Assync method in C# .net 4.0

Assync method in C# .net 4.0
2016-01-23T14:26:18+01:00
2016-01-25T17:04:57+01:00
2022-10-15T21:51:39+02:00
*deleted_63687882
Hali,

Eddig .NET 4.5-re -tel programoztam. Most viszont 4.0-val szeretnék megismerkedni. Viszont nagyon sok különbség van, többek között az, hogy nem találom hogyan tudom async method-ot indítani.

.NET 4.5-ben ez lenne a megoldás:

public async Task MyPublicAsyncTask() { await MyAsyncTask(); } private async Task MyAsyncTask() { await Task.Delay.... }


A kérdésem az, hogy miként lehet ugyanezt elérni .NET 4.0-ban?
Mutasd a teljes hozzászólást!
csak a lényeget


class Tasker
    {
        public void Run()
        {
            // task létrhozása és indítása
            var task1 = new Task(SimpleMethod);
            task1.Start();
            Thread.Sleep(100);

            //ugyanaz mint az előző, csak egyszerűbben
            var task2 = Task.Factory.StartNew(SimpleMethod);
            Thread.Sleep(100);

            // task paraméterrel és visszatérő értékkel
            var task3 = Task<int>.Factory.StartNew(() => MethodWithReturnValue("Hello world"));
            Console.WriteLine("Wait for task result");
            int length = task3.Result;
            Console.WriteLine("string length: {0}", length);
           
            // task futtatása az előző task befejezése után
            var task4 = Task.Factory.StartNew(SimpleMethod);
            task4.ContinueWith(task => SimpleMethod2());
            Thread.Sleep(50);
            Console.WriteLine("the Simplemethod2 text message will be visible after this text");


            // task megszakítása úgy, hogy a Task nem tud róla (a task status Faulted lesz)
            var cancellationTokenSource = new CancellationTokenSource();
            var task5 = Task.Factory.StartNew(() => CancellableMethod(cancellationTokenSource.Token));
            Thread.Sleep(100);
            Console.WriteLine("Task megszakítása. Mint láthatod ez csak akkor történik meg, amikor a függvényedben erre rákérdezel (menedzselt megszakítás)");
            cancellationTokenSource.Cancel();
            try
            {
                // kivételt (a cancel miatt) csak akkor kapsz, ha bevárod a taskot
                task5.Wait();
            }
            catch (AggregateException e)
            {
                // mivel megszakítottad és Wait-el be is vártad, ezért kivételt kaptál
                // a task Faulted állapotba kerül
                Console.WriteLine(task5.Status);
            }

            // task megszakítása úgy, hogy a TASK TUD róla (a task status Cancelled lesz)
            var cancellationTokenSource2 = new CancellationTokenSource();
            var task6 = Task.Factory.StartNew(() => CancellableMethod(cancellationTokenSource2.Token), cancellationTokenSource2.Token);
            Thread.Sleep(100);
            Console.WriteLine("Task megszakítása. Mint láthatod ez csak akkor történik meg, amikor a függvényedben erre rákérdezel (menedzselt megszakítás)");
            cancellationTokenSource2.Cancel();
            try
            {
                // kivételt (a cancel miatt) csak akkor kapsz, ha bevárod a taskot
                task6.Wait();
            }
            catch (AggregateException e)
            {
                // mivel megszakítottad és Wait-el be is vártad, ezért kivételt kaptál
                // a task Cancelled állapotba kerül
                Console.WriteLine(task6.Status);
            }


            // feltételes task folytatás
            // az alábbi bool értéket állítsd át
            // láthatod, hogy a két ContinueWith közül csak az egyik fog lefutni, attól függően, hogy mi a TaskContinuationOptions
            var throwException = false;
            var task7 = Task.Factory.StartNew(() => ExceptionMethod(throwException));
            task7.ContinueWith(task => Console.WriteLine("Exception"), TaskContinuationOptions.NotOnRanToCompletion);
            task7.ContinueWith(task => Console.WriteLine("Success"), TaskContinuationOptions.OnlyOnRanToCompletion);

            // ritkán használatos, de ha UI-t akar frissiteni, akkor a taskContinueWith-et így is használhatod (feltéve, hogy a komplett task UI szálról indult)
            // ahogy látom console-ban le se fut
            var task8 = Task.Factory.StartNew(() => Thread.Sleep(200));
            //task8.ContinueWith(t => Console.WriteLine("Itt lehet a UI-t frissiteni, ha akarod"),TaskScheduler.FromCurrentSynchronizationContext());


            // taskok megvárása
            var task9 = Task.Factory.StartNew(() => Thread.Sleep(200));
            var task10 = Task.Factory.StartNew(() => Thread.Sleep(500));
            var task11 = Task.Factory.StartNew(() => Thread.Sleep(1000));
            Task.WaitAll(task9, task10, task11); // mindet bevárja
            Task.WaitAny(task9, task10, task11); // csak egyet vár be, utána megy tovább


        }

        private void SimpleMethod()
        {
            Console.WriteLine("Simple task is running");
        }

        private void SimpleMethod2()
        {
            Thread.Sleep(200);
            Console.WriteLine("Another simple task is running");
        }

        private int MethodWithReturnValue(string s)
        {
            Thread.Sleep(1000);
            return s.Length;
        }

        private void CancellableMethod(CancellationToken token)
        {
            Console.WriteLine("this method can be cancelled");
            Thread.Sleep(1000);
            token.ThrowIfCancellationRequested();
        }

        private void ExceptionMethod(bool rasieException)
        {
            Thread.Sleep(500);
            if (rasieException)
            {
                Console.WriteLine("task throws exception");
                throw new Exception("Hiba");
            }
            else
            {
                Console.WriteLine("task succesfuly finished");
            }
        }

    }
