บางครั้งฉันจำเป็นต้องลองทำการผ่าตัดซ้ำหลายครั้งก่อนที่จะยอมแพ้ รหัสของฉันเหมือน:

int retries = 3;
while(true) {
  try {
    DoSomething();
    break; // success!
  } catch {
    if(--retries == 0) throw;
    else Thread.Sleep(1000);
  }
}

ฉันต้องการเขียนใหม่ในฟังก์ชันลองใหม่ทั่วไปเช่น:

TryThreeTimes(DoSomething);

เป็นไปได้ใน C #? รหัสสำหรับTryThreeTimes()วิธีการคืออะไร?

คำสั่งแบบครอบคลุมการจับที่เพียงแค่ลองโทรเดิมอาจเป็นอันตรายได้หากใช้เป็นกลไกการจัดการข้อยกเว้นทั่วไป ต้องบอกว่านี่เป็นเสื้อคลุมลองตีแลมด้าที่คุณสามารถใช้กับวิธีการใดก็ได้ ฉันเลือกที่จะคำนึงถึงจำนวนครั้งในการลองใหม่และการหมดเวลาลองอีกครั้งเป็นพารามิเตอร์เพื่อความยืดหยุ่นมากขึ้น:

public static class Retry
{
    public static void Do(
        Action action,
        TimeSpan retryInterval,
        int maxAttemptCount = 3)
    {
        Do<object>(() =>
        {
            action();
            return null;
        }, retryInterval, maxAttemptCount);
    }

    public static T Do<T>(
        Func<T> action,
        TimeSpan retryInterval,
        int maxAttemptCount = 3)
    {
        var exceptions = new List<Exception>();

        for (int attempted = 0; attempted < maxAttemptCount; attempted++)
        {
            try
            {
                if (attempted > 0)
                {
                    Thread.Sleep(retryInterval);
                }
                return action();
            }
            catch (Exception ex)
            {
                exceptions.Add(ex);
            }
        }
        throw new AggregateException(exceptions);
    }
}

ตอนนี้คุณสามารถใช้วิธีการยูทิลิตี้นี้เพื่อดำเนินการตรรกะลองใหม่:

Retry.Do(() => SomeFunctionThatCanFail(), TimeSpan.FromSeconds(1));

หรือ:

Retry.Do(SomeFunctionThatCanFail, TimeSpan.FromSeconds(1));

หรือ:

int result = Retry.Do(SomeFunctionWhichReturnsInt, TimeSpan.FromSeconds(1), 4);

หรือคุณอาจทำasyncเกินกำลัง

คุณควรพยายามพอลลี่ มันเป็น. NET ห้องสมุดที่เขียนโดยฉันที่ช่วยให้นักพัฒนาสามารถแสดงนโยบายการจัดการข้อยกเว้นชั่วคราวเช่นลองใหม่ลองใหม่ตลอดกาลรอและลองใหม่หรือ Circuit Breaker อย่างคล่องแคล่ว

ตัวอย่าง

Policy
    .Handle<SqlException>(ex => ex.Number == 1205)
    .Or<ArgumentException>(ex => ex.ParamName == "example")
    .WaitAndRetry(3, retryAttempt => TimeSpan.FromSeconds(3))
    .Execute(() => DoSomething());

นี่อาจเป็นความคิดที่ไม่ดี ประการแรกมันเป็นสัญลักษณ์ของคติพจน์สูงสุด "นิยามของความบ้ากำลังทำสิ่งเดียวกันสองครั้งและคาดหวังผลลัพธ์ที่แตกต่างกันในแต่ละครั้ง" ประการที่สองรูปแบบการเข้ารหัสนี้ไม่สามารถเขียนได้ดีกับตัวเอง ตัวอย่างเช่น:

สมมติว่าเลเยอร์ฮาร์ดแวร์เครือข่ายของคุณส่งแพ็กเก็ตอีกสามครั้งเมื่อเกิดความล้มเหลวรอพูดหนึ่งวินาทีระหว่างความล้มเหลว

ทีนี้สมมติว่าเลเยอร์ซอฟต์แวร์ส่งการแจ้งเตือนเกี่ยวกับความล้มเหลวสามครั้งในความล้มเหลวของแพ็กเก็ต

ตอนนี้สมมติว่าเลเยอร์การแจ้งเตือนเปิดใช้งานการแจ้งเตือนอีกสามครั้งเมื่อการส่งมอบการแจ้งเตือนล้มเหลว

ตอนนี้สมมติว่าชั้นการรายงานข้อผิดพลาดเปิดใช้งานเลเยอร์การแจ้งเตือนอีกสามครั้งเมื่อความล้มเหลวในการแจ้งเตือน

และตอนนี้สมมติว่าเว็บเซิร์ฟเวอร์เปิดใช้งานการรายงานข้อผิดพลาดอีกสามครั้งเมื่อเกิดข้อผิดพลาด

และตอนนี้สมมติว่าเว็บไคลเอ็นต์ส่งคำขออีกสามครั้งเมื่อได้รับข้อผิดพลาดจากเซิร์ฟเวอร์

ตอนนี้สมมติว่าบรรทัดบนสวิตช์เครือข่ายที่ควรจะกำหนดเส้นทางการแจ้งเตือนไปยังผู้ดูแลระบบไม่ได้เสียบปลั๊ก เมื่อใดที่ผู้ใช้เว็บไคลเอ็นต์ได้รับข้อความแสดงข้อผิดพลาดในที่สุด ฉันทำมันในอีกประมาณสิบสองนาทีต่อมา

