asp.net-web-api
OData med Asp.net Web API

Installera OData-paketen

Välj NuGet Package Manager> Package Manager Console från Verktyg-menyn. Skriv i fönstret Package Manager Console:

Install-Package Microsoft.AspNet.Odata

Detta kommando installerar de senaste OData NuGet-paketen.

Aktivera enhetsramen

För denna handledning använder vi Entity Framework (EF) Code First för att skapa backend-databasen.

Web API OData kräver inte EF. Använd alla datatillgångsskikt som kan översätta databasenheter till modeller.

Först installerar du NuGet-paketet för EF. Välj NuGet Package Manager > Package Manager Console från Verktyg- menyn. Skriv i fönstret Package Manager Console:

Install-Package EntityFramework

Öppna Web.config-filen och lägg till följande avsnitt i konfigurationselementet efter configSections- elementet.

<configuration>
  <configSections>
    <!-- ... -->
  </configSections>

  <!-- Add this: -->
  <connectionStrings>
    <add name="ProductsContext" connectionString="Data Source=(localdb)\v11.0; 
        Initial Catalog=ProductsContext; Integrated Security=True; MultipleActiveResultSets=True; 
        AttachDbFilename=|DataDirectory|ProductsContext.mdf"
      providerName="System.Data.SqlClient" />
  </connectionStrings>

Den här inställningen lägger till en anslutningssträng för en LocalDB-databas. Denna databas kommer att användas när du kör appen lokalt.

Lägg sedan till en klass med namnet ProductsContext i mappen Modeller:

using System.Data.Entity;
namespace ProductService.Models
{
    public class ProductsContext : DbContext
    {
        public ProductsContext() 
                : base("name=ProductsContext")
        {
        }
        public DbSet<Product> Products { get; set; }
    }
}

I konstruktören ger "name = ProductsContext" namnet på anslutningssträngen.

Konfigurera OData Endpoint

Öppna filen App_Start / WebApiConfig.cs. Lägg till följande med uttalanden:

using ProductService.Models;
using System.Web.OData.Builder;
using System.Web.OData.Extensions;

Lägg sedan till följande kod i metoden Register :

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        // New code:
        ODataModelBuilder builder = new ODataConventionModelBuilder();
        builder.EntitySet<Product>("Products");
        config.MapODataServiceRoute(
            routeName: "ODataRoute",
            routePrefix: null,
            model: builder.GetEdmModel());
    }
}

Den här koden gör två saker:

• Skapar en enhetsdatamodell (EDM).
• Lägger till en rutt.

En EDM är en abstrakt modell av data. EDM används för att skapa tjänstens metadatadokument. ODataConventionModelBuilder- klassen skapar en EDM med standardnamnkonventioner. Denna metod kräver minst kod. Om du vill ha mer kontroll över EDM kan du använda klassen ODataModelBuilder för att skapa EDM genom att lägga till egenskaper, nycklar och navigationsegenskaper uttryckligen.

En rutt berättar Web API för hur du dirigerar HTTP-förfrågningar till slutpunkten. För att skapa en OData v4-rutt, ring till MapODataServiceRoute- förlängningsmetoden.

Om din applikation har flera OData-slutpunkter, skapa en separat rutt för varje. Ge varje rutt ett unikt ruttnamn och prefix.

Lägg till OData Controller

En controller är en klass som hanterar HTTP-förfrågningar. Du skapar en separat controller för varje enhet som är inställd i din OData-tjänst. I denna handledning skapar du en kontroller för produktenheten.

Högerklicka på mappen Controllers i Solution Explorer och välj Lägg till > Klass . Namnge klassen ProductsController.

I versionen av denna självstudie för OData v3 används Add Controller-ställningar. För närvarande finns det inga ställningar för OData v4.

Byt ut pannplåtkoden i ProductsController.cs med följande.

using ProductService.Models;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using System.Web.Http;
using System.Web.OData;
namespace ProductService.Controllers
{
    public class ProductsController : ODataController
    {
        ProductsContext db = new ProductsContext();
        private bool ProductExists(int key)
        {
            return db.Products.Any(p => p.Id == key);
        } 
        protected override void Dispose(bool disposing)
        {
            db.Dispose();
            base.Dispose(disposing);
        }
    }
}

Styrenheten använder klassen ProductsContext för att komma åt databasen med EF. Observera att regulatorn åsidosätter dispositionsmetoden för att kassera ProductsContext .

Detta är startpunkten för regulatorn. Därefter lägger vi till metoder för alla CRUD-operationer.

Utför CRUD på enhetsuppsättningen

Fråga efter entitetsuppsättningen

Lägg till följande metoder i ProductsController .

[EnableQuery]
public IQueryable<Product> Get()
{
    return db.Products;
}

[EnableQuery]
public SingleResult<Product> Get([FromODataUri] int key)
{
    IQueryable<Product> result = db.Products.Where(p => p.Id == key);
    return SingleResult.Create(result);
}

Den parameterlösa versionen av Get-metoden returnerar hela produktsamlingen. Get-metoden med en nyckelparameter letar upp en produkt efter dess nyckel (i detta fall ID-egenskapen).

Attributet [EnableQuery] gör det möjligt för klienter att ändra frågan med hjälp av frågeställningsalternativ som $ filter, $ sort och $ page. Mer information finns i Stödja OData-frågeställningsalternativ .

Lägga till en enhet i entitetsuppsättningen

För att klienter ska kunna lägga till en ny produkt i databasen lägger du till följande metod i ProductsController .

public async Task<IHttpActionResult> Post(Product product)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
    db.Products.Add(product);
    await db.SaveChangesAsync();
    return Created(product);
}

Uppdatera en enhet

OData stöder två olika semantik för uppdatering av en enhet, PATCH och PUT.

• PATCH utför en delvis uppdatering. Klienten anger bara egenskaperna som ska uppdateras.
• PUT ersätter hela enheten.

Nackdelen med PUT är att klienten måste skicka värden för alla egenskaperna i enheten, inklusive värden som inte förändras. OData-specifikationen anger att PATCH är att föredra.

I vilket fall som helst, här är koden för både PATCH- och PUT-metoder:

public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Product> product)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
    var entity = await db.Products.FindAsync(key);
    if (entity == null)
    {
        return NotFound();
    }
    product.Patch(entity);
    try
    {
        await db.SaveChangesAsync();
    }
    catch (DbUpdateConcurrencyException)
    {
        if (!ProductExists(key))
        {
            return NotFound();
        }
        else
        {
            throw;
        }
    }
    return Updated(entity);
}

public async Task<IHttpActionResult> Put([FromODataUri] int key, Product update)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
    if (key != update.Id)
    {
        return BadRequest();
    }
    db.Entry(update).State = EntityState.Modified;
    try
    {
        await db.SaveChangesAsync();
    }
    catch (DbUpdateConcurrencyException)
    {
        if (!ProductExists(key))
        {
            return NotFound();
        }
        else
        {
            throw;
        }
    }
    return Updated(update);
}

När det gäller PATCH använder styrenheten typen Delta <T> för att spåra ändringarna.

Radera en enhet

Lägg till följande metod i ProductsController för att göra det möjligt för kunder att radera en produkt från databasen.

public async Task<IHttpActionResult> Delete([FromODataUri] int key)
{
    var product = await db.Products.FindAsync(key);
    if (product == null)
    {
        return NotFound();
    }
    db.Products.Remove(product);
    await db.SaveChangesAsync();
    return StatusCode(HttpStatusCode.NoContent);
}