Asp.net WebApi 项目示例（增删改查）

1.WebApi是什么

       ASP.NET Web API 是一种框架，用于轻松构建可以由多种客户端（包括浏览器和移动设备）访问的 HTTP 服务。ASP.Net Web API 是一种用于在 .NET Framework 上构建 RESTful 应用程序的理想平台。

    可以把WebApi看成Asp.Net项目类型中的一种，其他项目类型诸如我们熟知的WebForm项目，Windows窗体项目，控制台应用程序等。

    WebApi类型项目的最大优势就是，开发者再也不用担心客户端和服务器之间传输的数据的序列化和反序列化问题，因为WebApi是强类型的，可以自动进行序列化和反序列化，一会儿项目中会见到。

    下面我们建立了一个WebApi类型的项目，项目中对产品Product进行增删改查，Product的数据存放在List<>列表（即内存）中。

2.页面运行效果

如图所示，可以添加一条记录; 输入记录的Id，查询出该记录的其它信息； 修改该Id的记录； 删除该Id的记录。

3.二话不说，开始建项目

1）新建一个“ASP.NET MVC 4 Web 应用程序”项目，命名为“ProductStore”,点击确定，如图

2）选择模板“Web API”，点击确定，如图

3）和MVC类型的项目相似，构建程序的过程是先建立数据模型（Model）用于存取数据,

     再建立控制器层（Controller）用于处理发来的Http请求，最后构造显示层（View）用于

     接收用户的输入和用户进行直接交互。

 

     这里我们先在Models文件夹中建立产品Product类： Product.cs，如下：

 

[csharp] view plain copy
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Web;  
  5.   
  6. namespace ProductStore.Models  
  7. {  
  8.     public class Product  
  9.     {  
  10.         public int Id { get; set; }  
  11.         public string Name { get; set; }  
  12.         public string Category { get; set; }  
  13.         public decimal Price { get; set; }  
  14.     }  
  15. }  


4）试想，我们目前只有一个Product类型的对象，我们要编写一个类对其实现增删改查，以后我们可能会增加其他的类型的对象，再需要编写一个对新类型的对象进行增删改查的类，为了便于拓展和调用，我们在Product之上构造一个接口，使这个接口约定增删改查的方法名称和参数，所以我们在Models文件夹中新建一个接口：  IProductRepository.cs ，如下：

 

 

[csharp] view plain copy
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Threading.Tasks;  
  6.   
  7. namespace ProductStore.Models  
  8. {  
  9.     interface IProductRepository  
  10.     {  
  11.         IEnumerable<Product> GetAll();  
  12.         Product Get(int id);  
  13.         Product Add(Product item);  
  14.         void Remove(int id);  
  15.         bool Update(Product item);  
  16.     }  
  17. }  

5）然后，我们实现这个接口，在Models文件夹中新建一个类，具体针对Product类型的对象进行增删改查存取数据，并在该类的构造方法中，向List<Product>列表中存入几条数据，这个类叫：ProductRepository.cs，如下：

 

 

[csharp] view plain copy
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Web;  
  5.   
  6. namespace ProductStore.Models  
  7. {  
  8.     public class ProductRepository:IProductRepository  
  9.     {  
  10.         private List<Product> products = new List<Product>();  
  11.         private int _nextId = 1;  
  12.         public ProductRepository()  
  13.         {  
  14.             Add(new Product { Name="Tomato soup",Category="Groceries",Price=1.39M});  
  15.             Add(new Product { Name="Yo-yo",Category="Toys",Price=3.75M});  
  16.             Add(new Product { Name = "Hammer", Category = "Hardware", Price = 16.99M });  
  17.         }  
  18.   
  19.   
  20.         public IEnumerable<Product> GetAll()  
  21.         {  
  22.             return products;  
  23.         }  
  24.   
  25.         public Product Get(int id)  
  26.         {  
  27.             return products.Find(p=>p.Id==id);  
  28.         }  
  29.   
  30.         public Product Add(Product item)  
  31.         {  
  32.             if (item == null)  
  33.             {  
  34.                 throw new ArgumentNullException("item");  
  35.             }  
  36.             item.Id = _nextId++;  
  37.             products.Add(item);  
  38.             return item;  
  39.         }  
  40.   
  41.         public void Remove(int id)  
  42.         {  
  43.             products.RemoveAll(p=>p.Id==id);  
  44.         }  
  45.   
  46.         public bool Update(Product item)  
  47.         {  
  48.             if (item == null)  
  49.             {  
  50.                 throw new ArgumentNullException("item");  
  51.             }  
  52.             int index = products.FindIndex(p=>p.Id==item.Id);  
  53.             if (index == -1)  
  54.             {  
  55.                 return false;  
  56.             }  
  57.             products.RemoveAt(index);  
  58.             products.Add(item);  
  59.             return true;  
  60.         }  
  61.     }  
  62. }  

 

    此时，Model层就构建好了。

