PipelineTransport
Represents an HTTP pipeline transport used to send and receive HTTP requests
and responses.
using Microsoft.Extensions.Logging;
using System.ClientModel.Internal;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
namespace System.ClientModel.Primitives
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
public abstract class PipelineTransport : PipelinePolicy
{
[System.Runtime.CompilerServices.Nullable(2)]
private readonly PipelineTransportLogger _pipelineTransportLogger;
protected PipelineTransport()
{
}
[System.Runtime.CompilerServices.NullableContext(2)]
protected PipelineTransport(bool enableLogging, ILoggerFactory loggerFactory)
{
if (enableLogging)
_pipelineTransportLogger = new PipelineTransportLogger(loggerFactory);
}
public PipelineMessage CreateMessage()
{
PipelineMessage pipelineMessage;
PipelineMessage pipelineMessage2 = pipelineMessage = CreateMessageCore();
TimeSpan? networkTimeout = pipelineMessage.NetworkTimeout;
TimeSpan valueOrDefault = networkTimeout.GetValueOrDefault();
if (!networkTimeout.HasValue) {
valueOrDefault = ClientPipeline.DefaultNetworkTimeout;
TimeSpan? nullable2 = pipelineMessage.NetworkTimeout = valueOrDefault;
}
if (pipelineMessage2.Request == null)
throw new InvalidOperationException("Request was not set on message.");
if (pipelineMessage2.Response != null)
throw new InvalidOperationException("Response should not be set before transport is invoked.");
return pipelineMessage2;
}
protected abstract PipelineMessage CreateMessageCore();
public void Process(PipelineMessage message)
{
try {
ProcessSyncOrAsync(message, false).EnsureCompleted();
} catch (Exception exception) {
_pipelineTransportLogger?.LogExceptionResponse(message.Request.ClientRequestId ?? string.Empty, exception);
throw;
}
}
[AsyncStateMachine(typeof(<ProcessAsync>d__6))]
public ValueTask ProcessAsync(PipelineMessage message)
{
<ProcessAsync>d__6 stateMachine = default(<ProcessAsync>d__6);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.message = message;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<ProcessSyncOrAsync>d__7))]
private ValueTask ProcessSyncOrAsync(PipelineMessage message, bool async)
{
<ProcessSyncOrAsync>d__7 stateMachine = default(<ProcessSyncOrAsync>d__7);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.message = message;
stateMachine.async = async;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
protected abstract void ProcessCore(PipelineMessage message);
protected abstract ValueTask ProcessCoreAsync(PipelineMessage message);
private static bool ClassifyResponse(PipelineMessage message)
{
if (!message.ResponseClassifier.TryClassify(message, out bool isError))
PipelineMessageClassifier.Default.TryClassify(message, out isError);
return isError;
}
public sealed override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
{
Process(message);
}
[AsyncStateMachine(typeof(<ProcessAsync>d__12))]
public sealed override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
{
<ProcessAsync>d__12 stateMachine = default(<ProcessAsync>d__12);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.message = message;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
}
}