ASP.NET Web API 框架研究 Self Host模式下的消息处理管道

时间：2022-05-17 16:20:36

　　Self Host模式下的ASP.NET Web API与WCF非常相似，都可以寄宿在任意类型的托管应用程序中，宿主可以是Windows Form 、WPF、控制台应用以及Windows Service，寄宿的请求的监听、接收 和响应功能，是通过一个类型为HttpBinding的Binding对象创建的ChannelListener管道来完成的。

一、Binding绑定模型

　　Binding用来创建处理和传输消息的信道栈，信道栈有一组Channel组成，Binding也由一组BindingElement组成，每个BindingElement会创建一个ChannelListener，ChannelListener再创建对应的Channel，而每个Channel负责处理消息的单独一块功能，Binding启动时候会创建多个Channel组成一个消息处理管道，对请求依次进行处理，对相应按相反方向进行处理，有点类似ASP.NET Web API的消息处理管道，而这是宿主内部的功能，要注意区分。

　　对于这种由Binding创建的多个Channel组成的消息处理管道的消息处理能力，是由其包含的Channel决定的，有两种Channel是必不可少的，TransportChannel和MessageEncodingChanneI：

  • TransportChannel  面向传输层用于发送和接收消息
  • MessageEncodingChanneI 负责对接收（请求）的消息实施解码 ,并对发送（响应）的消息实施编码

二、涉及的类及源码分析

　　类主要在程序集System.Web.Http SeIfHost.dII中。

　　ASP.NET Web API 框架研究 Self Host模式下的消息处理管道

　　ASP.NET Web API 框架研究 Self Host模式下的消息处理管道

1、HttpBinding

　　继承自Binding，其只由两个BindingElement组成，Http(s)TransportBindingElement和HttpMessageEncodingBindingElement

　　Http(s)TransportBindingElement  决定最终采用的传输协议,Http或Https

　　HttpMessageEncodingBindingElement  创 建一个MessageEncoder对象完成针对消息的编码/解码工作 。

