Die richtigen NCache in EF Core und SQL Server

Heute zeige ich Ihnen, wie Sie sich integrieren können NCache in Ihre vorhandenen Entity Framework Core-Anwendungen, um die Vorteile davon zu nutzen hohe Leistung und Skalierbarkeit. Es gibt viel zu besprechen, also werde ich gleich loslegen.

Beispiel einer EF Core-Anwendung

Das erste, was wir haben, ist Folgendes Beispiel einer Entity Framework Core-Anwendung Das, was ich habe, verwendet Northwind SQL-Datenbanken. Wenn wir also hierher kommen, können Sie sehen, dass ich diese Bestellungen zwischen diesen Bestell-IDs 10249 und 10268 abrufe, und wir können sehen, dass ich diese Kunden aus den USA und diese Produkte zwischen diesen Produkt-IDs 10 und 20 abrufe. Das ist alles, was dieses Beispiel tut. Lassen Sie uns einen Blick auf die Ergebnisse werfen, die dadurch aus der Datenbank für uns abgerufen werden. Perfekt. Wir können also sehen, dass wir diese Produkte zwischen 10 und 20, diese 11 Produkte, diese 13 Kunden aus den USA und diese 20 Bestellungen zwischen diesen Bestell-IDs abrufen.

Nachdem das Beispiel nun ausgeführt wurde, werfen wir einen Blick auf die Datenbank, mit der wir arbeiten. Wie Sie sehen, arbeiten wir mit Northwind-Datenbanken und das sind die Kunden, die wir bereits in der Tabelle unserer Kunden haben. So, das ist alles schön und gut, wir haben die Beispielarbeit gesehen.

Integrationsschritte

Lassen Sie uns nun darüber sprechen, wie wir uns integrieren können NCache in diese vorhandene Entity Framework Core-Anwendung. Wir werden dies in fünf sehr einfachen Schritten tun.

Installieren NCache EF Core Nuget-Paket
Speichern NCache EntityFrameworkCore-Namespace
Geben Sie Cache-Konfigurationen in DbContext an
Machen Sie Modelle serialisierbar
Verwenden Sie die NCache EF Core-Erweiterungsmethoden

Installieren NCache EF Core Nuget-Paket

Der erste Schritt besteht also darin, das zu installieren NCache Entity Framework Core NuGet-Paket in die Anwendung ein. Wenn ich also die NuGet-Pakete für diese Anwendung verwalte, können wir sehen, dass ich den EntityFrameworkCore bereits installiert habe.NCache NuGet-Paket, das entspricht NCache 5.3 SP2. Perfekt. Also werde ich das einfach schließen.

Speichern NCache EntityFrameworkCore-Namespace

Werfen wir einen Blick auf den nächsten Schritt. Der nächste Schritt besteht also darin, das hinzuzufügen NCache Entity Framework Core-Namespace in unsere Bewerbung ein. Wenn ich also hier hochkomme, muss ich nur „using“ hinzufügen Alachisoft.NCache.EntityFrameworkCore". Ich muss das Gleiche für meinen Kontext tun. Also speichere ich das hier, gehe zum Kontext und füge es auch dort ein und speichere es, perfekt.

Geben Sie Cache-Konfigurationen im Datenbankkontext an

Der nächste Schritt besteht nun darin, die Cache-Konfigurationen im Datenbankkontext anzugeben. Wenn ich jetzt nach unten scrolle, suche ich nach meiner Methode „OnConfiguring“. Da ist sie also, die OnConfiguring-Methode. Und was ich hier tun werde, ist, dass ich den Cache, mit dem ich arbeite, hinzufügen werde, sodass das hier der „efcorecache“ ist, und ich füge das „NCache„Configuration.Configure“ und ich sage, dass dieser Cache und der Abhängigkeitstyp SQL Server sind, da ich mit einem SQL Server arbeite, perfekt.

Cache-Abhängigkeit von SQL Server

Machen Sie Modelle serialisierbar

