ACTUALIZACIÓN 5/2017
C# 6 filtros de excepción hacen la cláusula catch mucho más simple:
private static async Task<T> Retry<T>(Func<T> func, int retryCount)
{
while (true)
{
try
{
var result = await Task.Run(func);
return result;
}
catch when (retryCount-- > 0){}
}
}
y una versión recursiva:
private static async Task<T> Retry<T>(Func<T> func, int retryCount)
{
try
{
var result = await Task.Run(func);
return result;
}
catch when (retryCount-- > 0){}
return await Retry(func, retryCount);
}
ORIGINAL
Hay muchas maneras de codificar una función de reintento: se puede usar recursión o iteración tarea. Hubo un discussion en el grupo de usuarios griego .NET hace un tiempo sobre las diferentes formas de hacer exactamente esto.
Si está utilizando F # También se puede usar construcciones asíncronas. Desafortunadamente, no se pueden usar las construcciones async/await al menos en el Async CTP, porque al código generado por el compilador no le gustan los múltiples tiempos de espera o los posibles retiros en los bloques catch.
La versión recursiva es quizás la forma más sencilla de construir un reintento en C#.La siguiente versión no utiliza Separar y añade un retardo opcional antes reintentos:
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;
}
La función StartNewDelayed proviene de los ParallelExtensionsExtras muestras y utiliza un temporizador para activar un TaskCompletionSource cuando se produce el tiempo de espera.
La versión # F es mucho más simple:
let retry (asyncComputation : Async<'T>) (retryCount : int) : Async<'T> =
let rec retry' retryCount =
async {
try
let! result = asyncComputation
return result
with exn ->
if retryCount = 0 then
return raise exn
else
return! retry' (retryCount - 1)
}
retry' retryCount
Desafortunadamente, no es posible escribir algo similar en C# usando asíncrono/espera de la asíncrono CTP porque el compilador no le gusta declaraciones aguardan en el interior un bloque de captura. El siguiente intento también falla Silenty, debido a que el tiempo de ejecución no le gusta encontrarse con un descansar tras una excepción:
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--;
}
}
}
En cuanto a preguntar al usuario, puede modificar Reintentar para llamar a una función que pide al usuario y devuelve una tarea a través de un TaskCompletionSource para activar el siguiente paso cuando el usuario responde, por ejemplo:
private static Task<bool> AskUser()
{
var tcs = new TaskCompletionSource<bool>();
Task.Factory.StartNew(() =>
{
Console.WriteLine(@"Error Occured, continue? Y\N");
var response = Console.ReadKey();
tcs.SetResult(response.KeyChar=='y');
});
return tcs.Task;
}
private static Task<T> RetryAsk<T>(Func<T> func, int retryCount, 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
AskUser().ContinueWith(t =>
{
if (t.Result)
RetryAsk(func, retryCount - 1, tcs);
});
}
else
tcs.SetResult(_original.Result);
});
return tcs.Task;
}
con todas las continuaciones, se puede ver por qué una versión asíncrona de reintento es tan deseable.
ACTUALIZACIÓN:
En Visual Studio 2012 Beta las dos versiones siguientes trabajos:
Una versión con un bucle while:
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--;
}
}
}
y una versión recursiva:
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);
}
@svick no he tratado de implementar esta funcionalidad está llegando a una tarea futura, Parece que tenemos ideas interesantes ya, tiene que ir a través de ellos en detalle y darle una oportunidad –