เพื่อมิให้คุณคิดว่านี่เป็นเพียงตัวอย่างที่โง่เง่า: เราได้เห็นข้อบกพร่องนี้ในรหัสลูกค้าถึงแม้ว่าไกลยิ่งแย่กว่าที่ฉันเคยอธิบายไว้ที่นี่ ในรหัสลูกค้าโดยเฉพาะช่องว่างระหว่างเงื่อนไขข้อผิดพลาดที่เกิดขึ้นและในที่สุดก็ถูกรายงานไปยังผู้ใช้เป็นเวลาหลายสัปดาห์เพราะเลเยอร์จำนวนมากถูกลองใหม่โดยอัตโนมัติด้วยการรอ แค่คิดว่าจะเกิดอะไรขึ้นถ้ามีสิบลองใหม่แทนสามครั้งครั้ง

โดยปกติสิ่งที่ถูกต้องเกี่ยวกับเงื่อนไขข้อผิดพลาดจะรายงานทันทีและให้ผู้ใช้ตัดสินใจว่าจะทำอย่างไร หากผู้ใช้ต้องการสร้างนโยบายการลองใหม่โดยอัตโนมัติให้ผู้ใช้สร้างนโยบายนั้นในระดับที่เหมาะสมในซอฟต์แวร์นามธรรม

public void TryThreeTimes(Action action)
{
    var tries = 3;
    while (true) {
        try {
            action();
            break; // success!
        } catch {
            if (--tries == 0)
                throw;
            Thread.Sleep(1000);
        }
    }
}

จากนั้นคุณจะโทร:

TryThreeTimes(DoSomething);

... หรืออีกวิธีหนึ่ง ...

TryThreeTimes(() => DoSomethingElse(withLocalVariable));

ตัวเลือกที่ยืดหยุ่นมากขึ้น:

public void DoWithRetry(Action action, TimeSpan sleepPeriod, int tryCount = 3)
{
    if (tryCount <= 0)
        throw new ArgumentOutOfRangeException(nameof(tryCount));

    while (true) {
        try {
            action();
            break; // success!
        } catch {
            if (--tryCount == 0)
                throw;
            Thread.Sleep(sleepPeriod);
        }
   }
}

ที่จะใช้เป็น:

DoWithRetry(DoSomething, TimeSpan.FromSeconds(2), tryCount: 10);

รุ่นที่ทันสมัยกว่าพร้อมรองรับ async / คอย:

public async Task DoWithRetryAsync(Func<Task> action, TimeSpan sleepPeriod, int tryCount = 3)
{
    if (tryCount <= 0)
        throw new ArgumentOutOfRangeException(nameof(tryCount));

    while (true) {
        try {
            await action();
            return; // success!
        } catch {
            if (--tryCount == 0)
                throw;
            await Task.Delay(sleepPeriod);
        }
   }
}

ที่จะใช้เป็น:

await DoWithRetryAsync(DoSomethingAsync, TimeSpan.FromSeconds(2), tryCount: 10);

Transient Fault จัดการบล็อกโปรแกรมประยุกต์ให้เป็นคอลเลกชันของกลยุทธ์ขยายลองใหม่อีกครั้งรวมไปถึง:

• ที่เพิ่มขึ้น
• ช่วงเวลาคงที่
• การถอยกลับแบบเอ็กซ์โปเนนเชียล

นอกจากนี้ยังมีชุดของกลยุทธ์การตรวจจับข้อผิดพลาดสำหรับบริการบนคลาวด์

สำหรับข้อมูลเพิ่มเติมดูบทนี้ของคู่มือนักพัฒนาซอฟต์แวร์

พร้อมใช้งานผ่านNuGet (ค้นหา ' topaz ')

อนุญาตให้ใช้งานฟังก์ชั่นและลองใหม่ข้อความ

public static T RetryMethod<T>(Func<T> method, int numRetries, int retryTimeout, Action onFailureAction)
{
 Guard.IsNotNull(method, "method");            
 T retval = default(T);
 do
 {
   try
   {
     retval = method();
     return retval;
   }
   catch
   {
     onFailureAction();
      if (numRetries <= 0) throw; // improved to avoid silent failure
      Thread.Sleep(retryTimeout);
   }
} while (numRetries-- > 0);
  return retval;
}

คุณอาจลองเพิ่มประเภทข้อยกเว้นที่คุณต้องการลองอีกครั้ง เช่นนี้เป็นข้อยกเว้นการหมดเวลาที่คุณต้องการลองอีกครั้งหรือไม่ ข้อยกเว้นฐานข้อมูล

RetryForExcpetionType(DoSomething, typeof(TimeoutException), 5, 1000);

public static void RetryForExcpetionType(Action action, Type retryOnExceptionType, int numRetries, int retryTimeout)
{
    if (action == null)
        throw new ArgumentNullException("action");
    if (retryOnExceptionType == null)
        throw new ArgumentNullException("retryOnExceptionType");
    while (true)
    {
        try
        {
            action();
            return;
        }
        catch(Exception e)
        {
            if (--numRetries <= 0 || !retryOnExceptionType.IsAssignableFrom(e.GetType()))
                throw;

            if (retryTimeout > 0)
                System.Threading.Thread.Sleep(retryTimeout);
        }
    }
}

