本章將和大家分享ASP.NET Core中的Web API。

一、RESTful架構風格

REST（Representational State Transfer）表現層的狀態轉化，是一個介面的設計風格。是Web服務的一種新的架構風格（一種思想）。

資源：萬物看成資源。

使用POST，DELETE，PUT和GET四種請求方式分別對指定的URL資源進行增刪改查操作，RESTful是通過URI實現對資源的管理及訪問，具有擴充套件性強、結構清晰的特點。

URI：統一資源識別符號，資源對應的唯一地址。

統一介面：CRUD增刪改查，跟HTTP Method對應。

REST架構的主要原則：

　　1、對網路上所有的資源都有一個資源標誌符。

　　2、對資源的操作不會改變識別符號。

　　3、同一資源有多種表現形式（xml、json）。

　　4、所有操作都是無狀態的（Stateless）。

符合上述REST原則的架構方式稱為RESTful

無狀態：

　　基於Http協議，（登陸系統--查詢工資--計算稅收，有狀態）

　　無狀態的直接一個地址，就能拿到工資，就能得到稅收

關於RESTful更多資料可參考博文：https://blog.csdn.net/x541211190/article/details/81141459

二、Web API

WebApi：RESTful架構風格，http協議 無狀態 標準化操作 更輕量級，尤其是json，適合移動端。

Web API和MVC差別：

　　專人做專事，它們的管道模式是不一樣的。

　　Web API中是沒有生成頁面這套東西的，它不需要去找檢視那些東西，它也不存在去弄session之類的，Web API是專門提供資料的，比起MVC來講Web API更輕量級。

　　Web API嚴格遵守了RESTful架構風格。

接下來我們來看下程式碼部分：

1、Web API專案建立（使用VS2019）

建立成功後如下所示：

接下來我們新增一個名為Users的API控制器：

新增完成後我們來看下API控制器的結構：

using Microsoft.AspNetCore.Mvc;
using System;
 
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860

namespace MyWebAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class UsersController : ControllerBase
    {
        // GET: api/<UsersController>
        [HttpGet]
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        // GET api/<UsersController>/5
        [HttpGet("{id}")]
        public string Get(int id)
        {
            return "value";
        }

        // POST api/<UsersController>
        [HttpPost]
        public void Post([FromBody] string value)
        {
        }

        // PUT api/<UsersController>/5
        [HttpPut("{id}")]
        public void Put(int id, [FromBody] string value)
        {
        }

        // DELETE api/<UsersController>/5
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }
    }
}

可以看出API控制器繼承了ControllerBase基類，標記了 [ApiController] Api控制器特性和 [Route("api/[controller]")] 路由特性，

以及不同型別的Action方法也分別標記了不同的特性，分別為：HttpGet、HttpPost、HttpPut、HttpDelete特性，這四個特性分別對應著查、增、改、刪四個HTTP Method方法。

2、Web API路由

Web API路由規則如下：

　　1、請求進來時，會經過路由匹配找到合適的控制器。

　　2、那怎麼找Action呢？

　　　　1）根據HttpMethod找方法，用方法名字開頭（即使用Post、Delete、Put、Get這四個開頭），Get開頭就是對應Get請求。（該點在.NET Framework框架中適用）

　　　　2）如果不是使用Post、Delete、Put、Get這四個開頭，也可以使用HttpGet、HttpPost、HttpPut、HttpDelete這四大特性。

　　　　3）按照引數找最吻合

　　　　4）在.NET Core路由中會優先匹配標記了HttpGet、HttpPost、HttpPut、HttpDelete這四大特性的Action，在沒有匹配到的情況下才會去匹配別的Action，而且該Action可以不使用Post、Delete、Put、Get這四個開頭。

熟悉MVC的人一開始可能會對這個規則很不習慣，在MVC中我們是通過控制器和Action定位到具體操作的。但是為什麼在Web API中卻不是這樣的？

這是因為我們的Web API是嚴格遵循RESTful風格的，在RESTful風格中只有資源（萬物皆資源）和增刪改查操作，這裡的資源可以把它看成我們的控制器，

那有了資源之後我們還需要去傳遞具體的方法或者說Action嗎？不需要，這是因為我們的RESTful風格在設計的時候就已經將我們的增刪改查操作對應到具體的HttpMethod方法（即Post、Delete、Put、Get這四大型別）。

下面我們通過具體的例子來看下Web API的路由規則：

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860