Mutasd a teljes hozzászólást!

  • Mutasd a teljes hozzászólást!
  • Szerintem akkor be is zárhatjuk az ilyen típusú oldalakat, mert a google-ben mindent meglehet találni  

    Megjegyzem a "Microsoft Async"-t feltelepítettem, de dokumentációt nem találtam hozzá. Nem is úgy működik, ahogy arra számítottam. (doksi nélkül nehéz vele elindulni)

    Illetve a téma nem megoldott amit belinkeltél.

    ingyen ház: (7 620 000 találat )
    (ingyen ház - Google keresés)
    Mutasd a teljes hozzászólást!
  • Most viszont 4.0-val szeretnék megismerkedni.

    FYI: a .NET 4.5 a 4.0-ra épül, és a legkisebb támogatott verzió a .NET 4.5.2.
    Mutasd a teljes hozzászólást!
  • Windows XP alatt csak 4.0 megy.
    Mutasd a teljes hozzászólást!
  • FYI: a legkisebb támogatott Windows verzió a Vista.

    Nemcsak biztonsági frissítésekről van szó: van egy (na jó, kisebb) halom bug, amit a Microsoft csak a 4.5-ben javított. Ha pont beleszaladsz egybe, akkor úgysem tudsz mit csinálni, csak újabb framework-öt célozni.

    Megjegyezném, hogy gazdasági szempontokat figyelembevéve általában nem nagyon éri meg nem támogatott rendszereken való futást támogatni, mert aki ezen spórol, az rajtad is fog, miközben értékes erőforrásokat vesztegetsz el miattuk (ld. kerülőút keresése async/await-hez).
    Mutasd a teljes hozzászólást!
  • csak a lényeget


    class Tasker
        {
            public void Run()
            {
                // task létrhozása és indítása
                var task1 = new Task(SimpleMethod);
                task1.Start();
                Thread.Sleep(100);

                //ugyanaz mint az előző, csak egyszerűbben
                var task2 = Task.Factory.StartNew(SimpleMethod);
                Thread.Sleep(100);

                // task paraméterrel és visszatérő értékkel
                var task3 = Task<int>.Factory.StartNew(() => MethodWithReturnValue("Hello world"));
                Console.WriteLine("Wait for task result");
                int length = task3.Result;
                Console.WriteLine("string length: {0}", length);
               
                // task futtatása az előző task befejezése után
                var task4 = Task.Factory.StartNew(SimpleMethod);
                task4.ContinueWith(task => SimpleMethod2());
                Thread.Sleep(50);
                Console.WriteLine("the Simplemethod2 text message will be visible after this text");


                // task megszakítása úgy, hogy a Task nem tud róla (a task status Faulted lesz)
                var cancellationTokenSource = new CancellationTokenSource();
                var task5 = Task.Factory.StartNew(() => CancellableMethod(cancellationTokenSource.Token));
                Thread.Sleep(100);
                Console.WriteLine("Task megszakítása. Mint láthatod ez csak akkor történik meg, amikor a függvényedben erre rákérdezel (menedzselt megszakítás)");
                cancellationTokenSource.Cancel();
                try
                {
                    // kivételt (a cancel miatt) csak akkor kapsz, ha bevárod a taskot
                    task5.Wait();
                }
                catch (AggregateException e)
                {
                    // mivel megszakítottad és Wait-el be is vártad, ezért kivételt kaptál
                    // a task Faulted állapotba kerül
                    Console.WriteLine(task5.Status);
                }

                // task megszakítása úgy, hogy a TASK TUD róla (a task status Cancelled lesz)
                var cancellationTokenSource2 = new CancellationTokenSource();
                var task6 = Task.Factory.StartNew(() => CancellableMethod(cancellationTokenSource2.Token), cancellationTokenSource2.Token);
                Thread.Sleep(100);
                Console.WriteLine("Task megszakítása. Mint láthatod ez csak akkor történik meg, amikor a függvényedben erre rákérdezel (menedzselt megszakítás)");
                cancellationTokenSource2.Cancel();
                try
                {
                    // kivételt (a cancel miatt) csak akkor kapsz, ha bevárod a taskot
                    task6.Wait();
                }
                catch (AggregateException e)
                {
                    // mivel megszakítottad és Wait-el be is vártad, ezért kivételt kaptál
                    // a task Cancelled állapotba kerül
                    Console.WriteLine(task6.Status);
                }


                // feltételes task folytatás
                // az alábbi bool értéket állítsd át
                // láthatod, hogy a két ContinueWith közül csak az egyik fog lefutni, attól függően, hogy mi a TaskContinuationOptions
                var throwException = false;
                var task7 = Task.Factory.StartNew(() => ExceptionMethod(throwException));
                task7.ContinueWith(task => Console.WriteLine("Exception"), TaskContinuationOptions.NotOnRanToCompletion);
                task7.ContinueWith(task => Console.WriteLine("Success"), TaskContinuationOptions.OnlyOnRanToCompletion);

                // ritkán használatos, de ha UI-t akar frissiteni, akkor a taskContinueWith-et így is használhatod (feltéve, hogy a komplett task UI szálról indult)
                // ahogy látom console-ban le se fut
                var task8 = Task.Factory.StartNew(() => Thread.Sleep(200));
                //task8.ContinueWith(t => Console.WriteLine("Itt lehet a UI-t frissiteni, ha akarod"),TaskScheduler.FromCurrentSynchronizationContext());


                // taskok megvárása
                var task9 = Task.Factory.StartNew(() => Thread.Sleep(200));
                var task10 = Task.Factory.StartNew(() => Thread.Sleep(500));
                var task11 = Task.Factory.StartNew(() => Thread.Sleep(1000));
                Task.WaitAll(task9, task10, task11); // mindet bevárja
                Task.WaitAny(task9, task10, task11); // csak egyet vár be, utána megy tovább


            }

            private void SimpleMethod()
            {
                Console.WriteLine("Simple task is running");
            }

            private void SimpleMethod2()
            {
                Thread.Sleep(200);
                Console.WriteLine("Another simple task is running");
            }

            private int MethodWithReturnValue(string s)
            {
                Thread.Sleep(1000);
                return s.Length;
            }

            private void CancellableMethod(CancellationToken token)
            {
                Console.WriteLine("this method can be cancelled");
                Thread.Sleep(1000);
                token.ThrowIfCancellationRequested();
            }

            private void ExceptionMethod(bool rasieException)
            {
                Thread.Sleep(500);
                if (rasieException)
                {
                    Console.WriteLine("task throws exception");
                    throw new Exception("Hiba");
                }
                else
                {
                    Console.WriteLine("task succesfuly finished");
                }
            }

        }
    Mutasd a teljes hozzászólást!
  • Nagyon klassz összefoglaló!

    Annyival kiegészíteném, hogy - ha már async kódról beszélünk - Thread.Sleep() helyett célszerű Task-on belül inkább Task.Delay()-t használni, mert ez utóbbi nem fogja blokkolni a szálat.
    Mutasd a teljes hozzászólást!
  • 4.0 -ban még nem volt task delay
    Mutasd a teljes hozzászólást!
  • Na, ezt nem tudtam.

    Újabb ok, amiért nincs értelme 4.0-t célozni.

    Köszi
    Mutasd a teljes hozzászólást!
Tetszett amit olvastál? Szeretnél a jövőben is értesülni a hasonló érdekességekről?
abcd