6）下面，我们要构建Controller层，在此之前，先回顾一下Http中几种请求类型，如下

 

     get  类型  用于从服务器端获取数据，且不应该对服务器端有任何操作和影响

     post 类型  用于发送数据到服务器端，创建一条新的数据，对服务器端产生影响

     put 类型  用于向服务器端更新一条数据，对服务器端产生影响 （也可创建一条新的数据但不推荐这样用）

     delete 类型 用于删除一条数据，对服务器端产生影响

 

     这样，四种请求类型刚好可对应于对数据的 查询，添加，修改，删除。WebApi也推荐如此使用。在WebApi

项目中，我们请求的不再是一个具体页面，而是各个控制器中的方法（控制器也是一种类，默认放在Controllers

文件夹中）。下面我们将要建立一个ProductController.cs控制器类，其中的方法都是以“Get Post Put Delete”中

的任一一个开头的，这样的开头使得Get类型的请求发送给以Get开头的方法去处理，Post类型的请求交给Post开头的方法去处理，Put和Delete同理。

    而以Get开头的方法有好几个也是可以的，此时如何区分到底交给哪个方法执行呢？这就取决于Get开头的方法们的传入参数了，一会儿在代码中可以分辨。

   构建Controller层，在Controllers文件夹中建立一个ProductController.cs控制器类，如下：

 

[csharp] view plain copy
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Web;  
  5. using System.Web.Mvc;  
  6. using ProductStore.Models;  
  7. using System.Web.Http;  
  8. using System.Net;  
  9. using System.Net.Http;  
  10.   
  11. namespace ProductStore.Controllers  
  12. {  
  13.     public class ProductsController : ApiController  
  14.     {  
  15.         static readonly IProductRepository repository = new ProductRepository();  
  16.   
  17.         //GET:  /api/products  
  18.         public IEnumerable<Product> GetAllProducts()  
  19.         {  
  20.             return repository.GetAll();  
  21.         }  
  22.   
  23.         //GET: /api/products/id  
  24.         public Product GetProduct(int id)  
  25.         {  
  26.             Product item = repository.Get(id);  
  27.             if (item == null)  
  28.             {  
  29.                 throw new HttpResponseException(HttpStatusCode.NotFound);              
  30.             }  
  31.             return item;  
  32.         }  
  33.   
  34.         //GET: /api/products?category=category  
  35.         public IEnumerable<Product> GetProductsByCategory(string category)  
  36.         {  
  37.             return repository.GetAll().Where(p=>string.Equals(p.Category,category,StringComparison.OrdinalIgnoreCase));  
  38.         }  
  39.   
  40.         //POST: /api/products  
  41.         public HttpResponseMessage PostProduct(Product item)  
  42.         {  
  43.             item = repository.Add(item);  
  44.   
  45.             var response = Request.CreateResponse<Product>(HttpStatusCode.Created,item);  
  46.             string uri = Url.Link("DefaultApi", new { id=item.Id});  
  47.             response.Headers.Location = new Uri(uri);  
  48.   
  49.             return response;  
  50.         }  
  51.   
  52.         //PUT: /api/products/id  
  53.         public void PutProduct(int id, Product product)  
  54.         {  
  55.             product.Id = id;  
  56.             if (!repository.Update(product))  
  57.             {  
  58.                 throw new HttpResponseException(HttpStatusCode.NotFound);  
  59.             }  
  60.         }  
  61.   
  62.         //Delete: /api/products/id  
  63.         public void DeleteProduct(int id)  
  64.         {  
  65.             Product item = repository.Get(id);  
  66.             if (item == null)  
  67.             {  
  68.                 throw new HttpResponseException(HttpStatusCode.NotFound);  
  69.             }  
  70.             repository.Remove(id);  
  71.         }  
  72.     }  
  73. }  

 

    使该类继承于ApiController类，在其中实现处理各种Get,Post,Put,Delete类型Http请求的方法。

每一个方法前都有一句注释，标识了该方法的针对的请求的类型（取决于方法的开头），以及

要请求到该方法，需要使用的url。

 这些url是有规律的，见下图：

api是必须的，products对应的是ProductsControllers控制器，然后又Http请求的类型和url的

后边地址决定。

这里，我们除了第三个“Get a product by category”,其他方法都实现了。

7）最后，我们来构建View视图层，我们更改Views文件夹中的Home文件夹下的Index.cshtml文件，

这个文件是项目启动页，如下：

 

[html] view plain copy
 
  1. <div id="body">  
  2.     <script src="~/Scripts/jquery-1.8.2.min.js"></script>  
  3.     <section >  
  4.           <h2>添加记录</h2>  
  5.           Name:<input id="name" type="text" /><br />  
  6.           Category:<input id="category" type="text" />  
  7.           Price:<input id="price" type="text" /><br />  
  8.           <input id="addItem" type="button" value="添加" />  
  9.     </section>  
  10.   
  11.     <section>  
  12.         <br />  
  13.         <br />  
  14.           <h2>修改记录</h2>  
  15.           Id：<input id="id2" type="text" /><br />  
  16.           Name:<input id="name2" type="text" /><br />  
  17.           Category:<input id="category2" type="text" />  
  18.           Price:<input id="price2" type="text" /><br />  
  19.           <input id="showItem" type="button" value="查询" />  
  20.           <input id="editItem" type="button" value="修改" />  
  21.           <input id="removeItem" type="button" value="删除" />  
  22.     </section>  
  23.   
  24. </div>  


