asp.net-web-api
OData mit der Asp.net-Web-API

Installieren Sie die OData-Pakete

Wählen Sie im Menü Extras die Option NuGet Package Manager> Package Manager Console. Geben Sie im Fenster der Package Manager Console Folgendes ein:

Install-Package Microsoft.AspNet.Odata

Dieser Befehl installiert die neuesten OData NuGet-Pakete.

Aktivieren Sie Entity Framework

In diesem Lernprogramm verwenden wir zuerst Entity Framework-Code (EF), um die Back-End-Datenbank zu erstellen.

Web API OData erfordert keine EF. Verwenden Sie eine beliebige Datenzugriffsebene, die Datenbankobjekte in Modelle übersetzen kann.

Installieren Sie zuerst das NuGet-Paket für EF. Wählen Sie im Menü Extras die Option NuGet Package Manager > Package Manager Console . Geben Sie im Fenster der Package Manager Console Folgendes ein:

Install-Package EntityFramework

Öffnen Sie die Datei Web.config und fügen Sie nach dem Element configSections den folgenden Abschnitt innerhalb des Konfigurationselements hinzu .

<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>

Diese Einstellung fügt eine Verbindungszeichenfolge für eine LocalDB-Datenbank hinzu. Diese Datenbank wird verwendet, wenn Sie die App lokal ausführen.

Fügen Sie dem Ordner Models eine Klasse mit dem Namen ProductsContext hinzu:

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

Im Konstruktor gibt "name = ProductsContext" den Namen der Verbindungszeichenfolge an.

Konfigurieren Sie den OData-Endpunkt

Öffnen Sie die Datei App_Start / WebApiConfig.cs. Fügen Sie die folgenden using- Anweisungen hinzu:

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

Fügen Sie der Register- Methode dann den folgenden Code hinzu:

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());
    }
}

Dieser Code führt zwei Dinge aus:

• Erzeugt ein Entity Data Model (EDM).
• Fügt eine Route hinzu.

Ein EDM ist ein abstraktes Modell der Daten. Das EDM wird zum Erstellen des Service-Metadatendokuments verwendet. Die ODataConventionModelBuilder- Klasse erstellt eine EDM unter Verwendung von Standardbenennungskonventionen. Dieser Ansatz erfordert den geringsten Code. Wenn Sie mehr Kontrolle über das EDM haben möchten, können Sie die EDM mithilfe der ODataModelBuilder- Klasse erstellen, indem Sie Eigenschaften, Schlüssel und Navigationseigenschaften explizit hinzufügen.

Eine Route teilt der Web-API mit, wie sie HTTP-Anforderungen an den Endpunkt weiterleiten soll. Um eine OData v4-Route zu erstellen, rufen Sie die MapODataServiceRoute- Erweiterungsmethode auf.

Wenn Ihre Anwendung über mehrere OData-Endpunkte verfügt, erstellen Sie für jede eine separate Route. Geben Sie jeder Route einen eindeutigen Routennamen und ein Präfix.

Fügen Sie den OData Controller hinzu

Ein Controller ist eine Klasse, die HTTP-Anforderungen verarbeitet. Sie erstellen einen separaten Controller für jede Entität, die in Ihrem OData-Service festgelegt ist. In diesem Lernprogramm erstellen Sie einen Controller für die Produktentität.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Controller" und wählen Sie Hinzufügen > Klasse . Benennen Sie die Klasse ProductsController.

Die Version dieses Lernprogramms für OData v3 verwendet das Gerüst "Controller hinzufügen". Derzeit gibt es für OData v4 kein Gerüst.

Ersetzen Sie den Boilerplate-Code in ProductsController.cs durch Folgendes.

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);
        }
    }
}

Der Controller verwendet die ProductsContext- Klasse, um über EF auf die Datenbank zuzugreifen. Beachten Sie, dass der Controller die Dispose- Methode überschreibt, um den ProductsContext zu entsorgen.

Dies ist der Ausgangspunkt für die Steuerung. Als Nächstes fügen wir Methoden für alle CRUD-Vorgänge hinzu.

CRUD im Entity Set durchführen

Abfragen des Entity-Sets

Fügen Sie ProductsController die folgenden Methoden hinzu.

[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);
}

Die parameterlose Version der Get-Methode gibt die gesamte Products-Auflistung zurück. Die Get-Methode mit einem Schlüsselparameter sucht ein Produkt anhand seines Schlüssels (in diesem Fall der Id-Eigenschaft).

Mit dem Attribut [EnableQuery] können Clients die Abfrage mithilfe von Abfrageoptionen wie $ filter, $ sort und $ page ändern. Weitere Informationen finden Sie unter Unterstützung von OData-Abfrageoptionen .

Entität zum Entity-Set hinzufügen

Um Clients das Hinzufügen eines neuen Produkts zur Datenbank zu ermöglichen, fügen Sie ProductsController die folgende Methode hinzu.

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

Aktualisieren einer Entität

OData unterstützt zwei verschiedene Semantiken zum Aktualisieren einer Entität, PATCH und PUT.

• PATCH führt eine teilweise Aktualisierung durch. Der Client gibt nur die zu aktualisierenden Eigenschaften an.
• PUT ersetzt die gesamte Entität.

Der Nachteil von PUT besteht darin, dass der Client Werte für alle Eigenschaften in der Entität senden muss, einschließlich der Werte, die sich nicht ändern. Die OData-Spezifikation gibt an, dass PATCH bevorzugt wird.

In jedem Fall ist hier der Code für beide Methoden PATCH und PUT:

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);
}

Im Falle von PATCH verwendet der Controller den Typ Delta <T> , um die Änderungen zu verfolgen.

Entität löschen

Fügen Sie ProductsController die folgende Methode hinzu, damit Clients ein Produkt aus der Datenbank löschen können.

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);
}