　　public class  HttpBinding : Binding, IBindingRuntimePreferences
　　{
　　　　internal const string CollectionElementName = "httpBinding";

　　　　//默认传输模式为Buffered
　　　　internal const  TransferMode DefaultTransferMode = System.ServiceModel.TransferMode.Buffered;
　　　　//传输BindingElement 
　　　　private HttpsTransportBindingElement _httpsTransportBindingElement;
　　　　private HttpTransportBindingElement _httpTransportBindingElement;
　　　　private HttpBindingSecurity _security;

　　　　//编码/解码BindingElement
　　　　private HttpMessageEncodingBindingElement _httpMessageEncodingBindingElement;
　　　　private Action<HttpTransportBindingElement> _configureTransportBindingElement;

　　　　//初始化HttpBinding 
　　　　public HttpBinding()
　　　　{
　　　　　　Initialize();
　　　　}

　　　　public HttpBinding(HttpBindingSecurityMode securityMode)
　　　　: this()
　　　　{
　　　　　　_security.Mode = securityMode;
　　　　}

　　　　//从URL中确定主机名的比较模式

　　　　public  HostNameComparisonMode HostNameComparisonMode

　　　　{
　　　　　　get { return _httpTransportBindingElement.HostNameComparisonMode; }

　　　　　　set
　　　　　　{
　　　　　　　　_httpTransportBindingElement.HostNameComparisonMode = value;
　　　　　　　　_httpsTransportBindingElement.HostNameComparisonMode = value;
　　　　　}
　　　　}

　
　　　　public long MaxBufferPoolSize
　　　　{
　　　　　　get { return _httpTransportBindingElement.MaxBufferPoolSize; }

　　　　　　set
　　　　　　{
　　　　　　　　_httpTransportBindingElement.MaxBufferPoolSize = value;
　　　　　　　　_httpsTransportBindingElement.MaxBufferPoolSize = value;
　　　　　　}
　　　　}

　　　　//Buffered模式下的消息的最大缓冲区大小，Buffered模式，即消息先会保存于内存缓冲区后一并传输
　　　　[DefaultValue(TransportDefaults.MaxBufferSize)]
　　　　public int MaxBufferSize
　　　　{
　　　　　　get { return _httpTransportBindingElement.MaxBufferSize; }

　　　　　　set
　　　　　　{
　　　　　　　　_httpTransportBindingElement.MaxBufferSize = value;
　　　　　　　　_httpsTransportBindingElement.MaxBufferSize = value;
　　　　　　}
　　　　}

　　　　//请求消息的最大尺寸，默认为65536
　　　　[DefaultValue(TransportDefaults.MaxReceivedMessageSize)]
　　　　public long MaxReceivedMessageSize
　　　　{
　　　　　　get { return _httpTransportBindingElement.MaxReceivedMessageSize; }

　　　　　　set
　　　　　　{
　　　　　　　　_httpTransportBindingElement.MaxReceivedMessageSize = value;
　　　　　　　　_httpsTransportBindingElement.MaxReceivedMessageSize = value;
　　　　　　}
　　　　}

　　　　public Action<HttpTransportBindingElement> ConfigureTransportBindingElement
　　　　{
　　　　　　get { return _configureTransportBindingElement; }

　　　　　　set
　　　　　　{
　　　　　　　　if (value == null)
　　　　　　　　{
　　　　　　　　　　throw Error.PropertyNull();
　　　　　　　　}

　　　　　　　　_configureTransportBindingElement = value;
　　　　　　}
　　　　}

　　　　//传输模式

　　　　[DefaultValue(HttpTransportDefaults.TransferMode)]
　　　　public TransferMode TransferMode
　　　　{
　　　　　　get { return _httpTransportBindingElement.TransferMode; }

　　　　　　set
　　　　　　{
　　　　　　　　_httpTransportBindingElement.TransferMode = value;
　　　　　　　　_httpsTransportBindingElement.TransferMode = value;
　　　　　　}
　　　　}

　　　　//创建BindingElements，只包含两种
　　　　public override BindingElementCollection CreateBindingElements()
　　　　{
　　　　　　BindingElementCollection bindingElements = new BindingElementCollection();

　　　　　　bindingElements.Add(_httpMessageEncodingBindingElement);
　　　　　　bindingElements.Add(GetTransport());

　　　　　　return bindingElements.Clone();
　　　　}

　　　　private TransportBindingElement GetTransport()
　　　　{
　　　　　　HttpTransportBindingElement result = null;

　　　　　　if (_security.Mode == HttpBindingSecurityMode.Transport)
　　　　　　{
　　　　　　　　_security.Transport.ConfigureTransportProtectionAndAuthentication(_httpsTransportBindingElement);
　　　　　　　　result = _httpsTransportBindingElement;
　　　　　　}
　　　　　　else if (_security.Mode == HttpBindingSecurityMode.TransportCredentialOnly)
　　　　　　{
　　　　　　　　_security.Transport.ConfigureTransportAuthentication(_httpTransportBindingElement);
　　　　　　　　result = _httpTransportBindingElement;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　_security.Transport.DisableTransportAuthentication(_httpTransportBindingElement);
　　　　　　　　result = _httpTransportBindingElement;
　　　　　　}

　　　　　　if (_configureTransportBindingElement != null)
　　　　　　{
　　　　　　　　_configureTransportBindingElement(result);
　　　　　　}

　　　　　　return result;
　　　　}

　　　　//初始化各种对象

　　　　private void Initialize()
　　　　{
　　　　　　_security = new  HttpBindingSecurity();

　　　　　　_httpTransportBindingElement = new HttpTransportBindingElement();
　　　　　　_httpTransportBindingElement.ManualAddressing = true;

　　　　　　_httpsTransportBindingElement = new HttpsTransportBindingElement();
　　　　　　_httpsTransportBindingElement.ManualAddressing = true;

　　　　　　_httpMessageEncodingBindingElement = new HttpMessageEncodingBindingElement();
　　　　}
　　}

2、HttpMessage