Und nachdem das erledigt ist, besteht der nächste Schritt darin, unsere Modelle serialisierbar zu machen. Also gehe ich einfach zu meinen Modellen, gehe zu meinem Kunden und füge einfach [Serialisierbar] hinzu, perfekt. Ich werde das kopieren, zur Bestellung gehen und es dort einfügen, es speichern und im Produkt einfügen und es einfach dort einfügen, perfekt. Nachdem das erledigt ist, schaue ich mir nun diesen Mitarbeiter an und zeige Ihnen, dass ich alle anderen Modelle bereits als serialisierbar markiert habe, sodass ich dies nicht für weitere Modelle tun muss.

Verwenden Sie die NCache EF Core-Erweiterungsmethoden

Da unsere Modelle nun als serialisierbar markiert sind, kommen wir zum fünften Schritt. Und der fünfte Schritt ist der interessanteste, bei dem wir das Tatsächliche verwenden werden NCache Entity Framework-Kernerweiterungsmethoden innerhalb unserer Anwendung. Dies hängt nun vom Anwendungsfall für die in unserer Anwendung vorhandenen Daten ab, und dies könnte einer von zwei Anwendungsfällen sein. Wir könnten entweder Transaktionsdaten oder Referenzdaten in unserer Anwendung haben.

Umgang mit Transaktionsdaten

Wenn wir also über Transaktionsdaten sprechen und über den Umgang mit Transaktionsdaten sprechen, handelt es sich bei Transaktionsdaten um die Daten, die voraussichtlich sehr häufig gelesen und geschrieben werden. Ein gutes Beispiel für diese Daten wäre das Führen einer Flugaufzeichnung. Es gibt also viele Flüge, die innerhalb eines Tages stattfinden, und alle haben etwas anderes an sich. Wenn Sie sie also in einer Datenbank protokollieren würden, würden Sie ständig neue Flüge eintragen, und das kann als transaktionaler Anwendungsfall betrachtet werden . Wenn wir also einen solchen transaktionalen Anwendungsfall in unseren Anwendungen haben, sagen wir, dass es für diese Art von Daten ideal ist, die Erweiterungsmethode „FromCache“ zu verwenden.

Was nun die FromCache-Erweiterungsmethode bewirkt, ist das erste Mal, dass die FromCache-Erweiterungsmethode funktioniert. Sie funktioniert und verhält sich ganz wie eine normale Entity Framework Core-Anwendung, bei der Ihre Entitäten aus der Datenbank zurückgeholt werden. Zu diesem Zeitpunkt füllt die FromCache-Methode diese Entitäten jedoch in den Cache. Dies hat den Vorteil, dass Sie beim nächsten Aufruf dieser Abfragen oder wenn Sie diese Entitäten in Ihrer Anwendung benötigen, nicht den gesamten Weg zurückgehen müssen Datenbank, um diese Entitäten abzurufen, und stattdessen holen Sie diese Entitäten schnell aus dem Cache zurück, profitieren von hoher Leistung und stellen alle Ihre Daten schnell für die Verwendung in Ihrer Anwendung bereit.

Lassen Sie uns nun mit der tatsächlichen Implementierung fortfahren und einen Blick darauf werfen, wie sie funktioniert. Um also auf unsere Anwendung zurückzukommen, werde ich hier mit Bestellungen arbeiten und einige Optionen für das Zwischenspeichern von Bestellungen hinzufügen. Los geht's, und ich sage, ich habe „neue CachingOptions()“ ' hier, und ich werde den 'StoreAsType' einfach als 'Collection' definieren. Daher möchte ich, dass alle Bestellungen als eine einzige Sammlung im Cache gespeichert werden. Ich möchte auch, dass diese ablaufen, also füge ich einen Ablauf hinzu, also gehe ich zu „SetSlidingExpiration“. Ich füge eine „TimeSpan()“ von 10 Minuten hinzu, damit diese Bestellungen nach 10 Minuten ablaufen, perfekt . Und nachdem das erledigt ist, scrolle ich einfach hierher und füge die Erweiterungsmethode „.FromCache“ und die „order_caching_options“ hinzu, perfekt. Das ist alles, was ich hier tun muss.

var order_caching_options = new CachingOptions()
{
	StoreAs = StoreAs.SeparateEntities
};
order_caching_options.SetSlidingExpiration(new TimeSpan(0, 10, 0));

//Orders 
var order_resultset = context.Orders
		     .Where(o => o.OrderId >= 10249 && o.OrderId <= 10268)
		     .FromCache(order_caching_options)
		     .ToList();

