Asp.Net实现WebApi跨域 （非MVC）

目前WebApi在使用上大部分都是跟MVC组合的，而且使用起来也确实十分便利。

但有时候我们也需要在WebForm中使用WebApi，二者还是有一定区别的。

首先看下结构

 ①ApiController

即Controller部分，当然也包含Api的路径也是很重要的。这里面是Api/{function}/{controller}/{action}

看一下Controller里面的内容

using System;
using System.Web.Http;

namespace WebApiTest.Api.Func
{
    public class TestController : ApiController
    {
        [HttpPost]
        public TestModel Post([FromBody]TestModel model)
        {
            model.Name = "Post";
            model.UpdatedOn = DateTime.Now;
            model.Age++;
            return model;
        }
    }
}

注意的地方有这么几点：

• Controller要继承ApiController
• Action要加上特性 [HttpPost] ,[HttpGet] 。。。如下图
• 
• 一般情况我们用的都是[HttpPost]，这时候参数中就要加特性[FromBody]了
• 为了能够直接使用请求过来的数据，而不必去转化成对应的实体类，我们需要给参数实体类加特性[Newtonsoft.Json.JsonObject]否则返回的数据会是酱紫的

这是使用的实体类

[Newtonsoft.Json.JsonObject]
public class TestModel
{
    public string Name { set; get; }

    public int Age { set; get; }

    public DateTime UpdatedOn { set; get; }
}