namespace MyWebAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ValuesController : ControllerBase
    {
        [HttpGet("{id:int}/Type/{typeId:int=666}")] //訪問路徑：http://localhost:5000/api/values/1/type/666
        //[HttpGet("Get")] //訪問路徑：http://localhost:5000/api/values/get?id=1&typeId=666
        //[Route("/api/[controller]/{id:int}/Type/{typeId:int}")] //訪問路徑：http://localhost:5000/api/values/1/type/666 （不推薦）
        public string Get(int id, int typeId)
        {
            return $"value-Type {id} {typeId}";
        }

        //[HttpGet("{name}")]
        [Route("api/[controller]/{name}")]
        //路由模板不以“/”或“~/”開頭則Action特性路由會和控制器特性路由疊加（合併）
        //訪問路徑：http://localhost:5000/api/values/api/values/abc
        public string OverlyingGet(string name)
        {
            return $"OverlyingGet {name}";
        }

        //同是HttpGet請求時別的Action沒有標記HttpGet情況下則會匹配該Action
        public IEnumerable<string> Test()
        {
            return new string[] { "Test1", "Test2" };
        }

        // GET: api/<ValuesController>
        [HttpGet] //同是HttpGet請求時優先匹配帶有HttpGet特性的
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        // GET api/<ValuesController>/5
        [HttpGet("{id:int?}")]
        public string Get(int id)
        {
            return $"value-{id}";
        }

        // POST api/<ValuesController>
        [HttpPost]
        public void Post([FromBody] string value)
        {
        }

        // PUT api/<ValuesController>/5
        [HttpPut("{id}")]
        public void Put(int id, [FromBody] string value)
        {
        }

        // DELETE api/<ValuesController>/5
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }
    }
}

PS：路由模板不以“/”或“~/”開頭則Action特性路由會和控制器特性路由疊加（合併）。

使用.NET Core CLI來啟動下專案：

可以看出專案啟動成功了，接下來我們使用瀏覽器來模擬HttpGet請求：

首先我們來看下采用MVC傳統路由的方式訪問有什麼效果：

可以看到訪問失敗了，這是因為預設情況下WebApi的路由規則是RESTful風格的，接下來我們來看下正確的訪問方式：

至此，我們已經給大家show完一波RESTful風格的路由規則了，那有人可能會問能不能改成傳統的MVC路由規則呢？接下來我們就來演示一下：

首先要將控制器上面的[Route("api/[controller]")]和[ApiController]特性註釋掉（PS：一旦標記了[ApiController]特性就必須要標記[Route("...")]特性）

然後修改Startup.cs檔案，增加全域性路由模板：

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        //endpoints.MapControllers(); //框架預設生成的
        endpoints.MapControllerRoute(
            name: "defaultWithAreas",
            pattern: "api/{area:exists}/{controller=Home}/{action=Index}/{id?}");

        endpoints.MapControllerRoute(
            name: "default",
            pattern: "api/{controller=Home}/{action=Index}/{id?}");
    });
}

最後重新通過瀏覽器來訪問下：

全域性路由和特性路由可以共存，優先匹配特性路由：

可以看出，此時採用傳統路由規則訪問就能夠成功了。

更多關於.NET Core路由的參考資料，如下：

微軟官網關於ASP.NET Core 中的路由（包括路由約束）：https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/routing?view=aspnetcore-3.1

特性路由合併：https://blog.csdn.net/sinolover/article/details/104329265/

Web API路由：https://blog.csdn.net/qq_34759481/article/details/85018684

關於路由的就介紹到這裡了。

3、使用ajax請求Web API（PS：此處沒有使用RESTful風格，而是採用傳統的路由風格。）

為了演示我們額外建了一個MVC的專案，首先我們來看下MVC的前端程式碼部分：

@{
    ViewData["Title"] = "Home Index";
    Layout = null;
}

<div class="text-center">
    <form id="frmUser">
        <p>
            使用者Id：<input type="text" id="txtId" name="UserID" />
        </p>
        <p>
            <input type="button" id="btnGet1" value="Get1" />
        </p>
        <p>
            <input type="button" id="btnPost1" value="Post1" />
        </p>
        <p>
            <input type="button" id="btnPut1" value="Put1" />
        </p>
        <p>
            <input type="button" id="btnDelete1" value="Delete1" />
        </p>
    </form>

    <script src="~/lib/jquery/dist/jquery.min.js"></script>
    <script>
        var user = { UserID: "10002", UserName: "TianYa", UserEmail: "[email protected]" };
        var dirName = "http://localhost:5001";
        $("#btnGet1").on("click", function () {
            $.ajax({
                url: dirName + "/api/users/GetUserByID",
                type: "get",
                data: $("#frmUser").serialize(),
                success: function (data) {
                    console.log(data);
                },
                datatype: "json"
            });
        });

        $("#btnPost1").on("click", function () {
            $.ajax({
                url: dirName + "/api/users/PostUser",
                type: "post",
                data: user,
                success: function (data) {
                    console.log(data);
                },
                datatype: "json"
            });
        });

        $("#btnPut1").on("click", function () {
            $.ajax({
                url: dirName + "/api/users/PutUser",
                type: "put",
                data: $("#frmUser").serialize(),
                success: function (data) {
                    console.log(data);
                },
                datatype: "json"
            });
        });

        $("#btnDelete1").on("click", function () {
            $.ajax({
                url: dirName + "/api/users/DeleteUser",
                type: "delete",
                data: { "userID": $("#txtId").val() },
                success: function (data) {
                    console.log(data);
                },
                datatype: "json"
            });
        });
    </script>