Console.WriteLine($"Orders between 10249 and 10268 fetched: {order_resultset.Count}
\n--------------------------------------------------------------------------\n\n"
+ String.Format("{0,-25}  {1,-40}  {2,-10}", $"Order ID", $"Date", $"Shipper Name") + "\n");

order_resultset.ForEach(order =>
{
    Console.WriteLine(String.Format("{0,-25}  {1,-40}  {2,-10}", $"{order.OrderId}", $"{order.OrderDate}", $"{order.ShipName}"));
});

Bevor ich es ausführe, werfen wir einen Blick auf unseren Cache. Hier habe ich nun das „EFCoreCache“-Setup auf meinen beiden Knoten, das wir hier sehen können. Wenn Sie zum Monitor gehen, können wir sehen, dass er vollständig angeschlossen und gesund ist, läuft und sich in einem guten Zustand befindet, ohne dass sich etwas darin befindet. Und wenn wir uns die Statistiken ansehen, erfahren wir dasselbe: Es ist ein gesunder Cache mit null einsatzbereiten Gegenständen, perfekt. Lassen Sie uns nun unsere Anwendung ausführen und einen Blick auf die Ergebnisse werfen, die wir erhalten – perfekt.

Jetzt, da die Anwendung ausgeführt wird, schließe ich einfach dieses Konsolenfenster hier, und wir können die Anfragen sehen, die wir bei dieser Hinzufügung in unserem Cache erhalten haben, und wenn wir nach unten scrollen, können wir diese Anzahl sehen, was bedeutet, dass Unsere Sammlung wurde in den Cache gefüllt.

Wenn ich jetzt „export-cachekeys“ ausführe, perfekt, können wir diese Sammlung sehen, die in den Cache eingegeben wurde. Angenommen, ich möchte jede Bestellung als separate Entität hinzufügen, also füge ich „SeparateEntities“ zu meinem „StoreAs“-Typ statt Sammlung hinzu. Ich werde diese Anwendung erneut ausführen . Und was dies nun bewirken wird, ist, dass diese Bestellungen anstelle dieser einzelnen Sammlung als separate Einheiten hinzugefügt werden. Jetzt, da die Anwendungen ausgeführt werden, kann ich sie schließen, und wir können alle Aktivitäten sehen, die stattgefunden haben, und, was noch wichtiger ist, diese Ergänzungen. Diese 16 und 4 Ergänzungen und diese Zahl, die gestiegen ist.

Wenn wir also zu „Statistik“ gehen, sehen wir 16 und 5. Jetzt exportiere ich einfach die Cache-Schlüssel noch einmal und wir können sehen, dass wir eine Cache-Anzahl von 21 haben und alle unsere Bestellungen separat ausgefüllt wurden Entitäten in den Cache sowie eine Sammlung. Das ist also perfekt und fasst sozusagen zusammen, wie die FromCache-Erweiterungsmethode verwendet wird.

Umgang mit Referenzdaten

Lassen Sie uns nun darüber sprechen, wie Sie mit Referenzdaten umgehen und was Referenzdaten sind. Referenzdaten sind die Art von Daten, die viel häufiger gelesen als jemals geschrieben werden. Das sind also Daten, die mehr oder weniger ziemlich statisch bleiben. Sie haben beispielsweise einen Produktkatalog. Nun ist nicht zu erwarten, dass sich Ihre Produkte extrem häufig ändern. Es kann sich also um Referenzdaten handeln, die regelmäßig aus der Datenbank gelesen werden und selten oder nie geändert werden. Und im Fall von Referenzdaten lautet die Empfehlung, dass Sie Ihren gesamten Arbeitssatz an Referenzdaten in den Cache übertragen und dann immer nur dann aus dem Cache lesen, wenn Sie diese Referenzdaten abrufen möchten. Lassen Sie mich Ihnen zeigen, wie Sie das machen werden.

Die erste Methode, die wir haben, oder die zweite Erweiterungsmethode, die wir haben, ist also die Erweiterungsmethode „LoadIntoCache()“. Jetzt ist die Erweiterungsmethode LoadIntoCache() äußerst leistungsfähig, um Ihren gesamten Arbeitsdatensatz in den Cache zu laden. Dies wird also die Abfrage für die Datenbank ausführen, das Abfrageergebnis abrufen, das gesamte Abfrageergebnis in den Cache füllen und dieses Ergebnis dann an die Anwendung zurückgeben.

