İki eşzamansız görevi paralel olarak çalıştırın ve sonuçları .NET 4.5'te toplayın

Bir süredir .NET 4.5 ile çalışmanın basit olacağını düşündüğüm bir şeyi elde etmeye çalışıyorum.

İki uzun süreli görevi aynı anda başlatmak ve
sonuçları en iyi C # 4.5 (RTM) yöntemiyle toplamak istiyorum.

Aşağıdakiler çalışıyor ama hoşuma gitmiyor çünkü:

• Zaman Sleepuyumsuz bir yöntem olmak istiyorum , böylece awaitdiğer yöntemler olabilir
• Sadece beceriksiz görünüyor Task.Run()
• Bunun herhangi bir yeni dil özelliğini kullandığını bile düşünmüyorum!

Çalışma kodu:

public static void Go()
{
    Console.WriteLine("Starting");

    var task1 = Task.Run(() => Sleep(5000));    
    var task2 = Task.Run(() => Sleep(3000));

    int totalSlept = task1.Result + task2.Result;

    Console.WriteLine("Slept for a total of " + totalSlept + " ms");
}

private static int Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    Thread.Sleep(ms);
    Console.WriteLine("Sleeping for " + ms + " FINISHED");
    return ms;
}

Çalışmayan kod:

Güncelleme: Bu aslında işe yarıyor ve bunu yapmanın doğru yolu, tek sorun Thread.Sleep

Bu kod çalışmaz çünkü Sleep(5000)görevi hemen çalıştırma çağrısı Sleep(1000), tamamlanana kadar çalışmaz. Bu doğru olsa Sleepda asyncve çok erken kullanmıyorum awaitveya aramıyorum .Result.

Belki de Task<T>bir asyncyöntemi çağırarak çalışmayan bir çalışma yapmanın bir yolu olduğunu düşündüm, böylece daha sonra Start()iki görevi arayabilirim , ancak zaman Task<T>uyumsuz bir yöntemi çağırmaktan nasıl bir sonuç alacağımı bulamıyorum.

public static void Go()
{
    Console.WriteLine("Starting");

    var task1 = Sleep(5000);    // blocks
    var task2 = Sleep(1000);

    int totalSlept = task1.Result + task2.Result;

    Console.WriteLine("Slept for " + totalSlept + " ms");
}

private static async Task<int> Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    Thread.Sleep(ms);
    return ms;
}

Zaman uyumsuz programlama için Uyku yerine Task.Delay kullanmalı ve ardından görev sonuçlarını birleştirmek için Task.WhenAll kullanmalısınız. Görevler paralel olarak yürütülecekti.

public class Program
    {
        static void Main(string[] args)
        {
            Go();
        }
        public static void Go()
        {
            GoAsync();
            Console.ReadLine();
        }
        public static async void GoAsync()
        {

            Console.WriteLine("Starting");

            var task1 = Sleep(5000);
            var task2 = Sleep(3000);

            int[] result = await Task.WhenAll(task1, task2);

            Console.WriteLine("Slept for a total of " + result.Sum() + " ms");

        }

        private async static Task<int> Sleep(int ms)
        {
            Console.WriteLine("Sleeping for {0} at {1}", ms, Environment.TickCount);
            await Task.Delay(ms);
            Console.WriteLine("Sleeping for {0} finished at {1}", ms, Environment.TickCount);
            return ms;
        }
    }

async Task<int> LongTask1() { 
  ...
  return 0; 
}

async Task<int> LongTask2() { 
  ...
  return 1; 
}

...
{
   Task<int> t1 = LongTask1();
   Task<int> t2 = LongTask2();
   await Task.WhenAll(t1,t2);
   //now we have t1.Result and t2.Result
}

SleepYönteminiz eşzamansız iken Thread.Sleep, değildir. Zaman uyumsuzluğun tüm fikri, birden çok iş parçacığı başlatmak değil, tek bir iş parçacığını yeniden kullanmaktır. Thread.Sleep'e eşzamanlı bir arama yapmayı engellediğiniz için, işe yaramayacak.

Bunun Thread.Sleepgerçekte yapmak istediğiniz şeyin basitleştirilmesi olduğunu varsayıyorum . Gerçek uygulamanız eşzamansız yöntemler olarak kodlanabilir mi?

Birden fazla eşzamanlı engelleme çağrısı çalıştırmanız gerekiyorsa, düşündüğüm başka bir yere bakın!

Bu noktayı cevaplamak için:

Uykunun eşzamansız bir yöntem olmasını istiyorum, böylece diğer yöntemleri bekleyebilir

Sleepişlevi şu şekilde yeniden yazabilirsiniz :

private static async Task<int> Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    var task = Task.Run(() => Thread.Sleep(ms));
    await task;
    Console.WriteLine("Sleeping for " + ms + "END");
    return ms;
}

static void Main(string[] args)
{
    Console.WriteLine("Starting");

    var task1 = Sleep(2000);
    var task2 = Sleep(1000);

    int totalSlept = task1.Result +task2.Result;

    Console.WriteLine("Slept for " + totalSlept + " ms");
    Console.ReadKey();
}

bu kodu çalıştırdığınızda çıktı:

Starting
Sleeping for 2000
Sleeping for 1000
*(one second later)*
Sleeping for 1000END
*(one second later)*
Sleeping for 2000END
Slept for 3000 ms

Bu var haftasonu artık!

    public async void Go()
    {
        Console.WriteLine("Start fosterage...");

        var t1 = Sleep(5000, "Kevin");
        var t2 = Sleep(3000, "Jerry");
        var result = await Task.WhenAll(t1, t2);

        Console.WriteLine($"My precious spare time last for only {result.Max()}ms");
        Console.WriteLine("Press any key and take same beer...");
        Console.ReadKey();
    }

    private static async Task<int> Sleep(int ms, string name)
    {
            Console.WriteLine($"{name} going to sleep for {ms}ms :)");
            await Task.Delay(ms);
            Console.WriteLine("${name} waked up after {ms}ms :(";
            return ms;
    }

Bu makale birçok şeyi açıklamaya yardımcı oldu. SSS tarzında.

Zaman uyumsuz / Beklemede SSS

Bu bölüm, neden Thread.Sleepaynı orijinal iş parçacığı üzerinde çalıştığını açıklıyor - bu da benim ilk kafa karışıklığıma neden oluyor.

"Async" anahtar sözcüğü, bir yöntemin çağrılmasının ThreadPool'da sıraya girmesine neden olur mu? Yeni bir konu oluşturmak için? Mars'a bir roket gemisi fırlatmak için mi?

Hayır. Hayır. Ve hayır. Önceki sorulara bakın. "Async" anahtar sözcüğü derleyiciye, yöntemin bir bekleme noktasında askıya alınabileceği ve beklenen örnek tamamlandığında eşzamansız olarak yürütülmesine devam edebileceği şekilde, yöntemin içinde "await" kullanılabileceğini belirtir. Bu nedenle derleyici, "zaman uyumsuz" olarak işaretlenmiş bir yöntemin içinde "bekleme" yoksa bir uyarı verir.