</div>

接著我們來看下Web API的相關程式碼：

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;

using TianYa.Interface;
using TianYa.Model;

namespace MyWebAPI.Controllers
{
    //[Route("api/[controller]")]
    //[ApiController]
    public class UsersController : ControllerBase
    {
        private readonly IUserService _userService;
        public UsersController(IUserService userService)
        {
            _userService = userService;
        }

        [HttpGet]
        public Users GetUserByID(int userID)
        {
            return _userService.GetModel(userID);
        }

        [HttpPost]
        public Users PostUser(Users user)
        {
            return _userService.GetModel(user.UserID);
        }

        [HttpPut]
        public Users PutUser(Users user)
        {
            return _userService.GetModel(user.UserID);
        }

        [HttpDelete]
        public Users DeleteUser(int userID)
        {
            return _userService.GetModel(userID);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace TianYa.Model
{
    /// <summary>
    /// 使用者
    /// </summary>
    public class Users
    {
        public int UserID { get; set; }
        public string UserName { get; set; }
        public string UserEmail { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

using TianYa.Model;
using TianYa.Interface;

namespace TianYa.Service
{
    /// <summary>
    /// 使用者服務層
    /// </summary>
    public class UserService : IUserService
    {
        private List<Users> _listUsers = new List<Users>();
        public UserService()
        {
            _listUsers.Add(new Users
            {
                UserID = 10000,
                UserName = "張三",
                UserEmail = "[email protected]"
            });
            _listUsers.Add(new Users
            {
                UserID = 10001,
                UserName = "李四",
                UserEmail = "[email protected]"
            });
            _listUsers.Add(new Users
            {
                UserID = 10002,
                UserName = "王五",
                UserEmail = "[email protected]"
            });
            _listUsers.Add(new Users
            {
                UserID = 10003,
                UserName = "趙六",
                UserEmail = "[email protected]"
            });
        }

        public Users GetModel(int userId)
        {
            return _listUsers.FirstOrDefault(m => m.UserID == userId) ?? _listUsers[0];
        }
    }
}

然後使用.NET Core CLI來分別啟動MVC專案和Web API專案，啟動成功後我們來訪問下：

從執行結果中可以發現：

1、在Web API的Action方法中返回的是Users型別，但是響應到前端的時候Web API會幫我們自動轉換成指定的型別（例如：Json或XML）。

2、響應到前端的Json資料的格式預設採用的是駝峰命名法。

那怎麼才能使響應到前端的Json資料保留原來的格式呢？

首先需要先引用Microsoft.AspNetCore.Mvc.NewtonsoftJson 包：

然後修改Startup.cs檔案，如下所示：

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Generic;
using System.Linq;

using TianYa.Interface;
using TianYa.Service;

namespace MyWebAPI
{
    public class Startup
    {
        private readonly string _myCorsPolicy = "MyCorsPolicy";
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers().AddNewtonsoftJson(options =>
            {
                // 忽略迴圈引用
                options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                // 不使用駝峰
                options.SerializerSettings.ContractResolver = new DefaultContractResolver();
                // 設定時間格式
                options.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss";
                // 如欄位為null值，該欄位不會返回到前端
                // options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
            });
            services.AddCors(options => //設定跨域策略
                options.AddPolicy(_myCorsPolicy, builder =>
                 {
                     builder
                        .AllowAnyOrigin()
                        .AllowAnyMethod()
                        .AllowAnyHeader();
                 })
            );
            services.AddTransient<IUserService, UserService>(); //依賴注入
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();
            app.UseAuthorization();
            app.UseCors(_myCorsPolicy);
            app.UseEndpoints(endpoints =>
            {
                //endpoints.MapControllers(); //框架預設生成的
                endpoints.MapControllerRoute(
                            name: "defaultWithAreas",
                            pattern: "api/{area:exists}/{controller=Home}/{action=Index}/{id?}");
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "api/{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

設定完成重新啟動成功後，我們再來訪問下：

從執行結果可以看出此時返回到前端的Json資料保留了原來的格式。

更多關於Web API的可參考微軟官網：

https://docs.microsoft.com/zh-cn/aspnet/core/tutorials/first-web-api?view=aspnetcore-5.0&tabs=visual-studio

https://docs.microsoft.com/zh-cn/aspnet/core/web-api/?view=aspnetcore-5.0

至此本文就全部介紹完了，如果覺得對您有所啟發請記得點個贊哦！！！

此文由博主精心撰寫轉載請保留此原文連結：https://www.cnblogs.com/xyh9039/p/14163991.html

版權宣告：如有雷同純屬巧合，如有侵權請及時聯絡本人修改，謝謝！！！