Dies ist wiederum nützlich, um die Daten in den Cache zu übertragen, und Sie können dies in regelmäßigen Abständen ausführen, wenn Sie erwarten, dass sich die Daten ändern. Wenn Sie also damit rechnen, dass sich die Daten innerhalb einer Woche ändern, können Sie sie nach einer Woche erneut ausführen, um die Daten im Cache ständig zu aktualisieren und sicherzustellen, dass Sie keine Teilergebnisse erhalten, wenn Sie für diese Entitäten nur Abfragen aus dem Cache durchführen. Apropos Abfragen nur aus dem Cache: Sie würden dies tun, indem Sie die Erweiterungsmethode „FromCacheOnly()“ verwenden. Jetzt sucht die Erweiterungsmethode FromCacheOnly() immer nur im Cache nach Daten und geht nie zur Back-End-Datenbank, um diese Ergebnisse zu erhalten. Dies ist eine extrem schnelle Erweiterungsmethode und stellt sicher, dass Sie den vollen Leistungsvorteil des In-Memory-Caching nutzen, da Sie alle Entitäten aus einem Cluster-Cache erhalten und nie in Ihre Datenbank blicken.

Lassen Sie uns nun fortfahren und diese Erweiterungsmethoden in unsere Anwendung implementieren. Es gibt jedoch eine Voraussetzung, die wir erfüllen müssen, bevor wir sie verwenden können. Um diese Referenzdatenerweiterungsmethoden verwenden zu können, müssten wir also die Abfrageindizes in unserer Anwendung definieren. Dies kann auf zwei Arten erfolgen. Jetzt kann ich diese Abfrageindizes hier dynamisch erstellen, indem ich das Tag „[QueryIndexable]“ hinzufüge, das auch den Namespace einbringt.NCache.Runtime.Caching' in die Anwendung eingefügt, und jetzt habe ich dies dynamisch durchgeführt. Aber ich werde das auf andere Weise tun. Deshalb werde ich dies hier kommentieren, und wenn ich zu meinen Cluster-Caches komme, kann ich Ihnen zeigen, dass ich diese Abfrageindizes bereits in meinem Cache definiert habe, wie wir hier sehen können.

Da ich dies bereits getan habe, muss ich sie meiner Anwendung nicht dynamisch hinzufügen. Nachdem dies nun geklärt ist, scrolle ich hier nach unten und habe hier dieses Stück Code, und das Einzige, was ich tue, ist, die Produkte aus der Datenbank abzurufen. Sie werden mit der Erweiterungsmethode „LoadIntoCache()“ als separate Entitäten gespeichert, und das ist alles, was dies tun wird. Jetzt werde ich damit fortfahren und einen Blick auf die Ergebnisse werfen, die dadurch erzielt werden, perfekt.

//Load ALL Products Into Cache
var products_caching_option = new CachingOptions
{
    StoreAs = StoreAs.SeparateEntities
};
var all_products = (from products in context.Products
                    select products)
                    .LoadIntoCache(products_caching_option)
                    .ToList();
Console.WriteLine($"\n\nAll Products Loaded into cache : {all_products.Count}\n\n");
all_products.ForEach(product =>
{
    Console.WriteLine(String.Format("{0,-25}  {1,-40}  {2,-10}", $"{product.ProductId}", $"{product.ProductName}", $"{product.UnitPrice}"));
});

Wir können also sehen, dass wir diese 77 Produkte in den Cache geladen haben, und wir können sehen, wie die Zahl bis zum Äußersten gestiegen ist, welche Ergänzungen stattgefunden haben und welche Anfragen eingegangen sind. Wenn wir uns die Statistiken ansehen wir können 42 und 57 sehen.