คุณอาจทราบว่าตัวอย่างอื่น ๆ ทั้งหมดมีปัญหาคล้ายกันกับการทดสอบการลองใหม่ == 0 และลองอีกครั้งโดยไม่มีที่สิ้นสุดหรือไม่สามารถเพิ่มข้อยกเว้นเมื่อได้รับค่าลบ สลีป (-1000) จะล้มเหลวในบล็อก catch ด้านบน ขึ้นอยู่กับว่า 'โง่' คุณคาดหวังว่าคนจะเป็น แต่การเขียนโปรแกรมการป้องกันไม่เจ็บ

ฉันเป็นแฟนตัวยงของวิธีการสอบถามซ้ำและการขยายดังนั้นสองเซนต์ของฉันคือ:

public static void InvokeWithRetries(this Action @this, ushort numberOfRetries)
{
    try
    {
        @this();
    }
    catch
    {
        if (numberOfRetries == 0)
            throw;

        InvokeWithRetries(@this, --numberOfRetries);
    }
}

จากการทำงานก่อนหน้านี้ฉันคิดถึงการปรับปรุงตรรกะลองใหม่ในสามวิธี:

1. การระบุประเภทข้อยกเว้นที่จะจับ / ลองใหม่ นี่คือการปรับปรุงหลักเนื่องจากการลองใหม่เพื่อข้อยกเว้นใด ๆ เป็นเพียงความผิดปกติ
2. ไม่ซ้อนการลองครั้งสุดท้ายในการลอง / จับการบรรลุประสิทธิภาพที่ดีขึ้นเล็กน้อย

3. ทำให้มันเป็นActionวิธีการขยาย

   static class ActionExtensions
   {
     public static void InvokeAndRetryOnException<T> (this Action action, int retries, TimeSpan retryDelay) where T : Exception
     {
       if (action == null)
         throw new ArgumentNullException("action");
   
       while( retries-- > 0 )
       {
         try
         {
           action( );
           return;
         }
         catch (T)
         {
           Thread.Sleep( retryDelay );
         }
       }
   
       action( );
     }
   }

วิธีการนั้นสามารถเรียกใช้เช่นนั้น (วิธีการที่ไม่ระบุชื่อสามารถใช้เช่นกันแน่นอน):

new Action( AMethodThatMightThrowIntermittentException )
  .InvokeAndRetryOnException<IntermittentException>( 2, TimeSpan.FromSeconds( 1 ) );

ทำให้มันง่ายด้วย C # 6.0

public async Task<T> Retry<T>(Func<T> action, TimeSpan retryInterval, int retryCount)
{
    try
    {
        return action();
    }
    catch when (retryCount != 0)
    {
        await Task.Delay(retryInterval);
        return await Retry(action, retryInterval, --retryCount);
    }
}

ใช้พอลลี่

https://github.com/App-vNext/Polly-Samples

นี่คือความพยายามทั่วไปที่ฉันใช้กับ Polly

public T Retry<T>(Func<T> action, int retryCount = 0)
{
    PolicyResult<T> policyResult = Policy
     .Handle<Exception>()
     .Retry(retryCount)
     .ExecuteAndCapture<T>(action);

    if (policyResult.Outcome == OutcomeType.Failure)
    {
        throw policyResult.FinalException;
    }

    return policyResult.Result;
}

ใช้มันแบบนี้

var result = Retry(() => MyFunction()), 3);

ปฏิบัติตามคำตอบของ LBushkin ในรูปแบบล่าสุด:

    public static async Task Do(Func<Task> task, TimeSpan retryInterval, int maxAttemptCount = 3)
    {
        var exceptions = new List<Exception>();
        for (int attempted = 0; attempted < maxAttemptCount; attempted++)
        {
            try
            {
                if (attempted > 0)
                {
                    await Task.Delay(retryInterval);
                }

                await task();
                return;
            }
            catch (Exception ex)
            {
                exceptions.Add(ex);
            }
        }
        throw new AggregateException(exceptions);
    }

    public static async Task<T> Do<T>(Func<Task<T>> task, TimeSpan retryInterval, int maxAttemptCount = 3)
    {
        var exceptions = new List<Exception>();
        for (int attempted = 0; attempted < maxAttemptCount; attempted++)
        {
            try
            {
                if (attempted > 0)
                {
                    await Task.Delay(retryInterval);
                }
                return await task();
            }
            catch (Exception ex)
            {
                exceptions.Add(ex);
            }
        }
        throw new AggregateException(exceptions);
    }  

และใช้งาน:

await Retry.Do([TaskFunction], retryInterval, retryAttempts);

ในขณะที่ฟังก์ชั่น[TaskFunction]สามารถเป็นได้ทั้งหรือเพียงแค่Task<T>Task

ฉันจะใช้สิ่งนี้:

public static bool Retry(int maxRetries, Func<bool, bool> method)
{
    while (maxRetries > 0)
    {
        if (method(maxRetries == 1))
        {
            return true;
        }
        maxRetries--;
    }
    return false;        
}

ฉันจะไม่ใช้ข้อยกเว้นวิธีที่พวกเขาใช้ในตัวอย่างอื่น ๆ ดูเหมือนว่าสำหรับฉันหากเราคาดหวังว่าจะมีวิธีการที่ไม่ประสบความสำเร็จความล้มเหลวของมันก็ไม่ใช่ข้อยกเว้น ดังนั้นวิธีการที่ฉันโทรควรกลับจริงถ้ามันประสบความสำเร็จและเท็จถ้ามันล้มเหลว

