C# Web Api mit Entity Framework

Tutorial C#

von Ardian Shala, 19.03.2018 - update: 21.03.2018
Mit Visual Studio Community 2017 lässt sich schnell eine C# Web Api realisieren, die das Entity Framework zur Datenbank Kommunikation nutzt.
Die C# Web Api lässt sich einfach mit Postman testen, sodass zum Testen nicht zwingend ein Client erstellt werden muss.
Vorraussetzung:
  • Visual Studio Community 2017 - link
  • Postman App - link
  • Postman Chrome Extension - link

Neues C# Web Api Projekt erstellen

Das neue C# Web Api Projekt wird über Visual Studio Community 2017 erstellt.
Hierfür starten wir die IDE und legen es wie folgt an:
Datei / Neu / Projekt / Web / ASP.NET-Webanwendung
Hierbei wählen wir die Option empty aus und haken Web-API an
C# Web API - Projekt erstellen

Config anpassen

Die Datei webapiconfig.cs unter App_Start beinhaltet die wesentliche Konfiguration für die C# Web Api.
Damit die Controller Methoden später aufrufbar sind ergänzen wir den Abschnit config.Routes.MapHttpRoute um {action}, sodass ein Segment an den Controller weitergeleitet wird.

...routeTemplate: "api/{controller}/{action}/{id}",...

Controller erstellen

In dem Ordner Controllers erstellen wir nun über Rechtsklick / Hinzufügen / Web API-Controller Klasse eine Datei NotizController.
Anschließend benennen wir die vordefinierte Methode Get in GetNotizen um.

API mit Postman testen

Die C# Web API ist nun bereit aufgerufen zu werden. Dafür starten wir sie mittels Visual Studio Community 2017.
Um unsere API nun zu testen brauchen wir einen Client. Falls wir keinen haben, lässt sich diese optimal mit der Erweiterung Postman für Chrome testen.
Dafür öffnet man Postman und trägt in der Zeile die localhost Adresse der C# Web API ein, wählt die Option GET aus (falls nicht vorselektiert) und sendet die Abfrage über den Send Button ab.
z.B.:

http://localhost:58394/api/notiz/GetNotizen

Das Resultat sollte wie folgt aussehen:

[
    "value1",
    "value2"
]

Entity Framework installieren

Entity Framework kurz EF, ist ein Framework für eine objektrelationale Abbildung von Daten, welches das Persistieren von Datensätzen mit einer Datenbank vereinfacht.
Mittels NuGet-Paket Manager lässt sich Entity Framework leicht in ein Projekt integrieren:
Extras / NuGet Paket Manager / NuGet Paket Manager für Projektmappe verwalten
In dem sich öffnenden Fenster klickt man auf den Tab Durchsuchen und gibt in der Suche Entity Framework ein.
Nun klickt man in der Ergebnisliste EntityFramework (durch Microsoft) an, wählt im Detail Fenster das C# Web API Projekt aus und schließt den Vorgang mit Installieren ab.

Connectionstring einrichten

Damit Entity Framework mit der Datenbank kommunizieren kann, ergänzen wir in der webconfig in der connectionStrings Section folgenden Eintrag:

<connectionStrings>
    <add name="DefaultConnection" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\NOTIZAPIDB.mdf;Initial Catalog=NOTIZAPIDB;Integrated Security=True"
     providerName="System.Data.SqlClient" />
</connectionStrings>

Config anpassen

Nun passen wir erneut die Datei webapiconfig.cs an.
Wir möchten, dass Entity Framework unseren DBContext erstellt, falls dieser noch nicht vorhanden ist.

using (var context = new DBContext())
{
    if (!context.Database.Exists())
        context.Database.Initialize(true);
}

Model erstellen

Ein Model soll das Datenmodell darstellen.
Für unsere Notizen reicht ein einfaches Model mit folgender Struktur:

namespace API.Models
{
    public class Notiz
    {
        public int id { get; set; }
        public string title { get; set; }
    }
}

DBContext erstellen

Über den Entity Framework DBContext lassen sich Abfragen zu einer Datenbank realisieren.
Der DBContext muss von base abgeleitet werden, welche den Namen des ConnectionString als Parameter erwartet – hier DefaultConnection, den wir in der webconfig festgelegt haben.

using System.Data.Entity;
namespace API.Models
{
    public class DBContext : DbContext
    {
        public DBContext() : base("DefaultConnection") { }
        public DbSet<Notiz> Notizen { get; set; }
    }
}

GetNotizen abändern

Für Testzwecke und der Einfachheit dieses Tutorials wird direkt mit dem DBContext gearbeitet.
Sauberer ist es für die Übertragung eine Data Transfer Object (kurz DTO) Klasse zu nutzen, sodass nicht alle Daten aus der Datenbank übermittelt werden und die Übertragungsgröße gering gehalten wird.
Hierfür ändern wir im NotizController die Funktion GetNotizen wie folgt ab:

public IEnumerable<Notiz> GetNotizen()
{
    return this.dbContext.Notizen.ToArray();
}

Rufen wir nun per Postman die URL wie zuvor ab, sollte das Ergebnis ein leeres Array sein:

[]

Neue Notiz erstellen

Um eine neue Notiz erstellen zu können, müssen Informationen an die C# Web Api übermittelt werden. Dies geschieht hier in Form eines POST.
Nach Erstellen der neuen Notiz und dem Hinzufügen zum DbContext muss anschließend SaveChanges aufgerufen werden.
Dies führt dazu, dass Entity Framework geänderte Datensätze speichert.

[HttpPost]
public void AddNotiz(AddNotizParam addParam)
{
    var notiz = new Notiz();
    notiz.title = addParam.title;
    this.dbContext.Notizen.Add(notiz);
    this.dbContext.SaveChanges();
}

Um diesen Vorgang in Postman zu testen, stellen wir also von GET auf POST, wechseln auf den Tab Body, wählen die Option x-www-form-urlencoded aus und füllen die erste Zeile der Key Value Paar aus.
Der Key ist title und der Value kann hier z.B.: Mein Titel sein.
Der Vorgang wird über den Buttton Send abgeschlossen.

Vorhandene Notiz löschen

Der Vorgang ähnelt dem des Erstellen einer Notiz.
Statt eines Objects wollen wir hier aber nur ein Param übergeben, welches die ID des Datensatzes enthält.
(lässt sich auch über HttpDelete regeln)

[HttpPost]
public void DeleteNotiz(int id)
{
    var notiz = this.dbContext.Notizen.First(i => i.id == id);
    if (notiz != null)
    {
        this.dbContext.Notizen.Remove(notiz);
        this.dbContext.SaveChanges();
    }
}

Hierfür klicken wir in Postman hinter der URL Eingabe auf die Schaltfläche Params und geben in der erscheinenden Zeile den Key id und für den Value z.B.: 2 ein.
Dies wird dafür sorgen, dass wir in der DeleteNotiz Methode die Id mit dem Wert = 2 als Parameter erhalten

C# Web API - Postman Delete

Fazit

Mittels Visual Studio Community 2017 ist das Erstellen einer C# Web Api einfach und strukturiert.
Das anschließende Hinzufügen und Integrieren von Entity Framework geht schnell über den NuGet-Paket Manager.
Über Postman lassen sich die einzelnen Funktionen der C# Web Api komfortabel ansteuern.

#api #backend #c# #controller #datenbank #ef #entityframework #model #postman #webapi

Autor: Ardian Shala

Ersteller der Webseite MuchaDev. Full Stack Entwickler mit Angular, Ionic, PreactJs, C# und PHP