RegistryPipelineComponentBuilder<TBuilder, TKey>
sealed class RegistryPipelineComponentBuilder<TBuilder, TKey> where TBuilder : ResiliencePipelineBuilderBase
Builds a PipelineComponent used by the registry.
using Polly.Telemetry;
using Polly.Utils.Pipeline;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
namespace Polly.Registry
{
[NullableContext(1)]
[Nullable(0)]
internal sealed class RegistryPipelineComponentBuilder<[Nullable(0)] TBuilder, TKey> where TBuilder : ResiliencePipelineBuilderBase
{
[Nullable(0)]
private sealed class Builder : IEquatable<Builder>
{
[CompilerGenerated]
private Type EqualityContract {
[CompilerGenerated]
get {
return typeof(Builder);
}
}
public Func<PipelineComponent> ComponentFactory { get; set; }
public List<CancellationToken> ReloadTokens { get; set; }
public ResilienceStrategyTelemetry Telemetry { get; set; }
public TBuilder Instance { get; set; }
public Builder(Func<PipelineComponent> ComponentFactory, List<CancellationToken> ReloadTokens, ResilienceStrategyTelemetry Telemetry, TBuilder Instance)
{
ComponentFactory = ComponentFactory;
ReloadTokens = ReloadTokens;
Telemetry = Telemetry;
Instance = Instance;
base..ctor();
}
[CompilerGenerated]
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("Builder");
stringBuilder.Append(" { ");
if (PrintMembers(stringBuilder))
stringBuilder.Append(' ');
stringBuilder.Append('}');
return stringBuilder.ToString();
}
[CompilerGenerated]
private bool PrintMembers(StringBuilder builder)
{
RuntimeHelpers.EnsureSufficientExecutionStack();
builder.Append("ComponentFactory = ");
builder.Append(ComponentFactory);
builder.Append(", ReloadTokens = ");
builder.Append(ReloadTokens);
builder.Append(", Telemetry = ");
builder.Append(Telemetry);
builder.Append(", Instance = ");
builder.Append(Instance);
return true;
}
public static bool operator !=([Nullable(new byte[] {
2,
0,
0
})] Builder left, [Nullable(new byte[] {
2,
0,
0
})] Builder right)
{
return !(left == right);
}
public static bool operator ==([Nullable(new byte[] {
2,
0,
0
})] Builder left, [Nullable(new byte[] {
2,
0,
0
})] Builder 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<Func<PipelineComponent>>.Default.GetHashCode(ComponentFactory)) * -1521134295 + EqualityComparer<List<CancellationToken>>.Default.GetHashCode(ReloadTokens)) * -1521134295 + EqualityComparer<ResilienceStrategyTelemetry>.Default.GetHashCode(Telemetry)) * -1521134295 + EqualityComparer<TBuilder>.Default.GetHashCode(Instance);
}
[NullableContext(2)]
[CompilerGenerated]
public override bool Equals(object obj)
{
return Equals(obj as Builder);
}
[CompilerGenerated]
public bool Equals([Nullable(new byte[] {
2,
0,
0
})] Builder other)
{
if ((object)this != other) {
if ((object)other != null && EqualityContract == other.EqualityContract && EqualityComparer<Func<PipelineComponent>>.Default.Equals(ComponentFactory, other.ComponentFactory) && EqualityComparer<List<CancellationToken>>.Default.Equals(ReloadTokens, other.ReloadTokens) && EqualityComparer<ResilienceStrategyTelemetry>.Default.Equals(Telemetry, other.Telemetry))
return EqualityComparer<TBuilder>.Default.Equals(Instance, other.Instance);
return false;
}
return true;
}
[CompilerGenerated]
private Builder([Nullable(new byte[] {
1,
0,
0
})] Builder original)
{
ComponentFactory = original.ComponentFactory;
ReloadTokens = original.ReloadTokens;
Telemetry = original.Telemetry;
Instance = original.Instance;
}
[CompilerGenerated]
public void Deconstruct(out Func<PipelineComponent> ComponentFactory, out List<CancellationToken> ReloadTokens, out ResilienceStrategyTelemetry Telemetry, out TBuilder Instance)
{
ComponentFactory = this.ComponentFactory;
ReloadTokens = this.ReloadTokens;
Telemetry = this.Telemetry;
Instance = this.Instance;
}
}
private readonly Func<TBuilder> _activator;
private readonly TKey _key;
private readonly string _builderName;
[Nullable(2)]
private readonly string _instanceName;
private readonly Action<TBuilder, ConfigureBuilderContext<TKey>> _configure;
public RegistryPipelineComponentBuilder(Func<TBuilder> activator, TKey key, string builderName, [Nullable(2)] string instanceName, Action<TBuilder, ConfigureBuilderContext<TKey>> configure)
{
_activator = activator;
_key = key;
_builderName = builderName;
_instanceName = instanceName;
_configure = configure;
}
[return: Nullable(new byte[] {
0,
2,
1
})]
internal (ResilienceContextPool ContextPool, PipelineComponent Component) CreateComponent()
{
Builder builder = CreateBuilder();
PipelineComponent pipelineComponent = builder.ComponentFactory();
if (builder.ReloadTokens.Count == 0)
return (builder.Instance.ContextPool, pipelineComponent);
pipelineComponent = PipelineComponentFactory.CreateReloadable(new ReloadableComponent.Entry(pipelineComponent, builder.ReloadTokens, builder.Telemetry), delegate {
Builder builder2 = CreateBuilder();
return new ReloadableComponent.Entry(builder2.ComponentFactory(), builder2.ReloadTokens, builder2.Telemetry);
});
return (builder.Instance.ContextPool, pipelineComponent);
}
[return: Nullable(new byte[] {
1,
0,
0
})]
private Builder CreateBuilder()
{
ConfigureBuilderContext<TKey> context = new ConfigureBuilderContext<TKey>(_key, _builderName, _instanceName);
TBuilder builder = _activator();
builder.Name = _builderName;
builder.InstanceName = _instanceName;
_configure(builder, context);
TimeProvider timeProvider = builder.TimeProviderInternal;
ResilienceStrategyTelemetry telemetry = new ResilienceStrategyTelemetry(new ResilienceTelemetrySource(builder.Name, builder.InstanceName, null), builder.TelemetryListener);
return new Builder(() => PipelineComponentFactory.WithExecutionTracking(PipelineComponentFactory.WithDisposableCallbacks(builder.BuildPipelineComponent(), context.DisposeCallbacks), timeProvider), context.ReloadTokens, telemetry, builder);
}
}
}