　　Binding处理管道中处理的消息是HttpMessage,其继承自Message，它是对ASP.NET Web API处理的消息HttpRequestMessage和HttpResponseMessage的封装;HttpMessageEncoder对请求消息解码后得到HttpMessage对象，其会转成—个HttpRequestMessage对象并传入ASP.NET WebAPI消息处理管道进行处理，处理完后返回HttpResponseMessage对象,其被封装成HttpMessage对象，在通过传输层将响应返回给客户端之前,需要利用HttpMessageEncoder对其进行编码，然后进行传输。

　　internal sealed class  HttpMessage : Message
　　{
　　　　private HttpRequestMessage _request;
　　　　private HttpResponseMessage _response;
　　　　private MessageHeaders _headers;
　　　　private MessageProperties _properties;

　　　　//请求对象为参数，进行封装

　　　　public HttpMessage(HttpRequestMessage request)
　　　　{
　　　　　　Contract.Assert(request != null, "The 'request' parameter should not be null.");
　　　　　　_request = request;
　　　　　　Headers.To = request.RequestUri;
　　　　　　IsRequest = true;
　　　　}

　　　　//响应对象为参数，进行封装　　

　　　　public HttpMessage(HttpResponseMessage response)
　　　　{
　　　　　　Contract.Assert(response != null, "The 'response' parameter should not be null.");
　　　　　　_response = response;
　　　　　　IsRequest = false;
　　　　}

　　　　public override MessageVersion Version
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　EnsureNotDisposed();
　　　　　　　　return MessageVersion.None;
　　　　　　}
　　　　}

　　　　public override MessageHeaders Headers
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　EnsureNotDisposed();
　　　　　　　　if (_headers == null)
　　　　　　　　{
　　　　　　　　　　_headers = new MessageHeaders(MessageVersion.None);
　　　　　　　　}

　　　　　　　　return _headers;
　　　　　　}
　　　　}

　　　　public override MessageProperties Properties
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　EnsureNotDisposed();
　　　　　　　　if (_properties == null)
　　　　　　　　{
　　　　　　　　　　_properties = new MessageProperties();
　　　　　　　　　　_properties.AllowOutputBatching = false;
　　　　　　　　}

　　　　　　　　return _properties;
　　　　　　}
　　　　}

　　　　public override bool IsEmpty
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　long? contentLength = GetHttpContentLength();
　　　　　　　　return contentLength.HasValue && contentLength.Value == 0;
　　　　　　}
　　　　}

　　　　public override bool IsFault
　　　　{
　　　　　　get { return false; }
　　　　}

　　　　public bool IsRequest { get; private set; }

　　　　//从HttpMessage中获取HttpRequestMessage，参数extract是否是抽取，抽取即访问一次后第二次访问会返回null

　　　　public HttpRequestMessage GetHttpRequestMessage(bool extract)
　　　　{
　　　　　　EnsureNotDisposed();
　　　　　　Contract.Assert(IsRequest, "This method should only be called when IsRequest is true.");
　　　　　　if (extract)
　　　　　　{
　　　　　　　　HttpRequestMessage req = _request;

　　　　　　　　//设置为null，第二次访问为null
　　　　　　　　_request = null;
　　　　　　　　return req;
　　　　　　}

　　　　　　return _request;
　　　　}

　　　　//从HttpMessage中获取HttpResponseMessage ，参数extract是否是抽取，抽取即访问一次后第二次访问会返回null

　　　　public HttpResponseMessage GetHttpResponseMessage(bool extract)
　　　　{
　　　　　　EnsureNotDisposed();
　　　　　　Contract.Assert(!IsRequest, "This method should only be called when IsRequest is false.");
　　　　　　if (extract)
　　　　　　{
　　　　　　　　HttpResponseMessage res = _response;

　　　　　　　　//设置为null，第二次访问为null
　　　　　　　　_response = null;
　　　　　　　　return res;
　　　　　　}

　　　　　　return _response;
　　　　}

