Das erste Beispiel des anwendbaren Szenarios der ASP.NET WEB API

In meinem vorherigen Blog habe ich Ihnen eine kurze Einführung in die Beziehung zwischen dem HTTP-Protokoll und der RestFul-API sowie einige grundlegende Kenntnisse über das HTTP-Protokoll gegeben Besprechen Sie gemeinsam die anwendbaren Szenarien der WEB-API, schreiben Sie dann unsere erste WEB-API-Schnittstelle und demonstrieren Sie, wie Sie sie einfach aufrufen.

Viele Menschen sind verwirrt, warum brauchen wir jetzt, wo wir WCF haben, eine WEB-API? Wird die WEB-API WCF ersetzen?

Meiner Meinung nach bietet WCF eine Sammlung von RPC-Implementierungen. Das Design von WCF berücksichtigt SOA-Szenarien und verschiedene RPC-Probleme. Viele Leute werden auch sagen, dass die RestFul-API auch eine Art RPC ist und es auch eine Implementierung von RestFul in WCF gibt. In vielen Materialien gibt es einige Unterschiede in den Stilkonzepten zwischen RPC und RestFul. Tatsächlich ist der Unterschied zwischen den beiden eher subjektiv, und ich konzentriere mich hauptsächlich auf einige Probleme bei der tatsächlichen Verwendung , Es gibt viele unterstützte Protokolle, einschließlich der Protokolle der WS-*-Serie, sowie einige prägnantere Protokolle, die einige dedizierte Kommunikationsprotokolle mit sehr hoher Leistung bereitstellen, und WCF bietet meiner Meinung nach auch Funktionen wie Service Discovery Für interne Systeme stehen auch andere RPC-Lösungen zur Auswahl. Beispielsweise sind gRPC, Avor und Thrift Produkte mit derselben Positionierung wie WCF Auf dieser Basis kann jede Sprache und jedes Terminal problemlos verbunden werden und verschiedene sehr ausgereifte HTTP-Infrastrukturen und -Lösungen für Entwicklung, Debugging, Lastausgleich und Inhaltsverteilung nutzen. Daher ist WEB API ein Entwicklungsframework für HTTP, das sich auf die schnelle Entwicklung offener APIs im RestFul-Stil konzentriert. Derzeit scheint es, dass es WCF nicht ersetzen kann. Sie haben jeweils ihre eigenen geeigneten Szenarien, und die WEB-API kann nicht als Ersatz für WCF angesehen werden.

OK, jetzt entwickeln wir den ersten Satz WEB-API-Schnittstellen! Versionen, die VS2012 und höher verwenden, verfügen über vorgefertigte WEB-API-Erstellungsvorlagen. Nach der Erstellung sind MVC- und WEB-API-Projekte im Projekt vorhanden, die nicht separat erstellt werden können. Sowohl die WEB-API als auch die MVC verwenden ähnliche Routing-Mechanismen. Daher verwendet die WEB-API in der Standardroute

/api/{controller}/{id}

als Route. Fügen Sie /api hinzu / Abschnitt zur Unterscheidung zwischen MVC und Web-API.

Als nächstes fügen wir einen WEB-API-Controller namens PersonController hinzu, der von ApiController erbt. Beim Erstellen dieses Controllers definieren wir eine Ressource: Person, alle Vorgänge in PersonController Sie drehen sich alle um die Ressource Person. Als Nächstes beginnen wir mit der Definition einer Reihe von Vorgängen zum Hinzufügen, Löschen, Ändern und Überprüfen.

In der Web-API folgt das Standardrouting einer Konvention: Das Routing basiert auf Prädikaten, und das Präfix des Methodennamens ist das HTTP-Prädikat, das zum Aufrufen der Methode verwendet wird. Das Codebeispiel lautet wie folgt:

/// <summary>

    /// Person 为资源，对Person进行的一组操作    /// </summary>

    public class PersonController : ApiController

    {        private static List<Person> _personLst = new List<Person>();       

        /// <summary>

        /// 获取一个Person        /// </summary>

        /// <param name="id">Person的ID</param>

        /// <returns>Person</returns>

        public Person GetPerson(long id)

        {            return _personLst.Find(x => x.Id == id);

        } 

        /// <summary>

        /// 添加一个Person        /// </summary>

        /// <param name="person">Person</param>

        public void PostAddPerson(Person person)

        {

            _personLst.Add(person);

        } 

        /// <summary>

        /// 修改一个        /// </summary>

        /// <param name="id">Person Id</param>

        /// <param name="person">新</param>

        public void PutModifyPerson(long id, Person person)

        {            var p = _personLst.Find(x => x.Id == id);

            p.Age = person.Age;

            p.Name = person.Name;

            p.Sex = person.Sex;

        } 

        /// <summary>

        /// 删除一个Person        /// </summary>

        /// <param name="id">Person ID</param>

        public void DeletePerson(long id)

        {

            _personLst.RemoveAll(x => x.Id == id);

        }

}

Eine einfache API für CRUD-Operationen auf Ressourcen reicht aus, kein Parsen ist eine Eingabe erforderlich, die Ausgabe muss nicht gespleißt werden, so einfach ist das! Lass uns spazieren gehen!

Senden Sie eine Anfrage: Das Prädikat ist POST, die Semantik besteht darin, eine Person zu erstellen, die Person wird im Körper beschrieben und der Kopf erklärt dass der Body über Json serialisiert wird.

Antwort erhalten: Antwortcode 204, gehört zum Typ 2XX, Ausführung erfolgreich, keine Daten im Textkörper

Anfrage senden: Prädikat ist GET, Semantik ist Die Abfrage-Personenressource mit der ID 1 gibt im Kopf an, dass sie hofft, mithilfe von XML serialisierte Daten zu empfangen.

Erhaltene Antwort: Antwortcode ist 200, die Ausführung ist erfolgreich, es sind Daten im Körper vorhanden und die Daten sind vorhanden serialisiert mit XML

Anfrage senden: Das Prädikat ist PUT, die Semantik besteht darin, die Personenressource mit ID 1 zu ändern, der geänderte Inhalt befindet sich im Körper, der Inhalt- Der Typ gibt an, dass der Body die Json-Serialisierung verwendet. Im Body setzen wir Name Modify auf Test1Changed

Antwort erhalten, Antwortcode ist 204, Ausführung ist erfolgreich

Anfrage senden: Prädikat ist GET, Semantik ist Abfrageperson mit ID 1-Ressource, Akzeptieren gibt an, dass es hofft, Json-Daten zu empfangen

Antwort erhalten: Sie können sehen, dass der Körper der mit Json serialisierte Inhalt und der Name ist Attribut wurde in Test1Changed geändert

Anfrage senden: Prädikat ist DELETE, Semantik besteht darin, Personenressource mit ID 1 zu löschen

Antwort empfangen: Antwortcode 204, Ausführung erfolgreich

发送请求：谓词为GET，语义为查询ID为1的Person资源，Accept标明希望接收到Json数据

收到响应：响应码为200，执行成功，响应内容为null，资源已删除

 

这就是我用Fiddler来发送、调用的一组RestFul接口，大家可以看到，整个调用过程使用到了HTTP的语义，用到了谓词路由、内容协商。在增、删、改操作中，我都是使用void作为返回值，根据HTTP Code 判断，大家也可以自定义一些返回数据来做出更进一步的操作描述。

 

