.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[0]);
            if (tmp.Length == 1 && "*" == tmp[0])
            {
                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引入)就不存在问题, 能正常执行出结果