　　　　protected override void OnClose()
　　　　{
　　　　　　base.OnClose();
　　　　　　if (_request != null)
　　　　　　{
　　　　　　　　_request.DisposeRequestResources();
　　　　　　　　_request.Dispose();
　　　　　　　　_request = null;
　　　　　　}

　　　　　　if (_response != null)
　　　　　　{
　　　　　　　　_response.Dispose();
　　　　　　　　_response = null;
　　　　　　}
　　　　}

　　　　private static string GetNotSupportedMessage()
　　　　{
　　　　　　return Error.Format(
　　　　　　SRResources.MessageReadWriteCopyNotSupported,
　　　　　　HttpMessageExtensions.ToHttpRequestMessageMethodName,
　　　　　　HttpMessageExtensions.ToHttpResponseMessageMethodName,
　　　　　　typeof(HttpMessage).Name);
　　　　}

　　　　private void EnsureNotDisposed()
　　　　{
　　　　　　if (IsDisposed)
　　　　　　{
　　　　　　　　throw Error.ObjectDisposed(SRResources.MessageClosed, typeof(Message).Name);
　　　　　　}
　　　　}

　　　　private long? GetHttpContentLength()
　　　　{
　　　　　　HttpContent content = IsRequest
　　　　　　? GetHttpRequestMessage(false).Content
　　　　　　: GetHttpResponseMessage(false).Content;

　　　　　　if (content == null)
　　　　　　{
　　　　　　　　return 0;
　　　　　　}

　　　　　　return content.Headers.ContentLength;
　　　　}
　　}

3、HttpSelfHostServer

　　继承自HttpServer,是WebAPI 消息处理管道的第一个处理器，类似Web Host模式,管道的配置是通过HttpConfiguration完成，其对应由HttpSelfHostConfiguration来完成，也是在构造函数里指定。

　　重要逻辑都在代码注释里，代码太多，只是拿出重要的代码，以下是注意点：

  • 虽然继承HttpServer，但是没有重写SendAsync方法，只是重用了HttpServer的SendAsync，所以这部分逻辑是一致的
  • HttpSelfHostServer本身会打开和开启channel来监听，监听到消息后，会创建HttpRequestMessage，并调用基类HttpServer的SendAsync，进行后续的消息处理，返回响应HttpResponseMessage后，转换成Message返回给客户端。

