Αυτό τον καιρό δουλεύω με ένα Rest API και θέλω να κάνω Retry αν κάποια κλήση αποτυγχάνει για ένα ορισμένο αριθμό επαναλήψεων. Βρήκα μία συζήτηση στο StackOverflow όπου ο Jon Skeet προτείνει τον παρακάτω κώδικα:

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos

Είτε με τον ένα, είτε με τον άλλο τρόπο, εφόσον πρόκειται για Retry (δηλαδή fail το προηγούμενο και try again) θα πρέπει να περιμένεις για να δεις αμα απέτυχε ή πέτυχε, αλλοιώς θες κώδικα για να δεις εάν πετύχανε και τα δύο κλπ.. Και το Wait γιατι δεν σ'αρεσει; Μια χαρά φαίνεται.

---

Παναγιώτης Κεφαλίδης

"Για να επιτύχεις, θα πρέπει το πάθος σου για την επιτυχία να είναι μεγαλύτερο απο τον φόβο σου για την αποτυχία"

Οι απαντήσεις παρέχονται για συγκεκριμένες ερωτήσεις και χωρίς καμιά εγγύηση. Παρακαλώ διαβάστε τους όρους χρήσης.

Το Wait σημαίνει καταρχήν ότι το thread που καλεί θα μπλοκάρει σε ένα ή περισσότερα σημεία. Επιπλέον, με εμποδίζει να να αλλάξω το signature της μεθόδου και να επιστρέψω π.χ. Task<T>. Να επιστρέψω απευθείας το task δεν γίνεται γιατί δεν έχω τρόπο να δω αν έχει πετύχει ή όχι. Θα μπορούσα για παράδειγμα να βάλω ένα ContinueWith αλλά εκεί μέσα δεν μπορώ να κάνω κάποιο loop ή επανεκτέλεση του ίδιου task.

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos

---

Palladinos Nick
Software Engineer
-----------------------
The limits of my language mean the limits of my world. (Ludwig Wittgenstein)