Jetzt exportiere ich einfach noch einmal die Cache-Schlüssel, perfekt. Wir können also diese 99 Artikel in unserem Cache sehen und unser gesamter Arbeitssatz an Produkten wurde in den Cache gebracht. Jetzt, da wir unseren gesamten Arbeitssatz im Cache haben, kann ich sicher zu der Stelle zurückkehren, an der ich die Produkte abgefragt habe, also werde ich dies einfach kommentieren, und wir gehen nach oben und wir Ich werde die Erweiterungsmethode „FromCacheOnly()“ dort hinzufügen, wo ich meine Produkte abgerufen habe, perfekt. Und nachdem das erledigt ist, kann ich die Anwendung einfach noch einmal ausführen. Und werfen wir einen Blick auf die Ergebnisse, die meine Anwendung mit dieser Erweiterungsmethode „FromCacheOnly()“ abruft. Na, bitte.

Wir können also sehen, dass wir die gleiche Anzahl an Produkten erhalten haben, nämlich diese 11 Produkte. Wir wissen also, dass wir hier ein vollständiges Ergebnis haben und können sehen, dass dieser Abruf aus unserem Cache und dieser Aktivität erfolgt ist, was bedeutet, dass dieser FromCacheOnly( )-Erweiterungsmethode hat funktioniert und ruft die Ergebnisse für uns aus dem Cache ab.

EF Core-spezifisch NCache APIs

Das ist also alles für die Erweiterungsmethoden FromCacheOnly() und LoadIntoCache(). Jetzt können wir darüber reden EF Core-spezifisch NCache APIs. So, NCache gibt Ihnen die Möglichkeit, dass Sie nicht unbedingt eine Erweiterungsmethode verwenden müssen, um Daten in den Cache einzufügen oder daraus zu entfernen. Sie können das Cache-Handle auch mithilfe der EF Core-Bibliothek aus dem Kontext abrufen und dann mithilfe dieses Cache-Handles unabhängige Entitäten einfügen und unabhängige Entitäten aus dem Cache entfernen. Eine Sache, die ich hier hinzufügen möchte, ist, dass dies nicht dasselbe ist wie das NCache Innerhalb der verfügbare APIs NCache SDK, und dies ist die API, die für Entity Framework Core dediziert oder spezifisch ist.

Schauen wir uns also diese APIs an und schauen wir uns an, wie sie funktionieren. So würden wir sie also verwenden. Wir würden also den Cache aus dem Kontext abrufen und dann Daten in den Cache einfügen, indem wir einfach „cache.Insert“ für den Kunden ausführen und einen Out-String-Cache-Schlüssel bereitstellen. Dieser Cache-Schlüssel würde von den Entity Framework Core-APIs generiert. Und wenn Sie dann mit demselben Cache-Handle Daten oder ein Element aus dem Cache entfernen möchten, können Sie diese Daten beispielsweise mithilfe von context.find im Cache suchen und dann einfach einen Cache.Remove ausführen.

Lassen Sie uns nun fortfahren und dies in unserer Anwendung tun. Wenn ich also hier auf meine Bewerbung zurückkomme und hier nach unten scrolle, habe ich hier diesen Code, der den Kunden zum Cache hinzufügt. Ich werde diesen Code nur auskommentieren, und wenn Sie nach oben scrollen, können wir sehen, dass ich einfach den Cache aus dem Kontext erhalte, in dem dieser Kunde erstellt wird, und ich möchte ihn als separate Entität speichern, ich möchte die Änderungen speichern und führen Sie diesen Cache aus. Fügen Sie ihn ein und schreiben Sie dann aus, dass ich diesen Kunden zum Cache hinzugefügt habe. Lassen Sie uns also loslegen, es ausführen und einen Blick darauf werfen, was es bewirkt.

//Add Customer Using Cache Handle
Cache cache = context.GetCache();
var cust = new Customer
{
    CustomerId = "HANIH",
    ContactName = "Hanih Moos",
    ContactTitle = "Sales Representative",
    CompanyName = "Blauer See Delikatessen",
};

var options = new CachingOptions
{
    StoreAs = StoreAs.SeparateEntities
};

context.Customers.Add(cust);
context.SaveChanges(true);

cache.Insert(cust, out string cacheKey, options);
Console.WriteLine($"Customer ID: {cust.CustomerId} -> Added to Cache");