　　public sealed class  HttpSelfHostServer : HttpServer
　　{
　　　　private ConcurrentBag<IReplyChannel> _channels = new ConcurrentBag<IReplyChannel>();
　　　　private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();

　　　　private bool _disposed;
　　　　private HttpSelfHostConfiguration _configuration;
　　　　private IChannelListener<IReplyChannel> _listener;

　　　　private readonly object _windowSizeLock = new object();

　　　　//调用基类HttpServer构造函数，所以最有一个处理器默认也是HttpRoutingDispatcher
　　　　public HttpSelfHostServer(HttpSelfHostConfiguration configuration)
　　　　: base(configuration)
　　　　{
　　　　　　if (configuration == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("configuration");
　　　　　　}

　　　　　　_configuration = configuration;
　　　　　　InitializeCallbacks();
　　　　}

　　　　//初始化回调，接受到消息后，通过回调触发
　　　　private void InitializeCallbacks()
　　　　{
　　　　　　//...
　　　　　　_onReceiveRequestContextComplete = new AsyncCallback(OnReceiveRequestContextComplete);
　　　　　　_onReplyComplete = new AsyncCallback(OnReplyComplete)；

　　　　}

　　　　//打开服务
　　　　public Task OpenAsync()
　　　　{
　　　　　　if (Interlocked.CompareExchange(ref _state, 1, 0) == 1)
　　　　　　{
　　　　　　　　throw Error.InvalidOperation(SRResources.HttpServerAlreadyRunning, typeof(HttpSelfHostServer).Name);
　　　　　　}

　　　　　　_openTaskCompletionSource = new TaskCompletionSource<bool>();
　　　　　　BeginOpenListener(this);
　　　　　　return _openTaskCompletionSource.Task;
　　　　}

　　　　private void BeginOpenListener(HttpSelfHostServer server)
　　　　{
　　　　　　Contract.Assert(server != null);

　　　　　　try
　　　　　　{
　　　　　　　　// 创建 WCF HTTP transport channel
　　　　　　　　HttpBinding binding = new HttpBinding();

　　　　　　　　// 获取配置（从HttpSelfHostConfiguration ），并设置到HttpBinding 
　　　　　　　　BindingParameterCollection bindingParameters = server._configuration.ConfigureBinding(binding);
　　　　　　　　if (bindingParameters == null)
　　　　　　　　{
　　　　　　　　　　bindingParameters = new BindingParameterCollection();
　　　　　　　　}

　　　　　　　　// 创建channel listener
　　　　　　　　server._listener = binding.BuildChannelListener<IReplyChannel>(server._configuration.BaseAddress, bindingParameters);
　　　　　　　　if (server._listener == null)
　　　　　　　　{
　　　　　　　　　　throw Error.InvalidOperation(SRResources.InvalidChannelListener, typeof(IChannelListener).Name, typeof(IReplyChannel).Name);
　　　　　　　　}

　　　　　　　　//开始监听

　　　　　　　　IAsyncResult result = server._listener.BeginOpen(_onOpenListenerComplete, server);
　　　　　　　　if (result.CompletedSynchronously)
　　　　　　　　{

　　　　　　　　　　//监听到请求消息，触发回调函数
　　　　　　　　　　OpenListenerComplete(result);
　　　　　　　　}
　　　　　　}
　　　　　　catch (Exception e)
　　　　　　{
　　　　　　　　FaultTask(server._openTaskCompletionSource, e);
　　　　　　}
　　　　}

　　　　//..省略各种回调

　　　　//Channel接收到消息后,通过回调最后会调用此方法
　　　　private async void ProcessRequestContext(ChannelContext channelContext, RequestContext requestContext)
　　　　{
　　　　　　Contract.Assert(channelContext != null);
　　　　　　Contract.Assert(requestContext != null);

　　　　　　//调用下边的核心方法SendAsync

　　　　　　HttpResponseMessage response = await SendAsync(channelContext, requestContext);

　　　　　　//异步调用处理完后返回响应消息，把响应消息转换成Message 
　　　　　　Message reply = response.ToMessage();

　　　　　　//传回给客户端
　　　　　　BeginReply(new ReplyContext(channelContext, requestContext, reply));
　　　　}

　　　　//核心方法，注意没有重写（override）基类SendAsync

　　　　private async  Task<HttpResponseMessage> SendAsync(ChannelContext channelContext, RequestContext requestContext)
　　　　{
　　　　　　HttpRequestMessage request = null;
　　　　　　try
　　　　　　{
　　　　　　　　request = CreateHttpRequestMessage(requestContext);
　　　　　　}
　　　　　　catch
　　　　　　{
　　　　　　　　return new HttpResponseMessage(HttpStatusCode.BadRequest);
　　　　　　}

　　　　　　try
　　　　　　{

　　　　　　　　//SendAsync方法是HttpServer的SendAsync，因为本类HttpSelfHostServer没有override该方法，

　　　　　　　　//所以其他逻辑，比如建立Web API消息处理管道等，都和HttpServer一样
　　　　　　　　HttpResponseMessage response = await channelContext.Server.SendAsync(request, channelContext.Server._cancellationTokenSource.Token);

　　　　　　　　if (response == null)
　　　　　　　　{
　　　　　　　　　　response = request.CreateResponse(HttpStatusCode.InternalServerError);
　　　　　　　　}

　　　　　　　　return response;
　　　　　　}
　　　　　　catch (OperationCanceledException operationCanceledException)
　　　　　　{
　　　　　　　　return request.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, SRResources.RequestCancelled, operationCanceledException);
　　　　　　}
　　　　}

　　　　//构建HttpRequestMessage