8）然后我们给页面添加js代码，对应上面的按钮事件，用来发起Http请求，如下：

 

 

[javascript] view plain copy
 
  1. <script>  
  2.       //用于保存用户输入数据  
  3.       var Product = {  
  4.           create: function () {  
  5.               Id: "";  
  6.               Name: "";  
  7.               Category: "";  
  8.               Price: "";  
  9.               return Product;  
  10.           }  
  11.       }  
  12.   
  13.       //添加一条记录 请求类型:POST  请求url:  /api/Products    
  14.       //请求到ProductsController.cs中的 public HttpResponseMessage PostProduct(Product item) 方法  
  15.       $("#addItem").click(function () {  
  16.           var newProduct = Product.create();  
  17.           newProduct.Name = $("#name").val();  
  18.           newProduct.Category = $("#category").val();  
  19.           newProduct.Price = $("#price").val();  
  20.   
  21.           $.ajax({  
  22.               url: "/api/Products",  
  23.               type: "POST",  
  24.               contentType: "application/json; charset=utf-8",  
  25.               data: JSON.stringify(newProduct),  
  26.               success: function () {  
  27.                   alert("添加成功！");  
  28.               },  
  29.               error: function (XMLHttpRequest, textStatus, errorThrown) {  
  30.                   alert("请求失败，消息：" + textStatus + "  " + errorThrown);  
  31.               }  
  32.           });  
  33.       });  
  34.   
  35.       //先根据Id查询记录  请求类型:GET  请求url:  /api/Products/Id    
  36.       //请求到ProductsController.cs中的 public Product GetProduct(int id) 方法  
  37.       $("#showItem").click(function () {  
  38.           var inputId = $("#id2").val();  
  39.           $("#name2").val("");  
  40.           $("#category2").val("");  
  41.           $("#price2").val("");  
  42.           $.ajax({  
  43.               url: "/api/Products/" + inputId,  
  44.               type: "GET",  
  45.               contentType: "application/json; charset=urf-8",  
  46.               success: function (data) {  
  47.                   $("#name2").val(data.Name);  
  48.                   $("#category2").val(data.Category);  
  49.                   $("#price2").val(data.Price);  
  50.               },  
  51.               error: function (XMLHttpRequest, textStatus, errorThrown) {  
  52.                   alert("请求失败，消息：" + textStatus + "  " + errorThrown);  
  53.               }  
  54.           });  
  55.       });  
  56.   
  57.       //修改该Id的记录 请求类型:PUT  请求url:  /api/Products/Id    
  58.       //请求到ProductsController.cs中的 public void PutProduct(int id, Product product) 方法  
  59.       $("#editItem").click(function () {  
  60.           var inputId = $("#id2").val();  
  61.           var newProduct = Product.create();  
  62.           newProduct.Name = $("#name2").val();  
  63.           newProduct.Category = $("#category2").val();  
  64.           newProduct.Price = $("#price2").val();  
  65.   
  66.           $.ajax({  
  67.               url: "/api/Products/" + inputId,  
  68.               type: "PUT",  
  69.               data: JSON.stringify(newProduct),   
  70.               contentType: "application/json; charset=urf-8",  
  71.               success: function () {  
  72.                   alert("修改成功！ ");  
  73.               },  
  74.               error: function (XMLHttpRequest, textStatus, errorThrown) {  
  75.                   alert("请求失败，消息：" + textStatus + "  " + errorThrown);  
  76.               }  
  77.           });  
  78.       });  
  79.   
  80.       //删除输入Id的记录  请求类型:DELETE  请求url:  /api/Products/Id    
  81.       //请求到ProductsController.cs中的  public void DeleteProduct(int id) 方法  
  82.       $("#removeItem").click(function () {  
  83.           var inputId = $("#id2").val();  
  84.           $.ajax({  
  85.               url: "/api/Products/" + inputId,  
  86.               type: "DELETE",  
  87.               contentType: "application/json; charset=uft-8",  
  88.               success: function (data) {                     
  89.                       alert("Id为 " + inputId + " 的记录删除成功！");  
  90.               },  
  91.               error: function (XMLHttpRequest, textStatus, errorThrown) {  
  92.                   alert("请求失败，消息：" + textStatus + "  " + errorThrown);  
  93.               }  
  94.           });  
  95.       });  
  96.   </script>  


    这里，WebApi的一个简单的增删改查项目就完成了，选择执行项目即可测试。注意到，其中用ajax发起请求时，

发送到服务器端的数据直接是一个json字符串，当然这个json字符串中每个字段要和Product.cs类中的每个字段同名对应，在服务器端接收数据的时候，我们并没有对接收到的数据进行序列化，而返回数据给客户端的时候也并没有对数据进行反序列化，大大节省了以前开发中不停地进行序列化和反序列化的时间。

 

posted on 2017-06-08 15:51  alex5211314  阅读(348)  评论(0)    收藏  举报

导航