.Net Task<T>的一种比较神奇的卡死情况(Wait/Result卡死, await能得到结果)

出现的环境.Net4.0 + WebApi1(4.0.30506.0) + Microsoft.Bcl.Async.1.0.168

自己死活看不出原因, 分享出来给大家看看,希望有人能找到问题的关键

出现错误的是下面这两个模块

下面的CorsMessageHandler,抄的http://www.cnblogs.com/artech/p/cors-4-asp-net-web-api-04.html, 做了部分修改

     public class CorsMessageHandler : DelegatingHandler
     {
         private static readonly CorsAttribute DEFAULT_CORS = new CorsAttribute("*");//默认支持所有

         protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
             try
             {
                 //得到描述目标Action的HttpActionDescriptor
                 HttpMethod originalMethod = request.Method;
                 bool isPreflightRequest = request.IsPreflightRequest();
                 if (isPreflightRequest)
                 {
                     string method = request.Headers.GetValues("Access-Control-Request-Method").First();
                     request.Method = new HttpMethod(method);
                 }
                 HttpConfiguration configuration = request.GetConfiguration();
                 HttpControllerDescriptor controllerDescriptor = configuration.Services.GetHttpControllerSelector().SelectController(request);
                 HttpControllerContext controllerContext = new HttpControllerContext(request.GetConfiguration(), request.GetRouteData(), request)
                 {
                     ControllerDescriptor = controllerDescriptor
                 };
                 //避免权限错误
                 //HttpActionDescriptor actionDescriptor = configuration.Services.GetActionSelector().SelectAction(controllerContext);

                 //根据HttpActionDescriptor得到应用的CorsAttribute特性
                 CorsAttribute corsAttribute = null;
                 //corsAttribute = actionDescriptor.GetCustomAttributes<CorsAttribute>().FirstOrDefault();
                 corsAttribute = corsAttribute?? controllerDescriptor.GetCustomAttributes<CorsAttribute>().FirstOrDefault();
                 if (null == corsAttribute)
                 {
                     corsAttribute = DEFAULT_CORS;
                     //return base.SendAsync(request, cancellationToken);
                 }

                 //利用CorsAttribute实施授权并生成响应报头
                 IDictionary<string, string> headers;
                 request.Method = originalMethod;
                 bool authorized = corsAttribute.TryEvaluate(request, out headers);
                 HttpResponseMessage response;
                 if (isPreflightRequest)
                 {
                     if (authorized)
                     {
                         response = new HttpResponseMessage(HttpStatusCode.OK);
                     }
                     else
                     {
                         response = request.CreateErrorResponse(HttpStatusCode.BadRequest, corsAttribute.ErrorMessage);
                     }
                 }
                 else
                 {
                     var tmp = base.SendAsync(request, cancellationToken);
                     tmp.Wait();
                     response = tmp.Result;
                 }

                 if (headers != null)
                 {
                     foreach (var item in headers)
                     {
                         response.Headers.Add(item.Key, item.Value);
                     }
                 }
                 return response;
             }
             catch
             {
             }
             //catch -> fallback
             return await base.SendAsync(request, cancellationToken);
         }
     }
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
     public class CorsAttribute : Attribute
     {
         public Uri[] AllowOrigins { get; private set; }
         public string ErrorMessage { get; private set; }

         public CorsAttribute(params string[] allowOrigins)
         {
             var tmp = (allowOrigins ?? new string[]);
             if (tmp.Length ==  && "*" == tmp[])
             {
                 this.AllowOrigins = null;
             }
             else
             {
                 this.AllowOrigins = tmp.Select(origin => new Uri(origin)).ToArray();
             }
         }

         public bool TryEvaluate(HttpRequestMessage request, out IDictionary<string, string> headers)
         {
             headers = null;

             //bugfix: GetValues在找不到时会报错
             IEnumerable<string> origins;
             if (request.Headers.TryGetValues("Origin", out origins))
             {
                 string origin = origins.FirstOrDefault();
                 if (!String.IsNullOrEmpty(origin))
                 {
                     Uri originUri = new Uri(origin);
                     if (this.AllowOrigins == null || this.AllowOrigins.Contains(originUri))//支持"*"
                     {
                         headers = this.GenerateResponseHeaders(request);
                         return true;
                     }
                 }
             }
             this.ErrorMessage = "Cross-origin request denied";
             return false;
         }

         private IDictionary<string, string> GenerateResponseHeaders(HttpRequestMessage request)
         {
             //设置响应报头"Access-Control-Allow-Methods"
             string origin = request.Headers.GetValues("Origin").First();
             Dictionary<string, string> headers = new Dictionary<string, string>();
             headers.Add("Access-Control-Allow-Origin", origin);
             if (request.IsPreflightRequest())
             {
                 //设置响应报头"Access-Control-Request-Headers"
                 //和"Access-Control-Allow-Headers"
                 string requestHeaders = request.Headers.GetValues("Access-Control-Request-Headers").FirstOrDefault();
                 if (!string.IsNullOrEmpty(requestHeaders))
                 {
                     headers.Add("Access-Control-Allow-Headers", requestHeaders);
                 }
                 //string requestMethods = request.Headers.GetValues("Access-Control-Request-Method").FirstOrDefault();
                 //if (!string.IsNullOrEmpty(requestHeaders))
                 //{
                 //    headers.Add("Access-Control-Allow-Methods", requestMethods + ", OPTIONS");
                 //}
                 //else
                 //{
                     headers.Add("Access-Control-Allow-Methods", "*");
                 //}
             }
             headers.Add("Access-Control-Allow-Credentials", "true");//true, 允许跨域传cookie, 要在POST的返回值中也存在
             return headers;
         }
     }

一个简单的异常过滤器

     public class JsonExceptionFilter : FilterAttribute, IExceptionFilter//, IActionFilter
     {

         public Task ExecuteExceptionFilterAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
         {
             return Task.Factory.StartNew((obj) =>
             {
                 CancellationToken ct = (CancellationToken)obj;
                 if (actionExecutedContext.Exception != null)
                 {
                     var res = new ResultModel<String>(false, actionExecutedContext.Exception.GetType().ToString());
                     var resText = JsonConvert.SerializeObject(res);
                     if (actionExecutedContext.Response == null)
                     {
                         actionExecutedContext.Response = new HttpResponseMessage();
                     }
                     actionExecutedContext.Response.Content = new StringContent("{\"State\":-255}", Encoding.UTF8, "application/json");
                 }
             }, cancellationToken, cancellationToken);
         }
     }

现在存在的问题是如果Action内部有异常被过滤器捕获, CorsMessageHandler就卡死在

var tmp = base.SendAsync(request, cancellationToken);
response = tmp.Result;//卡死在这里, 用tmp.Wait();也是一样卡死

调试看task的State是WaitingForActivation, 但是用Wait/Result无限期卡死无法得到结果, 但是用await(Microsoft.Bcl.Async引入)就不存在问题, 能正常执行出结果