　　　　private  HttpRequestMessage CreateHttpRequestMessage(RequestContext requestContext)
　　　　{
　　　　　　// 从HTTP请求中获取 WCF Message
　　　　　　HttpRequestMessage request = requestContext.RequestMessage.ToHttpRequestMessage();
　　　　　　if (request == null)
　　　　　　{
　　　　　　　　throw Error.InvalidOperation(SRResources.HttpMessageHandlerInvalidMessage, requestContext.RequestMessage.GetType());
　　　　　　}

　　　　　　// 创建windows授权的 principal 信息并添加进请求HttpRequestMessage 
　　　　　　SetCurrentPrincipal(request);

　　　　　　HttpRequestContext httpRequestContext = new SelfHostHttpRequestContext(requestContext, _configuration,
　　　　　　request);
　　　　　　request.SetRequestContext(httpRequestContext);

　　　　　　// 添加查询客户端证书委托到属性字典中，以便以后可以查询
　　　　　　request.Properties.Add(HttpPropertyKeys.RetrieveClientCertificateDelegateKey, _retrieveClientCertificate);

　　　　　　// 添加表示是否是本地请求信息到请求的属性字典中
　　　　　　request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy<bool>(() => IsLocal(requestContext.RequestMessage)));
　　　　　　return request;
　　　　}

　　　　protected override void Dispose(bool disposing)
　　　　{
　　　　　　if (!_disposed)
　　　　　　{
　　　　　　　　_disposed = true;
　　　　　　　　if (_cancellationTokenSource != null)
　　　　　　　　{
　　　　　　　　　　_cancellationTokenSource.Dispose();
　　　　　　　　　　_cancellationTokenSource = null;
　　　　　　　　}
　　　　　　}

　　　　　　base.Dispose(disposing);
　　　　}

　　　　private static void SetCurrentPrincipal(HttpRequestMessage request)
　　　　{
　　　　　　SecurityMessageProperty property = request.GetSecurityMessageProperty();
　　　　　　if (property != null)
　　　　　　{
　　　　　　　　ServiceSecurityContext context = property.ServiceSecurityContext;
　　　　　　　　if (context != null && context.PrimaryIdentity != null)
　　　　　　　　{
　　　　　　　　　　WindowsIdentity windowsIdentity = context.PrimaryIdentity as WindowsIdentity;

　　　　　　　　　　if (windowsIdentity != null)
　　　　　　　　　　{

　　　　　　　　　　　　//设置Thread.CurrentPrincipal 为WindowsPrincipal
　　　　　　　　　　　　Thread.CurrentPrincipal = new WindowsPrincipal(windowsIdentity);
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}

　　　　}
　　}

4、HttpSelfHostConfiguration

　　继承自HttpConfiguration，构造函数中指定一个Uri作为监听基地址，Self Host模式下，请求的监听、接收、响应基本都是通过HttpBinding完成的，HttpSelfHostConfiguration的大部分属性都是用于对创建HttpBinding进行配置，所以它们的属性基本相同。

　　public class  HttpSelfHostConfiguration : HttpConfiguration
　　{
　　　　public HttpSelfHostConfiguration(string baseAddress)
　　　　: this(CreateBaseAddress(baseAddress))
　　　　{
　　　　}

　　　　//基地址Uri
　　　　public Uri BaseAddress
　　　　{
　　　　　　get { return _baseAddress; }
　　　　}

　　　　//最大请求并发量，默认值是100，若是多处理器，要cheny乘以处理器个数
　　　　public int MaxConcurrentRequests
　　　　{
　　　　　　get { return _maxConcurrentRequests; }

　　　　　　set
　　　　　　{
　　　　　　　　if (value < MinConcurrentRequests)
　　　　　　　　{
　　　　　　　　　　throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, MinConcurrentRequests);
　　　　　　　　}
　　　　　　　　_maxConcurrentRequests = value;
　　　　　　}
　　　　}

　　　　//消息传输模式，分Streamed和Buffered(默认)
　　　　public TransferMode TransferMode
　　　　{
　　　　　　get { return _transferMode; }

　　　　　　set
　　　　　　{
　　　　　　　　TransferModeHelper.Validate(value, "value");
　　　　　　　　_transferMode = value;
　　　　　　}
　　　　}

　　　　//从URI中获取主机名的匹配比较模式
　　　　public HostNameComparisonMode HostNameComparisonMode
　　　　{
　　　　　　get { return _hostNameComparisonMode; }

　　　　　　set
　　　　　　{
　　　　　　　　HostNameComparisonModeHelper.Validate(value, "value");
　　　　　　　　_hostNameComparisonMode = value;
　　　　　　}
　　　　}

　　　　//Buffered模式的最大缓冲池大小，默认值65536

　　　　public int MaxBufferSize
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　if (_maxBufferSizeIsInitialized || TransferMode != TransferMode.Buffered)
　　　　　　　　{
　　　　　　　　　　return _maxBufferSize;
　　　　　　　　}

　　　　　　　　long maxReceivedMessageSize = MaxReceivedMessageSize;
　　　　　　　　if (maxReceivedMessageSize > Int32.MaxValue)
　　　　　　　　{
　　　　　　　　　　return Int32.MaxValue;
　　　　　　　　}
　　　　　　　　return (int)maxReceivedMessageSize;
　　　　　　}

