FallbackHandler<T>
using Polly.Utils;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace Polly.Fallback
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
internal sealed class FallbackHandler<[System.Runtime.CompilerServices.Nullable(2)] T> : IEquatable<FallbackHandler<T>>
{
[CompilerGenerated]
private Type EqualityContract {
[CompilerGenerated]
get {
return typeof(FallbackHandler<T>);
}
}
public PredicateInvoker<HandleFallbackArguments> ShouldHandle { get; set; }
[System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
1,
0,
0,
1
})]
[field: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
1,
0,
0,
1
})]
public Func<OutcomeArguments<T, HandleFallbackArguments>, ValueTask<Outcome<T>>> ActionGenerator {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
1,
0,
0,
1
})]
get;
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
1,
0,
0,
1
})]
set;
}
public bool IsGeneric { get; set; }
public FallbackHandler(PredicateInvoker<HandleFallbackArguments> ShouldHandle, [System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
1,
0,
0,
1
})] Func<OutcomeArguments<T, HandleFallbackArguments>, ValueTask<Outcome<T>>> ActionGenerator, bool IsGeneric)
{
ShouldHandle = ShouldHandle;
ActionGenerator = ActionGenerator;
IsGeneric = IsGeneric;
base..ctor();
}
[System.Runtime.CompilerServices.NullableContext(2)]
public bool HandlesFallback<TResult>()
{
if (!this.IsGeneric)
return true;
return typeof(TResult) == typeof(T);
}
[System.Runtime.CompilerServices.NullableContext(2)]
[AsyncStateMachine(typeof(<GetFallbackOutcomeAsync>d__16<>))]
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
0,
1
})]
public ValueTask<Outcome<TResult>> GetFallbackOutcomeAsync<TResult>([System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})] OutcomeArguments<TResult, HandleFallbackArguments> args)
{
<GetFallbackOutcomeAsync>d__16<TResult> stateMachine = default(<GetFallbackOutcomeAsync>d__16<TResult>);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder<Outcome<TResult>>.Create();
stateMachine.<>4__this = this;
stateMachine.args = args;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[CompilerGenerated]
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("FallbackHandler");
stringBuilder.Append(" { ");
if (PrintMembers(stringBuilder))
stringBuilder.Append(' ');
stringBuilder.Append('}');
return stringBuilder.ToString();
}
[CompilerGenerated]
private bool PrintMembers(StringBuilder builder)
{
RuntimeHelpers.EnsureSufficientExecutionStack();
builder.Append("ShouldHandle = ");
builder.Append(ShouldHandle);
builder.Append(", ActionGenerator = ");
builder.Append(ActionGenerator);
builder.Append(", IsGeneric = ");
builder.Append(IsGeneric.ToString());
return true;
}
public static bool operator !=([System.Runtime.CompilerServices.Nullable(new byte[] {
2,
0
})] FallbackHandler<T> left, [System.Runtime.CompilerServices.Nullable(new byte[] {
2,
0
})] FallbackHandler<T> right)
{
return !(left == right);
}
public static bool operator ==([System.Runtime.CompilerServices.Nullable(new byte[] {
2,
0
})] FallbackHandler<T> left, [System.Runtime.CompilerServices.Nullable(new byte[] {
2,
0
})] FallbackHandler<T> right)
{
if ((object)left != right)
return left?.Equals(right) ?? false;
return true;
}
[CompilerGenerated]
public override int GetHashCode()
{
return ((EqualityComparer<Type>.Default.GetHashCode(EqualityContract) * -1521134295 + EqualityComparer<PredicateInvoker<HandleFallbackArguments>>.Default.GetHashCode(ShouldHandle)) * -1521134295 + EqualityComparer<Func<OutcomeArguments<T, HandleFallbackArguments>, ValueTask<Outcome<T>>>>.Default.GetHashCode(ActionGenerator)) * -1521134295 + EqualityComparer<bool>.Default.GetHashCode(IsGeneric);
}
[System.Runtime.CompilerServices.NullableContext(2)]
[CompilerGenerated]
public override bool Equals(object obj)
{
return Equals(obj as FallbackHandler<T>);
}
[CompilerGenerated]
public bool Equals([System.Runtime.CompilerServices.Nullable(new byte[] {
2,
0
})] FallbackHandler<T> other)
{
if ((object)this != other) {
if ((object)other != null && EqualityContract == other.EqualityContract && EqualityComparer<PredicateInvoker<HandleFallbackArguments>>.Default.Equals(ShouldHandle, other.ShouldHandle) && EqualityComparer<Func<OutcomeArguments<T, HandleFallbackArguments>, ValueTask<Outcome<T>>>>.Default.Equals(ActionGenerator, other.ActionGenerator))
return EqualityComparer<bool>.Default.Equals(IsGeneric, other.IsGeneric);
return false;
}
return true;
}
[CompilerGenerated]
private FallbackHandler([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0
})] FallbackHandler<T> original)
{
ShouldHandle = original.ShouldHandle;
ActionGenerator = original.ActionGenerator;
IsGeneric = original.IsGeneric;
}
[CompilerGenerated]
public void Deconstruct(out PredicateInvoker<HandleFallbackArguments> ShouldHandle, [System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
1,
0,
0,
1
})] out Func<OutcomeArguments<T, HandleFallbackArguments>, ValueTask<Outcome<T>>> ActionGenerator, out bool IsGeneric)
{
ShouldHandle = this.ShouldHandle;
ActionGenerator = this.ActionGenerator;
IsGeneric = this.IsGeneric;
}
}
}