在写了这些API后，我们需要在程序中调用，我以C#为例写一组对这些接口调用的实现。在C#中，传统调用HTTP接口一般有两种办法： WebRequest/WebResponse组合的方法调用和WebClient类进行调用。第一种方法抽象程度较低，使用较为繁琐；而WebClient主要面向了WEB网页场景，在模拟Web操作时使用较为方便，但用在RestFul场景下却比较麻烦，在Web API发布的同时，.NET提供了两个程序集：System.Net.Http和System.Net.Http.Formatting。这两个程序集中最核心的类是HttpClient。在.NET4.5中带有这两个程序集，而.NET4需要到Nuget里下载Microsoft.Net.Http和Microsoft.AspNet.WebApi.Client这两个包才能使用这个类，更低的.NET版本就只能表示遗憾了只能用WebRequest/WebResponse或者WebClient来调用这些API了。

       在使用中，System.Net.Http这个程序集提供了HttpClient类以及相关的HTTP调用，而System.Net.Http.Formatting提供了一些针对HttpClient的帮助扩展，更好地支持了内容协商、Content创建等功能。下面我就和大家一起写一下这个例子：

       我们新建一个控制台程序：

       代码如下：

public class Person

    {        public long Id { get; set; }        public string Name { get; set; } 

        public int Age { get; set; } 

        public string Sex { get; set; } 

        public override string ToString()

        {            return $"Id={Id} Name={Name} Age={Age} Sex={Sex}";

        }

    } 

    class Program

    {        static void Main(string[] args)

        {            var client = new HttpClient();

 

            client.BaseAddress = new Uri("http://localhost:22658/"); //基本的API URL
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); //默认希望响应使用Json序列化
 

 

            Run(client);

 

            Console.ReadLine();

 

        } 

        static async void Run(HttpClient client)

        {            var result = await AddPerson(client);

            Console.WriteLine($"添加结果：{result}"); //添加结果：true

 

            var person = await GetPerson(client);

            Console.WriteLine($"查询结果：{person}"); //查询结果：Id=1 Name=test Age=10 Sex=F
 

            result = await PutPerson(client);

            Console.WriteLine($"更新结果：{result}"); //更新结果：true
 

            result = await DeletePerson(client);

            Console.WriteLine($"删除结果：{result}"); //删除结果：true
        } 

        static async Task<bool> AddPerson(HttpClient client)

        {            return await client.PostAsJsonAsync("api/Person", new Person() { Age = 10, Id = 1, Name = "test", Sex = "F" }) //向Person发送POST请求，Body使用Json进行序列化
                                     .ContinueWith(x => x.Result.IsSuccessStatusCode);  //返回请求是否执行成功，即HTTP Code是否为2XX
        } 

        static async Task<Person> GetPerson(HttpClient client)

        {            return await await client.GetAsync("api/Person/1") //向Person发送GET请求
                .ContinueWith(x => x.Result.Content.ReadAsAsync<Person>(                              //获取返回Body，并根据返回的Content-Type自动匹配格式化器反序列化Body

                    new List<MediaTypeFormatter>() {new JsonMediaTypeFormatter()/*这是Json的格式化器*/

                                                    ,new XmlMediaTypeFormatter()/*这是XML的格式化器*/}));

 

        } 

        static async Task<bool> PutPerson(HttpClient client)

        {            return await client.PutAsJsonAsync("api/Person/1", new Person() { Age = 10, Id = 1, Name = "test1Change", Sex = "F" }) //向Person发送PUT请求，Body使用Json进行序列化
                                    .ContinueWith(x => x.Result.IsSuccessStatusCode);  //返回请求是否执行成功，即HTTP Code是否为2XX
        } 

        static async Task<bool> DeletePerson(HttpClient client)

        {            return await client.DeleteAsync("api/Person/1") //向Person发送DELETE请求
                .ContinueWith(x => x.Result.IsSuccessStatusCode); //返回请求是否执行成功，即HTTP Code是否为2XX
        }

}

 

    这就完成了这组API的调用，是不是非常简单方便？HTTPClient使用全异步的方法，并且他有良好的扩展性，我会在之后的博客中再聊这个问题。

    OK，到此为止一组简单的Restful API和C#的调用客户端就完成了，但这只是开始，Web API是一个很强大的框架，他的扩展点非常丰富，这些扩展能为我们的开发提供很多的帮助，下一篇博文我将为大家带来WEB API中Filter的使用。

    博文中如有不正确的地方欢迎大家指正。

Das obige ist der detaillierte Inhalt vonDas erste Beispiel des anwendbaren Szenarios der ASP.NET WEB API. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!