　　　　　　set
　　　　　　{
　　　　　　　　if (value < MinBufferSize)
　　　　　　　　{
　　　　　　　　　　throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, MinBufferSize);
　　　　　　　　}
　　　　　　　　_maxBufferSizeIsInitialized = true;
　　　　　　　　_maxBufferSize = value;
　　　　　　}
　　　　}

　　　　//允许请求消息的最大大小，默认为65536

　　　　public long MaxReceivedMessageSize
　　　　{
　　　　　　get { return _maxReceivedMessageSize; }

　　　　　　set
　　　　　　{
　　　　　　　　if (value < MinReceivedMessageSize)
　　　　　　　　{
　　　　　　　　　　throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, MinReceivedMessageSize);
　　　　　　　　}
　　　　　　　　_maxReceivedMessageSize = value;
　　　　　　}
　　　　}

　　　　//接收请求消息的超时时间，默认为10分钟　　

　　　　public TimeSpan ReceiveTimeout
　　　　{
　　　　　　get { return _receiveTimeout; }

　　　　　　set
　　　　　　{
　　　　　　　　if (value < TimeSpan.Zero)
　　　　　　　　{
　　　　　　　　　　throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, TimeSpan.Zero);
　　　　　　　　}

　　　　　　　　_receiveTimeout = value;
　　　　　　}
　　　　}

　　　　//发送响应消息的超时时间，默认为1分钟　　

　　　　public TimeSpan SendTimeout
　　　　{
　　　　　　get { return _sendTimeout; }

　　　　　　set
　　　　　　{
　　　　　　　　if (value < TimeSpan.Zero)
　　　　　　　　{
　　　　　　　　　　throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, TimeSpan.Zero);
　　　　　　　　}

　　　　　　　　_sendTimeout = value;
　　　　　　}
　　　　}

　　　　//客户端采用的用户凭证类型
　　　　public HttpClientCredentialType ClientCredentialType
　　　　{
　　　　　　get { return _clientCredentialType; }
　　　　　　set { _clientCredentialType = value; }
　　　　}