Wir können also sehen, dass wir diesen Kunden zum Cache hinzugefügt haben. Wenn ich also diese Anwendung schließe, können wir diese Addition sehen, die diese Anfragen ausgeführt hat, und wir können einen kleinen Einbruch sehen, sodass wir von 42 auf 43 gestiegen sind. Wenn wir zu den Statistiken gehen, sehen wir 43 und 57 Das ergibt 100. Wenn ich also die Cache-Schlüssel exportiere, können wir diesen unabhängigen Kunden sehen, los geht's. So können wir die unabhängige separate Entität sehen, die wir dem Cache hinzugefügt haben. Das ist perfekt.

Lassen Sie uns nun fortfahren und diesen Kunden entfernen. Deshalb werde ich diesen Codeabschnitt nur kommentieren. Auch hier scrolle ich nach unten und entkommentiere diesen Codeabschnitt. Dieser Codeabschnitt sucht lediglich nach dem Kunden im Cache mit demselben Kundennamen, und wenn er diesen Kunden findet, ist er es Ich werde es aus dem Kontext entfernen, die Änderungen speichern und es dann aus dem Cache entfernen. Und dann wird es ausdrucken, dass es das getan hat. Andernfalls wird angezeigt, dass der Kunde nicht gefunden werden konnte.

//Remove Customer Using Cache Handle
Cache cache = context.GetCache();
Customer customerToRemove = context.Customers.Find("HANIH");
if (customerToRemove != null)
{
    context.Customers.Remove(customerToRemove);
    context.SaveChanges(true);
    cache.Remove(customerToRemove);
    Console.WriteLine($"Customer ID: {customerToRemove.CustomerId} -> Removed from Cache");
}
else
{
    Console.WriteLine("could not find the customer within the cache");
}
Console.ReadLine();

Lassen Sie uns also loslegen und diese Anwendung ausführen und einen Blick auf die Ergebnisse werfen, perfekt. Wir können also sehen, dass der Kunde aus dem Cache entfernt wurde, und wir können in den Statistiken sehen, dass wir von 43 auf 42 gestiegen sind und der Monitor dasselbe anzeigen würde, perfekt.

Wenn wir jetzt zu den Statistiken zurückkehren, eröffne ich einfach die NCache PowerShell, und ich werde die Cache-Schlüssel exportieren, perfekt. Und wir können sehen, dass wir diesen Kunden nicht mehr in unserem Cache haben. Und so können Sie mit dem Kunden oder beliebige Daten hinzufügen und entfernen NCache EF Core-spezifische APIs.

Nächste Schritte

Herunterladen NCache

Und damit sind wir am Ende dieser Demonstration angelangt. Vielen Dank. Wenn Sie wollen herunterladen NCache Auf unserer Download-Seite erhalten Sie eine kostenlose 30-Tage-Testversion und ein voll funktionsfähiges Produkt. Lass mich dich jetzt dorthin bringen. Wenn wir also hierher kommen, können Sie hier sehen, dass dies die Angebote für .NET sind, die Sie für Windows und für Linux herunterladen können NCache bietet.

Versuchen Sie Playground

Du kannst es auch versuchen NCache draußen in der NCache Spielplatz. Und Sie können tatsächlich ein Gefühl für das Produkt bekommen, um zu sehen, wie die Funktionen funktionieren. Also, wenn Sie hierher gehen, um Versuchen Sie Playground Sie können sehen, dass Sie diese Sandbox-Sitzung 30 Minuten lang starten können, um einige Beispiele auszuführen und zu sehen, wie .NET- und Java-Beispiele ausgeführt werden und sich anfühlen.

Vereinbaren Sie einen personalisierten Termin NCache Demo

Und schließlich können Sie ein personalisiertes Buch buchen NCache Demo, bei der wir Ihnen eine einstündige technische Sitzung zur Diskussion stellen würden NCache Architektur und Funktionen und ordnen sie entsprechend dem Anwendungsfall zu, den wir in Ihren Umgebungen finden. Und das ist äußerst einfach. Sie müssen lediglich hier auf unsere Website gehen und diese personalisierte Live-Demo vereinbaren Diese Seite hier. Sobald Sie hier sind, können Sie die Anfrage absenden, wir erhalten sie und planen etwas. Und damit sind wir am Ende dieser Demo angelangt. Vielen Dank fürs Zuschauen, ich wünsche Ihnen einen wundervollen Tag. Auf Wiedersehen.