CRUD Operationen

CRUD Operationen mit EF core

In diesem Post klären wir folgende Themen:

Wir schauen uns als erstes an, was es mit CRUD auf sich hat.

CRUD - Backbone aller Datenverwaltung

CRUD steht für Create, Read, Update und Delete. Dies bezeichnet die Basis Operationen, die wir an allen Daten ausüben können.

Also Erstellen neuer Daten, Lesen bestehender Daten, das Verändern von Daten und das Entfernen oder Löschen von Daten.

CRUD mit List<T>

Die folgende Variable wird vorausgesetzt

var list = new List<string>();

CREATE – list.Add(“new value”);
READ – list[0] oder enumiereren list.GetEnumerator();
UPDATE – list[0] = “updated value”;
DELETE – list.Remove(“updated value”); RemoveAt oder Clear sind auch möglich

CRUD mit SQL

setze folgende Tabelle voraus:

CREATE TABLE Entity (Id Integer, Name varchar(20));

CREATE – INSERT INTO Entity (Id, Name) VALUES (1, “entity-1);
READ – SELECT Id, Name FROM Entity;
UPDATE – UPDATE Entity SET Name = “updated”; — Vorsicht ohne WHERE
DElETE – DELETE FROM Entity; — Vorsicht ohne WHERE

CRUD mit Klassen

Wir nutzen wieder die Entity wie bei SQL:

public class Entity { public int Id {get; set;} public string Name {get;set;} }

CREATE – var entity = new Entity { Id = 1, Name = “entity-1”};
READ – Jeder Zugriff auf die Referenz
UPDATE – entity.Id = 2;
DELETE – Alle Referenzen verschwunden und GC hat die Referenz beseitigt.

CRUD mit EF Core

auch hier wird die Entity genutzt

public class Entity
{
     public int Id {get;set;}
     public string Name {get;set;}
}

CREATE – Add(new Entity { Name =”next”} + SaveChanges()
READ – ToList, ToArray, First, Single usw.
UPDATE – Update(entity) + SaveChanges()
DELETE – Delete(entity) + SaveChanges()

Da das ganze natürlich selbsterklärend ist, bis auf für den entscheidenden Teil zu EF core, gehen wir nur auf die CRUD Operationen für EF core ein.

Grundsätzliche Idee für EF Core CRUD

Alle Beispile werden wieder anhand der Beispielapplikation dargestellt. Und der Code ist auf Github verfügbar.

Wir teilen CRUD mit EF core in zwei Teile ein:

Lesezugriff (READ)
Schreibzugriff (CREATE- UPDATE- DELETE)

Grundsätzlich werden aber alle Operationen auf dem DbContext ausgeführt.

Lesezugriff - READ

Lesen mit EF Core grundsätzlich sehr einfach, kann abhängig von der Applikationsdomäne natürlich sehr komplex werden. Das grundsätzliche Prinzip ist wie folgt. Wir fragen alle Produkte ab die in der Datenbank existieren:

using (var session = new LeantrainingDbContext())
{
     var products = await session.Set<Product>().ToListAsync();
     return products;
}

Soweit so einfach. Dies können wir natürlich immer durch folgende Query Operatoren erweitern:

Filtern: Where(x => …)
Sortieren: OrderBy und OrderByDescending
Projizieren: Select + anonyme Objekte
Gruppieren: Group By
Navigation: Include und ThenInclude
Ohne ChangeTracking: AsNoTracking

Ausgeführt (an die Datenbank gesandt) wird die Query immer erst dann, wenn einer der folgenden Befehle aufgerufen wird:

ToList, ToArray, ToDictionary
First, Single, Last
FirstOrDefault, SingleOrDefault, LastOrDefault
Count, Any, All, Max, Min, Sum etc.

Querying könnte ein ganzes Kapitel umfassen, deshalb schauen wir uns nun CUD Operationen an.

Schreibzugriff - CUD mit EF Core

Erstellen, Updaten und Löschen funktioniert bei EF core nach einem einheitlichen Prinzip.

DbContext erstellen (Datenbanksession)
Entity zur Änderung bestimmen
(Änderung durchführen)
Add, Update oder Remove Methode auf dem Context aufrufen
SaveChanges Methode auf dem Context aufrufen

Hier sind für alle 3 Operationen der 1. und 5. Schritt immer gleich. Der 4. wird auch jeweils durchgeführt, nur 2. und 3. sind abhängig von der Operation.

Beispiele in der Applikation

In der Applikation auf Github nutzen wir UseCases die in der Program.cs über folgendes Command aufrufbar sind (letzte ist der Key, nur einen verwenden)

dotnet run create | read | update | delete

Die usecases sehen wie folgt aus:

hier geht es zur Übersicht:

https://t-heiten.net/entity-framework-core/

Published by theiten on 01/10/202001/10/2020