Introduction
On numerous occasions, it becomes necessary for a developer to perform retries. For example, when an application tries to access the DB to read data, or read from a file. We'll need our application to be able to retry, based on our own parameters, until it is successful, or until we want it to stop.
Using the Code
The library is a DLL which can be used in any application. It allows to specify a retry schedule. For example:
- Retry 20 times, every 5 seconds
- Retry 30 times, every minute
- Retry forever, every hour
Such a retry schedule will enable the application to retry until it succeeds. Building a schedule this way allows the developer to make sure that the network/CPU is not overloaded by retries for a long time. It is possible to specify multiple schedules. Each will follow the other when the previous one completes.
The retry manager accepts a delegate to a method (Thanks to Ramon for the tip). This delegate will call a function in the calling application. If that delegate returns false
or throws an exception, the retry manager will retry based on the schedule defined.
Each retry action also raises an event to the calling application, with the retry data. This allows the developer to log the retry events, notify the user, and manage them.
The attached console application tries to perform an activity with two retry schedules. As shown, it will first try to do something. After failure, it will retry three times every second. If it fails, it will try every 2 seconds, indefinitely.
static RetryTimer.RetryManager manager = new RetryTimer.RetryManager();
static void Main(string[] args)
{
Console.WriteLine("Trying...");
if (!TrySomething())
{
Console.WriteLine("Failed, Retrying");
manager.DoRetry += new RetryTimer.RetryHandler(manager_DoRetry);
manager.AddSchedule(RetryTimer.MeasurementUnit.Seconds, 3, 1);
manager.AddSchedule(RetryTimer.MeasurementUnit.Seconds, -1, 2);
RetryTimer.RetryCallback handler = TrySomething;
manager.Start(handler);
Console.ReadLine();
}
else
{
Console.WriteLine("Success!");
}
}
The retry event handler handles retrying and reports the results of the retry to the retry manager.
static void manager_DoRetry(object sender, RetryTimer.DoRetryEventArgs args)
{
Result = (string.Format("Retrying {0} of {1} every {2} {3} at {4}",
new object[] {args.CurrentRetry,
args.CurrentSchedule.RetryCount,
args.CurrentSchedule.UnitCount,
args.CurrentSchedule.UnitOfMeasure.ToString(),
DateTime.Now.ToString()}));
Console.WriteLine(Result);
}
The retry manager will call the delegate based on the schedule, until stopped or until the schedules are completed.
public void Start(RetryCallback callback)
{
StopRequested = false;
if (mScheduleList.Count == 0)
{
throw new Exception("No Schedules defined. Cannot Start");
}
bool successTry = false;
while (currentScheduleIndex <= (mScheduleList.Count - 1) &&
!successTry && !StopRequested)
{
while ((ElapsedCount <= mScheduleList[currentScheduleIndex].RetryCount ||
mScheduleList[currentScheduleIndex].RetryCount<0) &&
!successTry && !StopRequested)
{
try
{
if (callback())
{
successTry = true; ;
}
}
catch (Exception ex)
{
}
if (DoRetry != null)
{
DoRetry(this, new DoRetryEventArgs
(mScheduleList[currentScheduleIndex], ElapsedCount));
}
if (!successTry)
{
for (int numberOfUnits = 0;
numberOfUnits < mScheduleList
[currentScheduleIndex].UnitCount *
Convert.ToUInt32( mScheduleList
[currentScheduleIndex].UnitOfMeasure) / 1000;
numberOfUnits++)
{
System.Threading.Thread.Sleep(1000);
}
}
ElapsedCount++;
}
currentScheduleIndex++;
ElapsedCount = 1;
}
}
History
- 3rd November, 2008 - Initial release of the article
- 5th November, 2008 - Some changes and updates - especially using a delegate