②跨域处理程序CorsHandler.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using System.Net.Http;
 using System.Threading.Tasks;
 using System.Threading;
 using System.Net;

 namespace WebApiTest.Handler
 {
     public class CorsHandler : DelegatingHandler
     {
         const string Origin = "Origin";
         const string AccessControlRequestMethod = "Access-Control-Request-Method";
         const string AccessControlRequestHeaders = "Access-Control-Request-Headers";
         const string AccessControlAllowOrigin = "Access-Control-Allow-Origin";
         const string AccessControlAllowMethods = "Access-Control-Allow-Methods";
         const string AccessControlAllowHeaders = "Access-Control-Allow-Headers";

         protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
             bool isCorsRequest = request.Headers.Contains(Origin);
             bool isPreflightRequest = request.Method == HttpMethod.Options;
             if (isCorsRequest)
             {
                 if (isPreflightRequest)
                 {
                     return Task.Factory.StartNew<HttpResponseMessage>(() =>
                     {
                         HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
                         response.Headers.Add(AccessControlAllowOrigin, request.Headers.GetValues(Origin).First());

                         string accessControlRequestMethod = request.Headers.GetValues(AccessControlRequestMethod).FirstOrDefault();
                         if (accessControlRequestMethod != null)
                         {
                             response.Headers.Add(AccessControlAllowMethods, accessControlRequestMethod);
                         }

                         string 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<HttpResponseMessage>(t =>
                     {
                         HttpResponseMessage resp = t.Result;
                         resp.Headers.Add(AccessControlAllowOrigin, request.Headers.GetValues(Origin).First());
                         return resp;
                     });
                 }
             }
             else
             {
                 return base.SendAsync(request, cancellationToken);
             }
         }
     }
 }

CorsHandler.cs

③Controller配置程序 HttpControllerSelector.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Web.Http;
 using System.Web.Http.Controllers;
 using System.Web.Http.Dispatcher;

 namespace WebApiTest.Handler
 {
     public class HttpControllerSelector : DefaultHttpControllerSelector
     {
         private HttpConfiguration configuration = null;
         public HttpControllerSelector(HttpConfiguration configuration)
             : base(configuration)
         {
             this.configuration = configuration;
             GetControllerMapping();
         }

         public override string GetControllerName(HttpRequestMessage request)
         {
             object function, c;
             var routedata = request.GetRouteData();

             if (routedata.Values.TryGetValue("function", out function) &&
                 routedata.Values.TryGetValue("controller", out c))
             {
                 var item = dict.FirstOrDefault(t => t.Key.Contains(string.Format("{0}.{1}controller", function, c).ToLower()));
                 if (item.Value != null)
                 {
                     return item.Value.ControllerName;
                 }
             }
             return base.GetControllerName(request);
         }

         IDictionary<string, HttpControllerDescriptor> dict = new Dictionary<string, HttpControllerDescriptor>();
         public override IDictionary<string, HttpControllerDescriptor> GetControllerMapping()
         {
             var list = Assembly.GetAssembly(this.GetType()).GetTypes().Where(t => t.IsSubclassOf(typeof(ApiController)));
             foreach (var type in list)
             {
                 dict.Add(type.FullName.ToLower(), new HttpControllerDescriptor(this.configuration, type.FullName.ToLower(), type));
             }

             return dict;
         }

         public override HttpControllerDescriptor SelectController(HttpRequestMessage request)
         {
             HttpControllerDescriptor c;
             var cn = GetControllerName(request);
             if (dict.TryGetValue(cn, out c))
             {
                 return c;
             }
             return base.SelectController(request);
         }
     }
 }

HttpControllerSelector.cs

④路由注册程序WebApiConfig.cs

 using System.Web.Http;
 using System.Web.Http.Dispatcher;

 namespace WebApiTest.Handler
 {
     public static class WebApiConfig
     {
         public static void Register(HttpConfiguration config)
         {
             // Web API 配置和服务
             config.Services.Replace(typeof(IHttpControllerSelector), new HttpControllerSelector(config));

             config.Routes.MapHttpRoute(
                 name: "Api",
                 routeTemplate: "api/{function}/{controller}/{action}"
             );
         }
     }
 }

WebApiConfig.cs

⑤Global.asax.cs

在该文件中添加如下代码

        public override void Init()
        {
            this.EndRequest += Global_EndRequest;
            this.BeginRequest += Global_BeginRequest;
            base.Init();
        }

        protected void Application_Start(object sender, EventArgs e)
        {
            GlobalConfiguration.Configuration.MessageHandlers.Add(new CorsHandler());
            WebApiConfig.Register(GlobalConfiguration.Configuration);
        }

至此 服务端的配置就基本OK了。

调用的地方用如下Ajax就可以了

$.ajax({
    url: "api/func/Test/Post",
    type: "POST",
    data: {Name:"Ray"},
    dataType:"json",
    success: function (result) {
        console.log(result);
    }
});

代码下载

---

上面讲的是服务端的配置，顺带一提客户端的调用。

但是，如果是在后台调用某个WebApi该如何破呢？

我使用的是Intersoft的CrossLight，用起来也是比较简单。

TestModel model = new TestModel();
RestClient c = new RestClient("http://localhost:1234/API/Module/");
RestRequest req = new RestRequest("Function/Do", HttpMethod.POST);
req.RequestFormat = RequestDataFormat.Json;
req.AddBody(model);
var res = c.ExecuteAsync<WebApiModel>(req);
var tmp = JsonConvert.DeserializeObject<WebApiModel<TestModel>>(res.Result.Content).Model;

if (res.Result.Data.HasError) {
    throw new Exception(res.Result.Data.ErrorMessage);
}

这里面有个包装的类WebApiModel，是为了更好的传递其他信息（如错误信息），定义如下

using System;

namespace XX
{
    [Newtonsoft.Json.JsonObject]
    [Serializable]
    public class WebApiModel
    {
        public WebApiModel()
        {

        }

        public WebApiModel(object model)
        {
            this.Model = model;
        }

        public object Model { get; set; }

        public bool HasError
        {
            get
            {
                return !string.IsNullOrEmpty(ErrorMessage);
            }
        }
        public string ErrorMessage { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace XX
{
    [Newtonsoft.Json.JsonObject]
    [Serializable]
    public class WebApiModel<T>
    {
        public WebApiModel()
        {

        }

        public WebApiModel(T model)
        {
            this.Model = model;
        }

        public T Model { get; set; }

        public bool HasError
        {
            get
            {
                return !string.IsNullOrEmpty(ErrorMessage);
            }
        }
        public string ErrorMessage { get; set; }
    }
}