ทำไมมันFunc<bool, bool>และไม่ใช่แค่Func<bool>? ดังนั้นถ้าฉันต้องการวิธีที่จะสามารถยกเว้นความล้มเหลวฉันมีวิธีแจ้งว่านี่เป็นความพยายามครั้งสุดท้าย

ดังนั้นฉันอาจใช้กับรหัสเช่น:

Retry(5, delegate(bool lastIteration)
   {
       // do stuff
       if (!succeeded && lastIteration)
       {
          throw new InvalidOperationException(...)
       }
       return succeeded;
   });

หรือ

if (!Retry(5, delegate(bool lastIteration)
   {
       // do stuff
       return succeeded;
   }))
{
   Console.WriteLine("Well, that didn't work.");
}

หากผ่านพารามิเตอร์ที่เมธอดไม่ได้ใช้พิสูจน์ให้เห็นว่าอึดอัดใจมันเป็นเรื่องยากที่จะใช้โอเวอร์โหลดของRetryสิ่งนั้นก็ใช้เวลาFunc<bool>เช่นกัน

การถอยกลับแบบเอ็กซ์โปเนนเชียลเป็นกลยุทธ์การลองใหม่ที่ดีกว่าเพียงลองจำนวน x ครั้ง คุณสามารถใช้ไลบรารีอย่าง Polly เพื่อนำไปใช้งานได้

สำหรับผู้ที่ต้องการมีทั้งตัวเลือกให้ลองใหม่ในข้อยกเว้นใด ๆ หรือตั้งค่าประเภทข้อยกเว้นอย่างชัดเจนให้ใช้สิ่งนี้:

public class RetryManager 
{
    public void Do(Action action, 
                    TimeSpan interval, 
                    int retries = 3)
    {
        Try<object, Exception>(() => {
            action();
            return null;
        }, interval, retries);
    }

    public T Do<T>(Func<T> action, 
                    TimeSpan interval, 
                    int retries = 3)
    {
        return Try<T, Exception>(
              action
            , interval
            , retries);
    }

    public T Do<E, T>(Func<T> action, 
                       TimeSpan interval, 
                       int retries = 3) where E : Exception
    {
        return Try<T, E>(
              action
            , interval
            , retries);
    }

    public void Do<E>(Action action, 
                       TimeSpan interval, 
                       int retries = 3) where E : Exception
    {
        Try<object, E>(() => {
            action();
            return null;
        }, interval, retries);
    }

    private T Try<T, E>(Func<T> action, 
                       TimeSpan interval, 
                       int retries = 3) where E : Exception
    {
        var exceptions = new List<E>();

        for (int retry = 0; retry < retries; retry++)
        {
            try
            {
                if (retry > 0)
                    Thread.Sleep(interval);
                return action();
            }
            catch (E ex)
            {
                exceptions.Add(ex);
            }
        }

        throw new AggregateException(exceptions);
    }
}

ฉันต้องการวิธีการที่สนับสนุนการยกเลิกในขณะที่ฉันอยู่ที่นั่นฉันได้เพิ่มการสนับสนุนสำหรับการส่งคืนความล้มเหลวระดับกลาง

public static class ThreadUtils
{
    public static RetryResult Retry(
        Action target,
        CancellationToken cancellationToken,
        int timeout = 5000,
        int retries = 0)
    {
        CheckRetryParameters(timeout, retries)
        var failures = new List<Exception>();
        while(!cancellationToken.IsCancellationRequested)
        {
            try
            {
                target();
                return new RetryResult(failures);
            }
            catch (Exception ex)
            {
                failures.Add(ex);
            }

            if (retries > 0)
            {
                retries--;
                if (retries == 0)
                {
                    throw new AggregateException(
                     "Retry limit reached, see InnerExceptions for details.",
                     failures);
                }
            }

            if (cancellationToken.WaitHandle.WaitOne(timeout))
            {
                break;
            }
        }

        failures.Add(new OperationCancelledException(
            "The Retry Operation was cancelled."));
        throw new AggregateException("Retry was cancelled.", failures);
    }