　　　　//将配置应用到httpBinding
　　　　internal BindingParameterCollection ConfigureBinding(HttpBinding httpBinding)
　　　　{
　　　　　　return OnConfigureBinding(httpBinding);
　　　　}

　　　　
　　　　protected virtual BindingParameterCollection OnConfigureBinding(HttpBinding httpBinding)
　　　　{
　　　　　　if (httpBinding == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("httpBinding");
　　　　　　}

　　　　　　if (_clientCredentialType != HttpClientCredentialType.Basic && _credentials.UserNameAuthentication.CustomUserNamePasswordValidator != null)
　　　　　　{
　　　　　　　　throw Error.InvalidOperation(SRResources.CannotUseOtherClientCredentialTypeWithUserNamePasswordValidator);
　　　　　　}

　　　　　　if (_clientCredentialType != HttpClientCredentialType.Certificate && _credentials.ClientCertificate.Authentication.CustomCertificateValidator != null)
　　　　　　{
　　　　　　　　throw Error.InvalidOperation(SRResources.CannotUseOtherClientCredentialTypeWithX509CertificateValidator);
　　　　　　}

　　　　　　httpBinding.MaxBufferSize = MaxBufferSize;
　　　　　　httpBinding.MaxReceivedMessageSize = MaxReceivedMessageSize;
　　　　　　httpBinding.TransferMode = TransferMode;
　　　　　　httpBinding.HostNameComparisonMode = HostNameComparisonMode;
　　　　　　httpBinding.ReceiveTimeout = ReceiveTimeout;
　　　　　　httpBinding.SendTimeout = SendTimeout;

　　　　　　if (_baseAddress.Scheme == Uri.UriSchemeHttps)
　　　　　　{

　　　　　　　　httpBinding.Security = new HttpBindingSecurity()
　　　　　　　　{
　　　　　　　　　　Mode = HttpBindingSecurityMode.Transport,
　　　　　　　　};
　　　　　　}

　　　　　　if (_clientCredentialType != HttpClientCredentialType.None)
　　　　　　{
　　　　　　　　if (httpBinding.Security == null || httpBinding.Security.Mode == HttpBindingSecurityMode.None)
　　　　　　　　{
　　　　　　　　　　// Basic over HTTP case
　　　　　　　　　　httpBinding.Security = new HttpBindingSecurity()
　　　　　　　　　　{
　　　　　　　　　　　　Mode = HttpBindingSecurityMode.TransportCredentialOnly,
　　　　　　　　　　};
　　　　　　　　}

　　　　　　　　httpBinding.Security.Transport.ClientCredentialType = _clientCredentialType;
　　　　　　}

　　　　　　if (UserNamePasswordValidator != null || X509CertificateValidator != null)
　　　　　　{
　　　　　　　　// those are the only two things that affect service credentials
　　　　　　　　return AddCredentialsToBindingParameters();
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　return null;
　　　　　　}
　　　　}

　　　　private BindingParameterCollection AddCredentialsToBindingParameters()
　　　　{
　　　　　　BindingParameterCollection bindingParameters = new BindingParameterCollection();
　　　　　　bindingParameters.Add(_credentials);
　　　　　　return bindingParameters;
　　　　}

　　　　//根据基地址创建对应Uri

　　　　private static Uri CreateBaseAddress(string baseAddress)
　　　　{
　　　　　　if (baseAddress == null)
　　　　　　{
　　　　　　　　throw Error.ArgumentNull("baseAddress");
　　　　　　}

　　　　　　return new Uri(baseAddress, UriKind.RelativeOrAbsolute);
　　　　}
　　}

三、HttpBiding、HttpSelfHostServer和消息处理管道的衔接

　　先根据指定的监听基地址创建一个HttpSelftHostConfiguration对象，然后，根据它创建HttpSelfHostServer,调用OpenAsync方法开启时候，HttpSelfHostServer会创建一个HttpBinding，并用指定的HttpSelfHostConfiguration对HttpBinding进行配置，然后，HttpBinding会根据监听基地址创建一个ChannelListener管道，对请求进行监听，请求到达时候，接收的二进制数据会经过解码后生成HttpMessage,其是对HttpRequestMessage的封装，然后，HttpSelfHostServer会从该HttpMessage提取出HttpRequestMessage，传递给WebAPI消息处理管道的其他处理器依次处理，处理完返回一个HttpResponseMessage对象，把其封装成HttpMessage,接着对其进行编码，通过传输层进行传输，返回给客户端。

　　另外，特别注意的是，Web API消息处理管道的最后一个消息处理器还是HttpRoutingDispatcher,其在HttpSelfHostServer创建时候，调用基类HttpServer的构造函数时候指定,而且在HttpRoutingDispatcher路由时候，由于路由数据没在HttpRequestMessage的属性字典中，所以要直接进行路由解析，获得的路由数据也会放在HttpRequestMessage的属性字典中，所以，后续的Controller创建等操作需要的路由数据都是从HttpRequestMessage的属性字典中获取。

　　ASP.NET Web API 框架研究 Self Host模式下的消息处理管道

相关文章