.NetWebApi消息拦截器MessageHandler-创新互联

这篇文章将为大家详细讲解有关.Net WebApi消息拦截器MessageHandler，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。

为北海街道等地区用户提供了全套网页设计制作服务，及北海街道网站建设行业解决方案。主营业务为成都做网站、成都网站设计、北海街道网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

消息拦截器是一个类，接收 HTTP request并返回 HTTP response,Message handler 继承自抽象类 HttpMessageHandler
可以自定义 MessageHandler,消息拦截器的作用如:

1. 读取或更改请求头 request headers

2. 添加 response headers

3. 在到达 controller 之前，进行参数验证

自定义 Message Handlers

自定义 MessageHandler 需要继承 System.Net.Http.DelegatingHander并且重载SendAsync方法

Task SendAsync(
  HttpRequestMessage request, CancellationToken cancellationToken);

这个方法的一般的处理流程是

1. 处理请求信息

2. 调用base.SendAsync方法，吧请求发送给内部处理

3. 内部处理完成之后，返回 response message(这个过程是异步的)

4. 处理response之后，返回给调用者

public class MessageHandler1 : DelegatingHandler
{
  protected async override Task SendAsync(
    HttpRequestMessage request, CancellationToken cancellationToken)
  {
    Debug.WriteLine("Process request");
    // Call the inner handler.
    var response = await base.SendAsync(request, cancellationToken);
    Debug.WriteLine("Process response");
    return response;
  }
}

消息拦截器生效

在WebApiConfig中注册相关

public static class WebApiConfig
{
  public static void Register(HttpConfiguration config)
  {
    config.MessageHandlers.Add(new MessageHandler1());
    config.MessageHandlers.Add(new MessageHandler2());

    // Other code not shown...
  }
}

https 请求拦截器

要求所有的请求都必须是https的请求，可以自定义一个https的拦截器，如果是https请求，就继续处理，否则就返回相关的提示信息

public class RequireHttpsHandler : DelegatingHandler
{
 public RequireHttpsHandler(int httpsPort)
 {
   _httpsPort = httpsPort;
 }

 public RequireHttpsHandler()
   : this(443)
 {
 }

 protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
 {
   //判断是否是 https 请求
   if (request.RequestUri.Scheme == Uri.UriSchemeHttps)
     return base.SendAsync(request, cancellationToken);

   var response = CreateResponse(request);
   var tcs = new TaskCompletionSource();
   tcs.SetResult(response);
   return tcs.Task;
 }

 private HttpResponseMessage CreateResponse(HttpRequestMessage request)
 {
   HttpResponseMessage response;
   var uri = new UriBuilder(request.RequestUri);
   uri.Scheme = Uri.UriSchemeHttps;
   uri.Port = _httpsPort;
   var body = string.Format("HTTPS is required
The resource can be found at {0}.", uri.Uri.AbsoluteUri);
   if (request.Method.Equals(HttpMethod.Get) || request.Method.Equals(HttpMethod.Head))
   {
     response = request.CreateResponse(HttpStatusCode.Found);
     response.Headers.Location = uri.Uri;
     if (request.Method.Equals(HttpMethod.Get))
       response.Content = new StringContent(body, Encoding.UTF8, "text/html");
   }
   else
   {
     response = request.CreateResponse(HttpStatusCode.NotFound);
     response.Content = new StringContent(body, Encoding.UTF8, "text/html");
   }

   return response;
 }
}

Enable CORS 拦截器

public class SimpleCorsHandler : DelegatingHandler
{
  private const string origin = "Origin";
  private const string accessControlRequestMethod = "Access-Control-Request-Method";
  private const string accessControlRequestHeaders = "Access-Control-Request-Headers";
  private const string accessControlAllowOrigin = "Access-Control-Allow-Origin";
  private const string accessControlAllowMethods = "Access-Control-Allow-Methods";
  private const string accessControlAllowHeaders = "Access-Control-Allow-Headers";

  protected override Task SendAsync(HttpRequestMessage request,
                              CancellationToken cancellationToken)
  {
    var isCorsRequest = request.Headers.Contains(origin);
    var isPreflightRequest = request.Method == HttpMethod.Options;

    if (isCorsRequest)
    {
      if (isPreflightRequest)
      {
        return Task.Factory.StartNew(() =>
            {
              var response = new HttpResponseMessage(HttpStatusCode.OK);
              response.Headers.Add(accessControlAllowOrigin,
                        request.Headers.GetValues(origin).First());

              var currentAccessControlRequestMethod =
                request.Headers.GetValues(accessControlRequestMethod).
                  FirstOrDefault();

              if (currentAccessControlRequestMethod != null)
              {
                response.Headers.Add(accessControlAllowMethods,
                          currentAccessControlRequestMethod);
              }

              var requestedHeaders = string.Join(", ", request.Headers.GetValues(accessControlRequestHeaders));

              if (!string.IsNullOrEmpty(requestedHeaders))
              {
                response.Headers.Add(accessControlAllowHeaders,
                          requestedHeaders);
              }

              return response;
            }, cancellationToken);
      }
      else
      {
        return base.SendAsync(request, cancellationToken).ContinueWith(t =>
            {
              var resp = t.Result;
              resp.Headers.Add(
                accessControlAllowOrigin,
                request.Headers.GetValues(origin).First());

              return resp;
            });
      }
    }
    else
    {
      return base.SendAsync(request, cancellationToken);
    }
  }
}

关于.Net WebApi消息拦截器MessageHandler就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。

网站栏目：.NetWebApi消息拦截器MessageHandler-创新互联
路径分享：http://shouzuofang.com/article/pggip.html