    private static void CheckRetryParameters(int timeout, int retries)
    {
        if (timeout < 1)
        {
            throw new ArgumentOutOfRangeException(...
        }

        if (retries < 0)
        {
            throw new ArgumentOutOfRangeException(...

        }
    }

    public class RetryResult : IEnumerable<Exception>
    {
        private readonly IEnumerable<Exception> failureExceptions;
        private readonly int failureCount;

         protected internal RetryResult(
             ICollection<Exception> failureExceptions)
         {
             this.failureExceptions = failureExceptions;
             this.failureCount = failureExceptions.Count;
         }
    }

    public int FailureCount
    {
        get { return this.failureCount; }
    }

    public IEnumerator<Exception> GetEnumerator()
    {
        return this.failureExceptions.GetEnumerator();
    }

    System.Collections.IEnumerator 
        System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

คุณสามารถใช้Retryฟังก์ชั่นเช่นนี้ลองอีกครั้ง 3 ครั้งด้วยความล่าช้า 10 วินาที แต่ไม่มีการยกเลิก

try
{
    var result = ThreadUtils.Retry(
        SomeAction, 
        CancellationToken.None,
        10000,
        3);

    // it worked
    result.FailureCount // but failed this many times first.
}
catch (AggregationException ex)
{
   // oops, 3 retries wasn't enough.
}

หรือลองอีกครั้งในทุก ๆ ห้าวินาทีเว้นแต่จะถูกยกเลิก

try
{
    var result = ThreadUtils.Retry(
        SomeAction, 
        someTokenSource.Token);

    // it worked
    result.FailureCount // but failed this many times first.
}
catch (AggregationException ex)
{
   // operation was cancelled before success.
}

อย่างที่คุณสามารถคาดเดาได้ในซอร์สโค้ดของฉันฉันได้ใช้Retryฟังก์ชันมากเกินไปเพื่อรองรับเดลเกตชนิดต่าง ๆ ที่ฉันต้องการใช้

วิธีนี้อนุญาตให้ลองใหม่ในบางประเภทของข้อยกเว้น (ส่งต่อผู้อื่นทันที)

public static void DoRetry(
    List<Type> retryOnExceptionTypes,
    Action actionToTry,
    int retryCount = 5,
    int msWaitBeforeEachRety = 300)
{
    for (var i = 0; i < retryCount; ++i)
    {
        try
        {
            actionToTry();
            break;
        }
        catch (Exception ex)
        {
            // Retries exceeded
            // Throws on last iteration of loop
            if (i == retryCount - 1) throw;

            // Is type retryable?
            var exceptionType = ex.GetType();
            if (!retryOnExceptionTypes.Contains(exceptionType))
            {
                throw;
            }

            // Wait before retry
            Thread.Sleep(msWaitBeforeEachRety);
        }
    }
}
public static void DoRetry(
    Type retryOnExceptionType,
    Action actionToTry,
    int retryCount = 5,
    int msWaitBeforeEachRety = 300)
        => DoRetry(new List<Type> {retryOnExceptionType}, actionToTry, retryCount, msWaitBeforeEachRety);

ตัวอย่างการใช้งาน:

DoRetry(typeof(IOException), () => {
    using (var fs = new FileStream(requestedFilePath, FileMode.Create, FileAccess.Write))
    {
        fs.Write(entryBytes, 0, entryBytes.Length);
    }
});

อัปเดตหลังจาก 6 ปี:ตอนนี้ฉันพิจารณาแล้วว่าวิธีการด้านล่างค่อนข้างแย่ ในการสร้างตรรกะลองใหม่เราควรพิจารณาใช้ไลบรารีอย่างพอลลี่

asyncการนำวิธีการลองใหม่ไปใช้ของฉัน:

public static async Task<T> DoAsync<T>(Func<dynamic> action, TimeSpan retryInterval, int retryCount = 3)
    {
        var exceptions = new List<Exception>();

        for (int retry = 0; retry < retryCount; retry++)
        {
            try
            {
                return await action().ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                exceptions.Add(ex);
            }

            await Task.Delay(retryInterval).ConfigureAwait(false);
        }
        throw new AggregateException(exceptions);
    }

ประเด็นสำคัญ: ฉันใช้ .ConfigureAwait(false);และFunc<dynamic>แทนFunc<T>

หรือวิธีการเกี่ยวกับการทำมันค่อนข้าง neater ....

int retries = 3;
while (retries > 0)
{
  if (DoSomething())
  {
    retries = 0;
  }
  else
  {
    retries--;
  }
}

ฉันเชื่อว่าการหลีกเลี่ยงข้อยกเว้นการขว้างปาเป็นกลไกเว้นแต่ว่าคุณผ่านพวกเขาไประหว่างเขตแดน (เช่นการสร้างห้องสมุดที่คนอื่นสามารถใช้) ทำไมไม่เพียงแค่DoSomething()ส่งคืนคำสั่งtrueถ้ามันประสบความสำเร็จและfalseอื่น ๆ ?

แก้ไข:และสิ่งนี้สามารถห่อหุ้มภายในฟังก์ชั่นเหมือนที่คนอื่น ๆ ได้แนะนำเช่นกัน ปัญหาเดียวคือถ้าคุณไม่ได้เขียนDoSomething()ฟังก์ชั่นด้วยตัวเอง

ฉันต้องการส่งพารามิเตอร์ไปยังวิธีของฉันเพื่อลองอีกครั้งและมีค่าผลลัพธ์ ดังนั้นฉันต้องการนิพจน์ .. ฉันสร้างคลาสนี้ขึ้นมาซึ่งทำงาน (มันเป็นแรงบันดาลใจให้กับ LBushkin's one) คุณสามารถใช้มันได้:

static void Main(string[] args)
{
    // one shot
    var res = Retry<string>.Do(() => retryThis("try"), 4, TimeSpan.FromSeconds(2), fix);

    // delayed execute
    var retry = new Retry<string>(() => retryThis("try"), 4, TimeSpan.FromSeconds(2), fix);
    var res2 = retry.Execute();
}

static void fix()
{
    Console.WriteLine("oh, no! Fix and retry!!!");
}

static string retryThis(string tryThis)
{
    Console.WriteLine("Let's try!!!");
    throw new Exception(tryThis);
}

public class Retry<TResult>
{
    Expression<Func<TResult>> _Method;
    int _NumRetries;
    TimeSpan _RetryTimeout;
    Action _OnFailureAction;

    public Retry(Expression<Func<TResult>> method, int numRetries, TimeSpan retryTimeout, Action onFailureAction)
    {
        _Method = method;
        _NumRetries = numRetries;
        _OnFailureAction = onFailureAction;
        _RetryTimeout = retryTimeout;
    }

    public TResult Execute()
    {
        TResult result = default(TResult);
        while (_NumRetries > 0)
        {
            try
            {
                result = _Method.Compile()();
                break;
            }
            catch
            {
                _OnFailureAction();
                _NumRetries--;
                if (_NumRetries <= 0) throw; // improved to avoid silent failure
                Thread.Sleep(_RetryTimeout);
            }
        }
        return result;
    }

    public static TResult Do(Expression<Func<TResult>> method, int numRetries, TimeSpan retryTimeout, Action onFailureAction)
    {
        var retry = new Retry<TResult>(method, numRetries, retryTimeout, onFailureAction);
        return retry.Execute();
    }
}

PS โซลูชันของ LBushkin ลองอีกครั้ง = D

ฉันจะเพิ่มรหัสต่อไปนี้ในคำตอบที่ยอมรับ

public static class Retry<TException> where TException : Exception //ability to pass the exception type
    {
        //same code as the accepted answer ....

        public static T Do<T>(Func<T> action, TimeSpan retryInterval, int retryCount = 3)
        {
            var exceptions = new List<Exception>();

            for (int retry = 0; retry < retryCount; retry++)
            {
                try
                {
                    return action();
                }
                catch (TException ex) //Usage of the exception type
                {
                    exceptions.Add(ex);
                    Thread.Sleep(retryInterval);
                }
            }

            throw new AggregateException(String.Format("Failed to excecute after {0} attempt(s)", retryCount), exceptions);
        }
    }

โดยทั่วไปโค้ดด้านบนกำลังสร้างRetryคลาสทั่วไปเพื่อให้คุณสามารถส่งชนิดของข้อยกเว้นที่คุณต้องการตรวจสอบเพื่อลองใหม่

ตอนนี้ใช้มันเกือบจะในลักษณะเดียวกัน แต่การระบุประเภทข้อยกเว้น

Retry<EndpointNotFoundException>.Do(() => SomeFunctionThatCanFail(), TimeSpan.FromSeconds(1));

ฉันรู้ว่าคำตอบนี้เก่ามาก แต่ฉันแค่ต้องการแสดงความคิดเห็นเกี่ยวกับเรื่องนี้เพราะฉันมีปัญหาในการใช้สิ่งเหล่านี้ในขณะที่ทำอะไรก็ตามที่มีเคาน์เตอร์

ในช่วงหลายปีที่ผ่านมาฉันได้ตัดสินวิธีที่ดีกว่าที่ฉันคิด นั่นคือการใช้การรวมเหตุการณ์บางอย่างเช่นส่วนขยายปฏิกิริยา "เรื่อง" หรือสิ่งที่คล้าย เมื่อการลองล้มเหลวคุณเพียงแค่เผยแพร่เหตุการณ์ที่บอกว่าการลองล้มเหลวและมีฟังก์ชันการรวมตัวจัดกำหนดการเหตุการณ์อีกครั้ง วิธีนี้ช่วยให้คุณสามารถควบคุมการลองใหม่ได้มากขึ้นโดยไม่ทำให้เกิดการเรียกตัวเองด้วยการวนซ้ำของการลองซ้ำและสิ่งที่ไม่ คุณไม่ได้ผูกหัวข้อเดียวกับกลุ่มของ sleeps

ทำง่ายใน C #, Java หรือภาษาอื่น ๆ :

  internal class ShouldRetryHandler {
    private static int RETRIES_MAX_NUMBER = 3;
    private static int numberTryes;

    public static bool shouldRetry() {
        var statusRetry = false;

        if (numberTryes< RETRIES_MAX_NUMBER) {
            numberTryes++;
            statusRetry = true;
            //log msg -> 'retry number' + numberTryes

        }

        else {
            statusRetry = false;
            //log msg -> 'reached retry number limit' 
        }

        return statusRetry;
    }
}

และใช้ในรหัสของคุณง่ายมาก:

 void simpleMethod(){
    //some code

    if(ShouldRetryHandler.shouldRetry()){
    //do some repetitive work
     }

    //some code    
    }

หรือคุณสามารถใช้มันในวิธีแบบเรียกซ้ำ:

void recursiveMethod(){
    //some code

    if(ShouldRetryHandler.shouldRetry()){
    recursiveMethod();
     }

    //some code    
    }

int retries = 3;
while (true)
{
    try
    {
        //Do Somthing
        break;
    }
    catch (Exception ex)
    {
        if (--retries == 0)
            return Request.BadRequest(ApiUtil.GenerateRequestResponse(false, "3 Times tried it failed do to : " + ex.Message, new JObject()));
        else
            System.Threading.Thread.Sleep(100);
    }

ผู้ช่วยทดลองอีกครั้ง: การใช้งานจาวาทั่วไปที่มีทั้งความพยายามส่งคืนและโมฆะประเภท

import java.util.function.Supplier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class RetryHelper {
  private static final Logger log = LoggerFactory.getLogger(RetryHelper.class);
  private int retryWaitInMS;
  private int maxRetries;

  public RetryHelper() {
    this.retryWaitInMS = 300;
    this.maxRetries = 3;
  }

  public RetryHelper(int maxRetry) {
    this.maxRetries = maxRetry;
    this.retryWaitInMS = 300;
  }

  public RetryHelper(int retryWaitInSeconds, int maxRetry) {
    this.retryWaitInMS = retryWaitInSeconds;
    this.maxRetries = maxRetry;
  }

  public <T> T retryAndReturn(Supplier<T> supplier) {
    try {
      return supplier.get();
    } catch (Exception var3) {
      return this.retrySupplier(supplier);
    }
  }

  public void retry(Runnable runnable) {
    try {
      runnable.run();
    } catch (Exception var3) {
      this.retrySupplier(() -> {
        runnable.run();
        return null;
      });
    }

  }

  private <T> T retrySupplier(Supplier<T> supplier) {
    log.error("Failed <TASK>, will be retried " + this.maxRetries + " times.");
    int retryCounter = 0;

    while(retryCounter < this.maxRetries) {
      try {
        return supplier.get();
      } catch (Exception var6) {
        ++retryCounter;
        log.error("<TASK> failed on retry: " + retryCounter + " of " + this.maxRetries + " with error: " + var6.getMessage());
        if (retryCounter >= this.maxRetries) {
          log.error("Max retries exceeded.");
          throw var6;
        }

        try {
          Thread.sleep((long)this.retryWaitInMS);
        } catch (InterruptedException var5) {
          var5.printStackTrace();
        }
      }
    }

    return supplier.get();
  }

  public int getRetryWaitInMS() {
    return this.retryWaitInMS;
  }

  public int getMaxRetries() {
    return this.maxRetries;
  }
}

การใช้งาน:

    try {
      returnValue = new RetryHelper().retryAndReturn(() -> performSomeTask(args));
      //or no return type:
      new RetryHelper().retry(() -> mytask(args));
    } catch(Exception ex){
      log.error(e.getMessage());
      throw new CustomException();
    }

นี่คือasync/ awaitรุ่นที่รวมข้อยกเว้นและรองรับการยกเลิก

/// <seealso href="https://docs.microsoft.com/en-us/azure/architecture/patterns/retry"/>
protected static async Task<T> DoWithRetry<T>( Func<Task<T>> action, CancellationToken cancelToken, int maxRetries = 3 )
{
    var exceptions = new List<Exception>();

    for ( int retries = 0; !cancelToken.IsCancellationRequested; retries++ )
        try {
            return await action().ConfigureAwait( false );
        } catch ( Exception ex ) {
            exceptions.Add( ex );

            if ( retries < maxRetries )
                await Task.Delay( 500, cancelToken ).ConfigureAwait( false ); //ease up a bit
            else
                throw new AggregateException( "Retry limit reached", exceptions );
        }

    exceptions.Add( new OperationCanceledException( cancelToken ) );
    throw new AggregateException( "Retry loop was canceled", exceptions );
}

public delegate void ThingToTryDeletage();

public static void TryNTimes(ThingToTryDelegate, int N, int sleepTime)
{
   while(true)
   {
      try
      {
        ThingToTryDelegate();
      } catch {

            if( --N == 0) throw;
          else Thread.Sleep(time);          
      }
}

ฉันเขียนชั้นเรียนขนาดเล็กตามคำตอบที่โพสต์ไว้ที่นี่ หวังว่ามันจะช่วยให้ใครบางคน: https://github.com/natenho/resiliency

using System;
using System.Threading;

/// <summary>
/// Classe utilitária para suporte a resiliência
/// </summary>
public sealed class Resiliency
{
    /// <summary>
    /// Define o valor padrão de número de tentativas
    /// </summary>
    public static int DefaultRetryCount { get; set; }

    /// <summary>
    /// Define o valor padrão (em segundos) de tempo de espera entre tentativas
    /// </summary>
    public static int DefaultRetryTimeout { get; set; }

    /// <summary>
    /// Inicia a parte estática da resiliência, com os valores padrões
    /// </summary>
    static Resiliency()
    {
        DefaultRetryCount = 3;
        DefaultRetryTimeout = 0;
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente DefaultRetryCount vezes  quando for disparada qualquer <see cref="Exception"/> 
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <remarks>Executa uma vez e realiza outras DefaultRetryCount tentativas em caso de exceção. Não aguarda para realizar novas tentativa.</remarks>
    public static void Try(Action action)
    {
        Try<Exception>(action, DefaultRetryCount, TimeSpan.FromMilliseconds(DefaultRetryTimeout), null);
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente determinado número de vezes quando for disparada qualquer <see cref="Exception"/> 
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <param name="retryCount">Número de novas tentativas a serem realizadas</param>
    /// <param name="retryTimeout">Tempo de espera antes de cada nova tentativa</param>
    public static void Try(Action action, int retryCount, TimeSpan retryTimeout)
    {
        Try<Exception>(action, retryCount, retryTimeout, null);
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente determinado número de vezes quando for disparada qualquer <see cref="Exception"/> 
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <param name="retryCount">Número de novas tentativas a serem realizadas</param>
    /// <param name="retryTimeout">Tempo de espera antes de cada nova tentativa</param>
    /// <param name="tryHandler">Permitindo manipular os critérios para realizar as tentativas</param>
    public static void Try(Action action, int retryCount, TimeSpan retryTimeout, Action<ResiliencyTryHandler<Exception>> tryHandler)
    {
        Try<Exception>(action, retryCount, retryTimeout, tryHandler);
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente por até DefaultRetryCount vezes quando for disparada qualquer <see cref="Exception"/> 
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <param name="tryHandler">Permitindo manipular os critérios para realizar as tentativas</param>
    /// <remarks>Executa uma vez e realiza outras DefaultRetryCount tentativas em caso de exceção. Aguarda DefaultRetryTimeout segundos antes de realizar nova tentativa.</remarks>
    public static void Try(Action action, Action<ResiliencyTryHandler<Exception>> tryHandler)
    {
        Try<Exception>(action, DefaultRetryCount, TimeSpan.FromSeconds(DefaultRetryTimeout), null);
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente determinado número de vezes quando for disparada qualquer <see cref="TException"/> 
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <remarks>Executa uma vez e realiza outras DefaultRetryCount tentativas em caso de exceção. Aguarda DefaultRetryTimeout segundos antes de realizar nova tentativa.</remarks>
    public static void Try<TException>(Action action) where TException : Exception
    {
        Try<TException>(action, DefaultRetryCount, TimeSpan.FromSeconds(DefaultRetryTimeout), null);
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente determinado número de vezes quando for disparada qualquer <see cref="TException"/> 
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <param name="retryCount"></param>
    public static void Try<TException>(Action action, int retryCount) where TException : Exception
    {
        Try<TException>(action, retryCount, TimeSpan.FromSeconds(DefaultRetryTimeout), null);
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente determinado número de vezes quando for disparada qualquer <see cref="Exception"/> 
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <param name="retryCount"></param>
    /// <param name="retryTimeout"></param>
    public static void Try<TException>(Action action, int retryCount, TimeSpan retryTimeout) where TException : Exception
    {
        Try<TException>(action, retryCount, retryTimeout, null);
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente determinado número de vezes quando for disparada qualquer <see cref="Exception"/> 
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <param name="tryHandler">Permitindo manipular os critérios para realizar as tentativas</param>
    /// <remarks>Executa uma vez e realiza outras DefaultRetryCount tentativas em caso de exceção. Aguarda DefaultRetryTimeout segundos antes de realizar nova tentativa.</remarks>
    public static void Try<TException>(Action action, Action<ResiliencyTryHandler<TException>> tryHandler) where TException : Exception
    {
        Try(action, DefaultRetryCount, TimeSpan.FromSeconds(DefaultRetryTimeout), tryHandler);
    }

    /// <summary>
    /// Executa uma <see cref="Action"/> e tenta novamente determinado número de vezes quando for disparada uma <see cref="Exception"/> definida no tipo genérico
    /// </summary>
    /// <param name="action">Ação a ser realizada</param>
    /// <param name="retryCount">Número de novas tentativas a serem realizadas</param>
    /// <param name="retryTimeout">Tempo de espera antes de cada nova tentativa</param>
    /// <param name="tryHandler">Permitindo manipular os critérios para realizar as tentativas</param>
    /// <remarks>Construído a partir de várias ideias no post <seealso cref="http://stackoverflow.com/questions/156DefaultRetryCount191/c-sharp-cleanest-way-to-write-retry-logic"/></remarks>
    public static void Try<TException>(Action action, int retryCount, TimeSpan retryTimeout, Action<ResiliencyTryHandler<TException>> tryHandler) where TException : Exception
    {
        if (action == null)
            throw new ArgumentNullException(nameof(action));

        while (retryCount-- > 0)
        {
            try
            {
                action();
                return;
            }
            catch (TException ex)
            {
                //Executa o manipulador de exception
                if (tryHandler != null)
                {
                    var callback = new ResiliencyTryHandler<TException>(ex, retryCount);
                    tryHandler(callback);
                    //A propriedade que aborta pode ser alterada pelo cliente
                    if (callback.AbortRetry)
                        throw;
                }

                //Aguarda o tempo especificado antes de tentar novamente
                Thread.Sleep(retryTimeout);
            }
        }

        //Na última tentativa, qualquer exception será lançada de volta ao chamador
        action();
    }

}

/// <summary>
/// Permite manipular o evento de cada tentativa da classe de <see cref="Resiliency"/>
/// </summary>
public class ResiliencyTryHandler<TException> where TException : Exception
{
    #region Properties

    /// <summary>
    /// Opção para abortar o ciclo de tentativas
    /// </summary>
    public bool AbortRetry { get; set; }

    /// <summary>
    /// <see cref="Exception"/> a ser tratada
    /// </summary>
    public TException Exception { get; private set; }

    /// <summary>
    /// Identifca o número da tentativa atual
    /// </summary>
    public int CurrentTry { get; private set; }

    #endregion

    #region Constructors

    /// <summary>
    /// Instancia um manipulador de tentativa. É utilizado internamente
    /// por <see cref="Resiliency"/> para permitir que o cliente altere o
    /// comportamento do ciclo de tentativas
    /// </summary>
    public ResiliencyTryHandler(TException exception, int currentTry)
    {
        Exception = exception;
        CurrentTry = currentTry;
    }

    #endregion

}

ฉันใช้คำตอบที่ยอมรับแล้วในเวอร์ชัน async - และดูเหมือนว่าจะใช้งานได้ดี - มีความคิดเห็นอะไรบ้าง?

        public static async Task DoAsync(
            Action action,
            TimeSpan retryInterval,
            int maxAttemptCount = 3)
        {
            DoAsync<object>(() =>
            {
                action();
                return null;
            }, retryInterval, maxAttemptCount);
        }

        public static async Task<T> DoAsync<T>(
            Func<Task<T>> action,
            TimeSpan retryInterval,
            int maxAttemptCount = 3)
        {
            var exceptions = new List<Exception>();

            for (int attempted = 0; attempted < maxAttemptCount; attempted++)
            {
                try
                {
                    if (attempted > 0)
                    {
                        Thread.Sleep(retryInterval);
                    }
                    return await action();
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }
            throw new AggregateException(exceptions);
        }

และเรียกมันว่าเป็นอย่างนี้:

var result = await Retry.DoAsync(() => MyAsyncMethod(), TimeSpan.FromSeconds(5), 4);