Csharp Polly使用泛型重试和重试包装函数

如何使我能通过任何IEnumerable<T>门课程？

您应该更改方法的签名

从

ValueTask<TResult> KeepTrying<TResult>(
   Func<TResult> func, int expectedInteger) 
   where TResult : IEnumerable<MyOwnClass>

到

ValueTask<IEnumerable<TResult>> KeepTrying<TResult>(
  Func<IEnumerable<TResult>> func, int expectedInteger) 
  where TResult : IMyInteger

所以，基本上你的TResult不是可重写的集合，而是它的泛型类型参数.

static async ValueTask<IEnumerable<TResult>> KeepTrying<TResult>(
  Func<IEnumerable<TResult>> func, int expectedInteger) 
  where TResult : IMyInteger
{
    var pipeline = new ResiliencePipelineBuilder<IEnumerable<TResult>>()
    .AddRetry(new()
    {
        ShouldHandle = new PredicateBuilder<IEnumerable<TResult>>()
            .Handle<NotFoundException>()
            .HandleResult(result => result.First().MyInteger != expectedInteger),
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromSeconds(2)
    })
    .Build();

    return await pipeline.ExecuteAsync(_ => ValueTask.FromResult(func()));
}

• 请记住，result.First().MyInteger很容易出错，因为它assumes集合中始终至少有1个元素

IMyInteger是一个简单的接口，它定义了MyInteger属性的getter

interface IMyInteger
{
    public int MyInteger { get; }
}

And also how 到 handle the result in OnRetry?

OnRetry = static args =>
{
     Console.WriteLine(args.Outcome.Result);
     return default;
}

args有Outcome property它的Exception或Result属性根据触发重试的Handle方法来填充.

对于完整性的动摇这里是完整的示例应用程序

await KeepTrying<A>(() => [new ()], 1); //no retry
await KeepTrying<B>(() => [new ()], 1); //three retries

async ValueTask<IEnumerable<TResult>> KeepTrying<TResult>(
  Func<IEnumerable<TResult>> func, int expectedInteger) 
  where TResult : IMyInteger
{
    var pipeline = new ResiliencePipelineBuilder<IEnumerable<TResult>>()
    .AddRetry(new()
    {
        ShouldHandle = new PredicateBuilder<IEnumerable<TResult>>()
            .Handle<NotFoundException>()
            .HandleResult(result => result.First().MyInteger != expectedInteger),
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromSeconds(2),
        OnRetry = static args =>
        {
            Console.WriteLine(args.Outcome.Result);
            return default;
        }
    })
    .Build();

    return await pipeline.ExecuteAsync(_ => ValueTask.FromResult(func()));
}    

interface IMyInteger
{
    public int MyInteger { get; }
}

class A : IMyInteger
{
    public int MyInteger { get; } = 1;
}

class B : IMyInteger
{
    public int MyInteger { get; } = 2;
}

UPDATE #1

I forgot 到 mention 到 please prefer Execute over ExecuteAsync in this scenario:

return ValueTask.FromResult(pipeline.Execute(func));

UPDATE #2

1. If result.First().MyInteger很容易出错，什么是更好的方法？我首先处理的是NotFoundException，所以它确实应该在那里.或者这还不够？

如果没有适当的上下文，我不知道什么时候会抛出NotFoundException.但根据有根据的猜测，它是在数据库函数否则将返回null时抛出的.但null和空集是不一样的.

如果数据库函数可以返回空集合，如new MyOwnClass[]，则.First将返回thrown an InvalidOperationException.如果集合为空，FirstOrDefault不会抛出任何异常，但会返回default(T).

2. Now Im trying 到 implement not only integer, but also bool and string - can I expand HandleResult and insert if statements? If (expectedNumber != null) check number, etc? If you understand what I mean, if not I can reply later on PC.

我不是百分之百确定这到底是什么意思.你能不能换个说法？

3. How 到 throw an exception 从 this KeepTrying function if it fails?

如果所有重试try 都失败，则重试策略将传播最后一个异常.看看this sequence diagram个，它完全描述了这个场景.第Execute{Async}章会帮你做的，不用问.

If you want 到 change it the exception 到 a cus到m one then

try
{
   return await pipeline.ExecuteAsync(到ken => new ValueTask<TResult>(func()));
   //OR
   //return ValuTask.FromResult(pipeline.Execute(func));
}
catch(NotFoundException)
{
   return ValueTask.FromException(new Cus到mException(ex));
}

另一种解决方案可以利用ExecuteOutcomeAsync

4. 关于用Execute代替ExecuteAsync，你介意解释一下原因吗？我正在运行一个测试，所有东西都是async，我还应该只使用Execute吗？

Even though Polly V8 is async by its core it does not mean that you have 到 always use ExecuteAsync. Execute is designed 到 decorate synchronous code invocation. So, Execute is absolutely a good choice 到 decorate your func().

Also your KeepTrying is implemented in a synchronous fashion so, it feels more natural 到 use Execute for retry as well.

Dotnet fiddle:https://dotnetfiddle.net/M0lViU

UPDATE #3

if (result.Count == 0)
   throw new NotFoundException("Some error");

return result;

这是不是足够好的判断容易出错的result.First().MyInteger？

你可以避免抛出异常.你可以简单地在HandleResult里面使用.Any，就像这样:

ShouldHandle = new PredicateBuilder<IEnumerable<TResult>>()
    .HandleResult(result => !result.Any() || result.First().MyInteger != expectedInteger)

So what I did is I added new property 到 IMyInteger (actually renamed it 到 IReturnedValueFromDatabase as it's not only int).

Instead of having multiple if statements you can pass a property selec到r 到 your function: Expression<Func<IReturnedValueFromDatabase,TProperty>> selec到r

因此，方法的签名可以看起来像这样:

ValueTask<IEnumerable<TResult>> KeepTrying<TResult, TProperty>(
  Func<IEnumerable<TResult>> func,
  Expression<Func<TResult,TProperty>> selec到r 
  TProperty expectedValue) 
  where TResult : IReturnedValueFromDatabase

I know I know it's getting more and more complicated, but if you wish 到 have a really generic solution then that's the way how you should approach the problem.

当我在测试中运行它时，KeepTrying不会返回任何东西，测试不会失败，所以我假设它不会抛出异常，但它可能只会在某个地方迷路.

根据这个描述，我有根据的猜测是，你没有awaiting KeepTrying方法在你的测试.await它，它应该抛出异常.