Νίκο, αμα ήταν να το κάνουμε σε άλλη γλώσσα ή με "πειραματικές" εκδόσεις (για την C#), τότε οκ.. Το θέμα οτι πρέπει να είναι ασύγχρονα, το ξέραμε απο την αρχή, αλλά η C#, ασύγχρονα έχει στην 5.. ή αμα περάσεις την CTP.. που δεν νομίζω να το θες (εννοώ με παρόμοιο syntax όπως η F#). Αλλοιώς η υλοποίηση πάει σε F# που λέει ο Νίκος, και το βγάζεις σαν Librabry?

---

Παναγιώτης Κεφαλίδης

"Για να επιτύχεις, θα πρέπει το πάθος σου για την επιτυχία να είναι μεγαλύτερο απο τον φόβο σου για την αποτυχία"

Οι απαντήσεις παρέχονται για συγκεκριμένες ερωτήσεις και χωρίς καμιά εγγύηση. Παρακαλώ διαβάστε τους όρους χρήσης.

---

Palladinos Nick
Software Engineer
-----------------------
The limits of my language mean the limits of my world. (Ludwig Wittgenstein)

Α να γεια σου ντε!

---

Παναγιώτης Κεφαλίδης

"Για να επιτύχεις, θα πρέπει το πάθος σου για την επιτυχία να είναι μεγαλύτερο απο τον φόβο σου για την αποτυχία"

Οι απαντήσεις παρέχονται για συγκεκριμένες ερωτήσεις και χωρίς καμιά εγγύηση. Παρακαλώ διαβάστε τους όρους χρήσης.

Το σκάλισα λίγο παραπάνω και βρήκα ένα τρόπο να αποφύγω το Unwrap αλλά και το return Task.Factory.StartNew(() => _original.Result); το οποίο υπάρχει μόνο για να γυρίσει το έτοιμο αποτέλεσμα σε μορφή Task. Ο παρακάτω κώδικας χρησιμοποιεί το TaskCompletionSource, μία κλάση η οποία επιστρέφει ένα task το οποίο ολοκληρώνεται μόνο αν κάποιος καλέσει τις μεθόδους SetResult, SetException, SetCancelled :

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos

Παναγιώτη η πρώτη σου τεχνική (δεν δοκίμασα την δεύτερη), κολλάει κάπου και τρέχει τον κώδικα για πάντα εφόσον συνεχίσει να "σκάει"

Παραθέτω εδώ την έκδοση του Νίκου αλλά με καθορισμό ενός Action σε περίπτωση που μετά το τέλος των retry δεν έχει επιτύχει, ώστε να μην κάνει throw o finalizer

        public static Task<T> Retry<T>(Func<T> original, int tryCount, Action<Exception> ifAllRetriesFail, int delayMs = 0)
        {
            return
                Task.Factory.StartNew(original).ContinueWith(_original =>
                {
                    if (_original.IsFaulted)
                    {
                        // call this so that TPL thinks we've caught all the exceptions
                        var flattened = _original.Exception.Flatten();
 
                        // assume it's faulted because of the options we specify
                        // for ContinueWith()
                        if (tryCount == 1)
                        // this is one so we control the total number 
                        // of tries and not retries
                        {
                            ifAllRetriesFail(flattened.InnerException);
                            return Task.Factory.StartNew(() => default(T));
                        }
                        // sleep baby
                        Thread.Sleep(delayMs);
                        return Retry(original, tryCount - 1, ifAllRetriesFail);
                    }
                    return Task<T>.Factory.StartNew(() => _original.Result);
                }).Unwrap();
        }

Έχεις δίκιο, στον έλεγχο του RetryCount λείπει το else. Έπρεπε να είναι

if (retryCount == 0)
    tcs.SetException(_original.Exception.InnerExceptions);
 else
    Retry(func, retryCount - 1, tcs);

αντί για

if (retryCount == 0)
    tcs.SetException(_original.Exception.InnerExceptions);
Retry(func, retryCount - 1, tcs);

 

Στον κώδικα του Νίκου έχεις κάνει μία "κακή" αλλαγή. Η προσθήκη του Thread.Sleep θα προκαλέσει πρόβλημα γιατί αχρηστεύει  ένα thread από το thread pool. Σκοπός του TPL είναι να απαλλαγούμε από απευθείας παρεμβάσεις στα threads.

Αν θέλεις να προσθέσεις κάποια καθυστέρηση, θα πρέπει να χρησιμοποιήσεις tasks για να κάνεις κάτι σαν την StartNewDelayed από τα ParallelExtensionExtras για να εκτελέσεις το Retry αφού περάσει το timeout. Σε αυτή την περίπτωση ο κώδικας αλλάζει στο παρακάτω:

 private static Task<T> Retry<T>(Func<T> func, int retryCount, int delay, TaskCompletionSource<T> tcs = null)
        {
            if (tcs == null)
                tcs = new TaskCompletionSource<T>();
            Task.Factory.StartNew(func).ContinueWith(_original =>
            {
                if (_original.IsFaulted)
                {
                    if (retryCount == 0)
                        tcs.SetException(_original.Exception.InnerExceptions);
                    else
                        Task.Factory.StartNewDelayed(delay).ContinueWith(t =>
                        {
                            Retry(func, retryCount - 1, delay,tcs);
                        });
                }
                else
                    tcs.SetResult(_original.Result);
            });
            return tcs.Task;
        }

Αυτό που προσπαθώ να κάνω να παίξει και κάτι πάει στραβά, είναι το Retry με async/await. Κανονικά ο παρακάτω κώδικας  θα έπρεπε να παίζει αλλά κρεμάει χωρίς καν unhandled exception, όταν κάνω compile σε Visual Studio 2010 με Async CTP.

private static async Task<T> Retry<T>(Func<T> func, int retryCount)
{
    while (true)
    {
        try
        {
            var result = await TaskEx.Run(func);
            return result;
        }
        catch 
        {
            if (retryCount == 0)
                throw;
            retryCount--;
        }
    }
}

 

Υποθέτω ότι το rewriting που κάνει ο compiler τουλάχιστον στο Async CTP αποτυγχάνει όταν δει παραπάνω από δύο exceptions στο catch. Επίσης, δεν μπορώ να έχω await μέσα στο catch, κάνοντας το Delay επίσης δύσκολο. Κρίμα, αν έπαιζε το Retry θα ήταν τόσο καθαρό όσο η αρχική έκδοση!

Όταν ο compiler συναντάει τα async/await keywords στην ουσία δημιουργεί ένα task iterator ο οποίος τρέχει ως ξεχωριστό task τον κώδικα μεταξύ των awaits. Τα πράγματα γίνονται δύσκολα όταν υπάρχει catch/finally και παρότι ο compiler κάνει αρκετά καλή δουλειά, δεν μπορείς να έχεις await μέσα σε catch ή finally, ενώ όπως φαίνεται παραπάνω, τα απανωτά exception προκαλούν εγκεφαλικό.

Όπως θα πει και ο Νίκος, το async της F# είναι ανώτερο από το αντίστοιχο του .NET

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos

Δοκίμασα το Retry με async στο Visual Studio 2011 και η μορφή με το while δουλεύει, ενώ η recursive μορφή που αντιστοιχεί στην F# θέλει μία μικρή αλλαγή.

Το παρακάτω δουλεύει:

        private static async Task<T> Retry<T>(Func<T> func, int retryCount)
        {
            while (true)
            {
                try
                {
                    var result = await Task.Run(func);
                    return result;
                }
                catch
                {
                    if (retryCount == 0)
                        throw;
                    retryCount--;
                }
            }
        }

Αυτή η έκδοση όμως δεν δουλεύει, γιατί δεν γίνεται δεκτό το await μέσα στο catch:

        private static async Task<T> Retry<T>(Func<T> func, int retryCount)
        {
            try
            {
                var result = await Task.Run(func);
                return result;
            }
            catch
            {
                if (retryCount == 0)
                    throw;
                return await Retry(func, --retryCount);
            }
        }

Ευτυχώς, μπορούμε άνετα να κάνουμε το Retry έξω από το catch, οπότε η παρακάτω μορφή δουλεύει:

        private static async Task<T> Retry<T>(Func<T> func, int retryCount)
        {
            try
            {
                var result = await Task.Run(func);
                return result;
            }
            catch
            {
                if (retryCount == 0)
                    throw;
            }
            return await Retry(func, --retryCount);
        }

 

 

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos