Die richtigen NCache in EF Core mit Oracle

Hallo zusammen, ich bin Sean und heute zeige ich Ihnen, wie Sie sich integrieren können NCache in dein bestehendes Entity Framework-Kernanwendungen die mit einer Oracle-Datenbank konfiguriert sind. Wir werden dies als praktische Demonstration durchführen, bei der wir mit einer Beispielanwendung arbeiten, die ich bereits für diese Demo konfiguriert habe, und die wir integrieren werden NCache hinein. Das sind also ziemlich aufregende Dinge, die wir zusammengestellt haben. Lassen Sie mich Ihnen zeigen, wie wir es machen werden.

Beispiel einer EF Core-Anwendung

Das erste, was ich hier habe, ist also die Beispielanwendung selbst. Wie Sie hier sehen können, habe ich die Beispielanwendung und hole hier einige Bestellungen, Kunden und Produkte ab. Und ich habe dies so konfiguriert, dass es mit einer Oracle-Datenbank funktioniert, die ich Ihnen hier zeigen kann. Wenn wir zum Kontext gehen, können Sie sehen, dass ich diese UseOracle-Methode hier habe, um mit meiner Oracle-Datenbank zu arbeiten.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
   optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}

Bevor wir dieses Programm tatsächlich ausführen, möchte ich Sie zur Datenbank führen und Ihnen zeigen, womit wir arbeiten. Ich arbeite also mit der Northwind-Datenbank in Oracle. Und da wir viele Tische haben, habe ich die, mit denen ich arbeite, hier geöffnet, damit wir sie sehen können. Das erste ist ORDERS, und wir können hier diese Eigenschaften für die Bestellungen sehen, mit denen wir arbeiten werden. Dann werfen wir einen Blick auf unsere PRODUKTE. Das sind also die Produkteigenschaften, die wir in unserer Anwendung erhalten oder abrufen werden. Und dann ist die dritte Tabelle KUNDEN, und wir können hier die Eigenschaften unserer Kunden sehen. Und das sind so ziemlich alle Tabellen, mit denen wir arbeiten werden.

Lassen Sie uns nun diese Tabellen tatsächlich abfragen und einen Blick auf den Inhalt werfen. Sie sehen also, dass ich 77 Produkte in meiner Northwind-Datenbank habe, und das sind alle Produkte hier. Also, das ist alles schön und gut. Werfen wir nun einen Blick auf die KUNDEN, Kunden, und geben Sie ein, und wenn ich ganz nach unten scrolle – perfekt! Wir können also sehen, dass ich 89 Kunden in meiner Northwind-Datenbank habe, und alle diese Kunden sind genau hier, wie Sie vor Ihnen sehen können.

Werfen wir nun einen Blick auf unsere Bestellungen. Jetzt wird es viele Bestellungen geben, scrollen wir nach unten – perfekt! Wir können also sehen, dass wir 830 Bestellungen in unserer Datenbank haben. Das sind viele Bestellungen, und wir können alle diese Bestellungen hier sehen. Wir werden also einige Kriterien in der Bewerbung durchgehen und das jetzt durchgehen.

Nachdem die Anwendung nun ausgeführt wurde, können wir es perfekt sehen. Lassen Sie mich nun hier nach oben scrollen, damit wir diese Produkte zwischen ID 25 und 50 abrufen können. Wir haben also 26 Produkte; Kunden aus Großbritannien, wir haben also sieben Kunden; und Bestellungen zwischen 10280 und 10300, also haben wir diese 21 Bestellungen – perfekt!

Bestellungen werden von der DB abgerufen

NCache Einrichtung für EF Core

Da wir nun wissen, dass das Beispiel funktioniert, können wir mit der Konfiguration fortfahren NCache in unserer Entity Framework Core-Anwendung. Konfigurieren Sie also unsere Anwendung für die Zusammenarbeit NCache ist so einfach wie fünf Schritte, die wir in dieser Demonstration ausführen werden.

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

Beginnen wir also mit dem ersten Schritt hier, nämlich der Installation von NCache Entity Framework Core NuGet-Paket in unsere Anwendung. Wenn ich also in meiner Anwendung zu den NuGet-Paketen gehe, suchen wir nach dem EntityFrameworkCore.NCache NuGet-Paket, das sich hier befindet. Ich habe dies in meiner Anwendung installiert, also können wir es hier sehen. Und ich verwende Version 5.3.2.1, was entspricht NCache Version 5.3 SP2. Also, das ist perfekt. Lassen Sie uns nun fortfahren, diese Registerkarte schließen und mit dem nächsten Schritt fortfahren.

Speichern NCache EntityFrameworkCore-Namespace

Der nächste Schritt besteht also darin, das hinzuzufügen NCache Entity Framework Core-Namespace in die Anwendung. Öffnen wir also den Code erneut und gehen hier auf unser Programm ein. Und ich möchte nur hinzufügen:

using Alachisoft.NCache.EntityFrameworkCore

Perfekt! Also speichere ich das einfach, gehe zum Modellkontext und füge es hier ein – perfekt! Nachdem dies nun erledigt ist, können wir mit dem nächsten Schritt fortfahren, nämlich der Angabe der Cache-Konfigurationen im Datenbankkontext.

Geben Sie Cache-Konfigurationen im Datenbankkontext an

Also scrolle ich nach unten zu meiner Konfigurationsmethode, füge den Namen des Caches hinzu, mit dem wir arbeiten werden, und übergebe den NCache Aufbau. Das wird also mein „Efcoreoraclecache“ – perfekt! Und ich muss das hinzufügen NCacheKonfiguration.Konfigurieren den Namen des Caches zusammen mit dem DependencyType, der Oracle sein wird – perfekt! Und das ist so ziemlich alles, was ich hier tun muss.

...
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
   string cache = "efcoreoraclecache";

   NCacheConfiguration.Configure(cache, DependencyType.Oracle);

   optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}
...

Werfen wir nun einen Blick auf den Cache, mit dem wir arbeiten werden. Sie können also sehen, dass ich meinen EFCoreOracleCache hier auf diesen beiden Demomaschinen konfiguriert habe. Und werfen wir einen Blick auf die Details dieses Caches. Wenn wir also diesen Cache überwachen möchten, können wir von hier aus auf diese Überwachungsschaltfläche klicken. Das bringt uns zu dem Monitor hier, der uns den Zustand unseres Caches anzeigt, und wir können sehen, dass er gut und sauber ist und wir über einen gesunden Cache verfügen, mit dem wir arbeiten können.

Wenn wir zu unseren Details zurückkehren und auf Statistiken klicken, gelangen wir zu dieser Seite hier, die uns die Statistiken unseres Caches anzeigt. Wenn wir nun zu unserem Monitor zurückkehren, kehren wir zu unserer Anwendung zurück und öffnen den nächsten Schritt.

Machen Sie Modelle serialisierbar

Der nächste Schritt besteht also darin, unsere Modelle serialisierbar zu machen. Perfekt. Jetzt komme ich zu meinem Kundenmodell. Das wird also dort drüben sein. Perfekt. Und ich werde nur hinzufügen [Serialisierbar] hier drüben. Perfekt. Nachdem das erledigt ist, kann ich nun mit meiner Bestellung fortfahren. Und Sie können sehen, dass das bereits als markiert ist [Serialisierbar]. Und mein Produkt, das wiederum bereits als gekennzeichnet ist [Serialisierbar]. Alle meine Modelle sind also serialisierbar, und es kann losgehen. Jetzt können wir zum nächsten Schritt übergehen.

Verwenden Sie die NCache EF Core-Erweiterungsmethoden

Der nächste Schritt ist die Verwendung der NCache Entity Framework Core-Erweiterungsmethoden innerhalb unserer Anwendung. Und ich mache hier nur eine Pause, weil die von uns gewählten Erweiterungsmethoden von der Art der Daten abhängen, die wir tatsächlich zwischenspeichern.

Es gibt also zwei Arten von Daten, die wir zwischenspeichern können: Der erste Typ ist transaktional und der zweite Typ ist referenziert. Worum es sich bei diesen Typen handelt und wie man mit ihnen umgeht, darauf gehen wir gleich näher ein. Sprechen wir also über das erste. Perfekt.

Umgang mit Transaktionsdaten

Der erste Datentyp, den Sie verarbeiten können, sind also Transaktionsdaten. Transaktionsdaten sind nun Daten, die sowohl einen leseintensiven als auch einen schreibintensiven Anwendungsfall haben. Ein gutes Beispiel hierfür wären Flugdaten, bei denen jeden Tag so viele Flüge stattfinden und diese Daten jeden Tag in die Datenbank geschrieben und auch jeden Tag aus der Datenbank abgerufen werden. Das ist also ein sehr lese- und schreibintensiver Anwendungsfall, der diese Daten als transaktional qualifiziert. In unserem Fall lässt sich ein ähnlicher Anwendungsfall auf unsere Aufträge abbilden. Daher können wir unsere Bestellungen als unsere Transaktionsdaten betrachten. Wenn wir also über den Umgang mit Transaktionsdaten in Entity Framework Core sprechen, mit NCachewerden wir die verwenden FromCache() Erweiterungsmethode.

Wenn Sie diese Erweiterungsmethode nun vor Ihren vorhandenen Abfragen verknüpfen, wird sie bei der ersten Ausführung wie eine Standardabfrage ausgeführt. Ihre Anwendung geht zur Datenbank und ruft die Entitäten von dort ab. Dieses Mal wird Ihre Anwendung sie jedoch in Ihrem Cluster-Cache zwischenspeichern. Wenn Ihre Anwendung also das nächste Mal versucht, diese Entitäten abzurufen, wird sie nicht den ganzen Weg bis zur Back-End-Datenbank zurücklegen, sondern sie wird ausgeführt um diese Entitäten aus dem Cluster-Cache zurück in Ihre Anwendung zu bringen. Schauen wir uns also an, wie diese Methode funktioniert.

Wenn ich also zu meiner Bewerbung komme, hole ich hier meine Bestellungen ab. Deshalb werde ich nur einige Optionen zum Zwischenspeichern von Bestellungen hinzufügen. Deshalb werde ich hier order_caching_options hinzufügen, und diese werden „neue CachingOptions“ sein. Deshalb werde ich hier meinen Geschäftstyp angeben, um anzugeben, dass ich eine einzige Sammlung aller meiner Bestellungen abrufen möchte. Also StoreAs.Collection und fülle das dann in meinen Cache. Außerdem werde ich diesen Daten einen absoluten Ablauf von 10 Minuten hinzufügen, denn wenn Sie mit Transaktionsdaten arbeiten, ändern sich diese Daten häufig, sodass Sie sie so regelmäßig wie möglich aktualisieren möchten. Deshalb werde ich diesen Ablauf einfach auf 10 Minuten festlegen, sodass dieser Datensatz nach 10 Minuten im Cache aktualisiert wird. Jetzt werde ich das hinzufügen .FromCache() Erweiterungsmethode und füge meine order_caching_options hinzu, und das ist perfekt. Das ist absolut perfekt und das ist alles, was wir tun müssen.

using OracleEFCore.Models;
using Alachisoft.NCache.EntityFrameworkCore;

namespace OracleEFCore
{
    internal class Program
    {
        static void Main(string[] args)
        {
            using (var context = new Models.ModelContext())
            {
                //-----Orders----- 
                var order_caching_options = new CachingOptions()
                {
                    StoreAs = StoreAs.Collection
                };
                order_caching_options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));

                int upper_orderid = 10300;
                int lower_orderid = 10280;

                var order_resultset = context.Orders
					  .Where(o => o.Orderid >= lower_orderid && o.Orderid <= upper_orderid)
					  .FromCache(order_caching_options)
					  .ToList();
					  ...

Lassen Sie uns nun das Beispiel ausführen und einen Blick darauf werfen, was wir erhalten. Perfekt. Das Beispiel wird also ausgeführt, es gibt hier keine Änderungen, also kann ich das hier einfach schließen, und jetzt können wir uns die Anfragen ansehen, die wir in unserem Cache erhalten haben. Und wir können sehen, dass auch diese Zahl gestiegen ist. Exportieren wir nun die Cache-Schlüssel für diesen Cache und werfen wir einen Blick auf die Sammlung, die wir gerade unserem Cluster-Cache hinzugefügt haben. Perfekt. So können Sie diese Sammlung sehen, die dem Cache hinzugefügt wurde. Das ist großartig.

Aber sagen wir mal, ich wollte nicht eine einzelne Sammlung in den Cache legen, sondern jede Bestellung als separate Einheit. Nun, in diesem Fall kann ich den Store einfach als Typ angeben, der aus separaten Einheiten besteht.

//-----Orders----- 
var order_caching_options = new CachingOptions()
{
   StoreAs = StoreAs.SeparateEntities
};

Wenn ich diese Anwendung jetzt erneut ausführe, werden alle meine Bestellungen als separate Einheiten im Cache abgelegt. Nachdem die Anwendung ausgeführt wurde, schließen wir sie. Wir können sehen, dass die Zahl ganz nach oben gegangen ist, und wir können die durchgeführten Ergänzungen und diese Anfragen sehen. Wenn ich zu den Statistiken gehe, können wir diese Zahl von 7 und diese Zahl von 15 sehen. Perfekt.

Exportieren wir nun die Cache-Schlüssel und werfen wir einen Blick auf die Schlüssel, die wir in unserem Cache haben. Perfekt. Wir haben also diese 22 Schlüssel oder Artikel in unserem Cache und alle unsere Bestellungen werden separat zwischengespeichert. Das fasst ziemlich genau zusammen, wie die Erweiterungsmethode „FromCache()“ verwendet wird.

Umgang mit Referenzdaten

Lassen Sie uns nun darüber sprechen, wie Sie mit Referenzdaten umgehen können. Referenzdaten sind also Daten, die einen sehr leseintensiven Anwendungsfall haben, aber nicht so häufig aktualisiert werden wie Transaktionsdaten. Ein gutes Beispiel hierfür wäre ein Produktkatalog. Wenn Sie also Produkte auf Lager haben oder einen Produktkatalog haben, aktualisieren Sie diesen Katalog nicht sehr häufig. Ihre Produkte würden sich vielleicht ein- oder zweimal im Monat ändern. Es ist also wahrscheinlicher, dass Sie diese Daten nur aus der Datenbank lesen und diese Daten in der Datenbank nicht wirklich sehr häufig aktualisieren. Daher ist es sinnvoll, diese Daten aus der Datenbank in einen Cluster-Cache zu übertragen und sie dann aus einem Hochgeschwindigkeits-Cluster-Cache oder Datenspeicher im Arbeitsspeicher zu lesen, anstatt sie in die Datenbank zu übertragen. Dadurch erhält Ihre Anwendung eine hohe Leistung und Skalierbarkeit Verteiltes In-Memory-Caching.

Wenn Sie also mit Referenzdaten arbeiten, ist die erste Methode, die Sie verwenden würden LoadIntoCache() Methode. Jetzt übernimmt die Methode „In den Cache laden“ einfach die Ergebnisse der Abfrage, die Sie in Entity Framework Core ausgeführt haben, und speichert diese Ergebnisse im Cluster-Cache. Jetzt kann die Methode zum Laden in den Cache so eingestellt werden, dass sie in einem Intervall ausgeführt wird, in dem erwartet wird, dass Daten aktualisiert werden.

Nehmen wir zum Beispiel den Produktkatalog, den wir jede Woche aktualisieren. Wir können diese Methode so einstellen, dass sie jede Woche ausgeführt wird, sodass die Daten im Cache ständig aktualisiert werden und immer neue Daten im Cache vorhanden sind.

Nachdem Sie nun Ihren gesamten Datensatz im Cache haben, werfen wir einen Blick auf die dritte Erweiterungsmethode, nämlich die FromCacheOnly() Erweiterungsmethode. Jetzt die FromCacheOnly() Die Erweiterungsmethode ist eine wirklich coole Erweiterungsmethode, die dafür sorgt, dass Sie von Ihrer Anwendung immer nur zum Cluster-Cache wechseln, um Ihre Daten abzurufen, und nicht zur Back-End-Datenbank. Sie werden niemals auf die gesicherte Datenbank zugreifen, wenn Sie die verwenden FromCacheOnly() Erweiterungsmethode.

Wenn Sie diese Methode also zusammen mit dem verwenden LoadIntoCache() Mit dieser Methode verfügen Sie über einen wirklich leistungsstarken Satz an Tools, die sicherstellen, dass Ihr Cluster-Cache auf dem neuesten Stand und mit Ihrer Datenbank synchronisiert bleibt und dass Sie Ihre Daten nur aus Ihrem Cluster-Cache abrufen.

Schauen wir uns nun an, wie wir diese Methoden verwenden würden. Wenn Sie also mit diesen Methoden arbeiten, müssen wir hier zunächst unsere Abfrageindizes für diese Modelle erstellen. Wenn wir auf den Kunden eingehen, besteht eine Möglichkeit darin, das hinzuzufügen [QueryIndexable] Markieren Sie hier oben über dem Feld „Kunde“. Wir können hier also dieses „QueryIndexable[]“-Tag sehen, und das bringt diese Bibliothek mit sich. In meinem Fall muss ich dies jedoch nicht tun, daher werde ich dies einfach auskommentieren. Der Grund dafür ist, dass ich, wenn ich zu meinem Cluster-Cache und zu den Details gehe, hier nach unten zur Registerkarte „Abfrageindizes“ scrolle und Sie sehen können, dass ich alle meine Abfrageindizes bereits zum Cache hinzugefügt habe. Da ich diese hinzugefügt habe, muss ich sie also nicht dynamisch definieren.

Nachdem unsere Abfrageindizes nun einsatzbereit sind, habe ich hier diesen Code, der alle meine Produkte aus der Datenbank in den Cache lädt. Also werde ich einfach weitermachen und diesen Codeabschnitt auskommentieren. Perfekt!

// ------------------------Load ALL Products Into Cache------------------------
...
	var products_caching_option = new CachingOptions
	{
	   StoreAs = StoreAs.SeparateEntities
	};

	products_caching_option.SetAbsoluteExpiration(DateTime.Now.AddDays(10));

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

Und alles, was dieser Code tut, ist, dass er festlegt, dass ich meine Produkte in separate Einheiten einteilen und sie mit einem Ablauf von 10 Tagen hinzufügen möchte. Dann das LoadIntoCache() Methode lädt die Produkte in den Cache. Lassen Sie uns dies nun ausführen und einen Blick auf die Ergebnisse werfen, die es erhält. Perfekt! Also, wenn wir jetzt hier nach oben scrollen, los geht's! Wir können sehen, dass wir alle Produkte in den Cache geladen haben, diese 77 Produkte.

Und dann können wir sehen, welche Anfragen in den Cache eingegangen sind, welche Ergänzungen durchgeführt wurden und wie viel gestiegen ist. Wenn wir unsere Statistiken öffnen, können wir sehen, dass wir 59 Elemente auf einer Partition und 41 auf der anderen haben.

Lassen Sie uns nun die Cache-Schlüssel exportieren und uns die Daten ansehen, die wir haben. Perfekt! Wir haben also 100 Schlüssel in unserem Cache und alle Produkte wurden in den Cache gebracht. Perfekt! Da nun unser gesamter Datensatz vorliegt, muss ich diese Methode nicht erneut ausführen. Ich werde einfach weitermachen und dies kommentieren.

Und jetzt werden wir das ausführen FromCacheOnly() Erweiterungsmethode für unsere Produktabfrage, die wir zuvor ausgeführt haben. Also füge ich einfach ' hinzu. FromCacheOnly(). Perfekt! Lassen Sie uns nun die Stichprobe ausführen und einen Blick auf die Ergebnisse dieser Abrufe werfen. Perfekt! Da haben wir also 26 Ergebnisse, die gleichen, die wir erhalten haben, als wir diese Anwendung ohne Caching ausgeführt haben, was ein vollständiges Ergebnis bedeutet, und wir können die durchgeführten Abrufe und die Anfragen sehen, die wir im Cache erhalten haben.

EF Core-spezifisch NCache APIs

Und das fasst ziemlich genau zusammen, wie Sie das nutzen können FromCacheOnly() an. Nach der Installation können Sie HEIC-Dateien mit der LoadIntoCache() Erweiterungsmethode. Und das bringt uns zum EF Core-spezifischen Thema NCache APIs, die Sie verwenden können. Angenommen, Sie möchten beispielsweise nicht die Erweiterungsmethoden verwenden und mit unabhängigen Entitäten arbeiten, indem Sie eine Entität erstellen, sie im Kontext beibehalten und sie dann in den Cache verschieben. Also, NCache ermöglicht Ihnen dies mit dem EF Core-spezifisch NCache APIs. Diese funktionieren also so, dass Sie den Cache-Kontext aus dem EF Core-Kontext in Ihrer Anwendung abrufen. Und sobald Sie über diesen Cache-Kontext verfügen, können Sie diesen Cache-Kontext verwenden, um Entitäten in den Cache einzufügen oder Entitäten aus dem Cache zu entfernen.

Dies ist nicht mit den APIs zu verwechseln, die im bereitgestellt werden NCache SDK. Diese sind spezifisch für Entity Framework Core und verhalten sich wie für Entity Framework Core vorgesehen. In den Einfügedaten können Sie also sehen, dass wir einen Kunden mit einem Out-String-Cache-Schlüssel einfügen werden. Und dies ist ein Cache-Schlüssel, der von der Entity Framework Core API bereitgestellt wird.

Schauen wir uns nun an, wie das funktioniert, und dann können wir sehen, wie die Elemente oder Entitäten im Cache dauerhaft bleiben. Wenn wir also hier nach unten scrollen, können wir sehen, dass ich mithilfe des Cache-Handles einen Kunden zum Cache hinzufügen kann. Deshalb werde ich diesen Codeabschnitt hier einfach auskommentieren. Perfekt!

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

	options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));

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

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

Wenn Sie sehen, dass ich lediglich den Cache-Kontext erhalte, erstelle ich diesen Kunden hier. Ich sage hier, dass ich es als separate Einheit mit einem Ablauf von 10 Minuten speichern möchte. Ich behalte dies einfach in meinem Kontext bei, speichere die Änderungen und führe dann diese Cache-Einfügung hier durch. Und dann ausdrucken, dass ich diesen Kunden zum Cache hinzugefügt habe.

Lassen Sie uns nun also fortfahren, den Code ausführen und einen Blick darauf werfen, wie das funktioniert. Perfekt! Wir können also sehen, dass der Kunde zum Cache hinzugefügt wurde. Ich werde das einfach schließen. Wir können diese Addition für 1, die durchgeführt wurde, und diesen Anstieg in unserer Zählung sehen. Kommen wir also zur Statistik. Na, bitte! Wir sehen also 41 und die Zahl ist von 59 auf 60 gestiegen.

Lassen Sie uns nun fortfahren und die Cache-Schlüssel exportieren. Perfekt! Also los geht's! Wir können den Kunden sehen, der zum Cache hinzugefügt wurde, und Sie können sehen, dass die API diesem Artikel den Cache-Schlüssel zugewiesen hat. Wir mussten keinen Schlüssel angeben, um ihn hinzuzufügen. Also das ist perfekt!

Lassen Sie uns nun fortfahren, lassen Sie mich das klären und tatsächlich diesen Kunden entfernen, den wir in den Cache gelegt haben. Jetzt werde ich diesen Codeabschnitt noch einmal auskommentieren. Ich werde das einfach auskommentieren, dann scrollen wir nach unten und entfernen den Kunden mithilfe des Cache-Handles. Also, ich habe diesen Code hier. Also werde ich einfach alles auswählen und es hier einfach auskommentieren.

//-------------------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($"\n\nCustomer ID: {customerToRemove.Customerid} -> Removed from Cache");
	}
	else
	{
		Console.WriteLine("\n\ncould not find the customer within the cache");
	}

Und dieser Code ruft den Cache erneut aus dem Kontext ab und findet diesen Kunden innerhalb des Kontexts. Und wenn dieser Kunde tatsächlich gefunden wird, dann wird es ihn aus dem Kontext entfernen, die Änderungen speichern, dann diese Funktion „cache.Remove()“ ausführen, um den Kunden zu entfernen, und dann wird es ausdrucken, dass es so ist Hab's so gemacht. Andernfalls, wenn es den Kunden nicht finden kann, teilt er uns lediglich mit, dass der Kunde nicht im Cache gefunden werden konnte.

Lassen Sie uns nun fortfahren, dies speichern, diese Anwendung ausführen und einen Blick darauf werfen, was passiert. Perfekt! Also, den Kunden gefunden und aus dem Cache entfernt. Eindrucksvoll!

Schließen wir dies nun und werfen einen Blick auf die Anzahl. Wir sehen, dass sie von 60 auf 59 gesunken ist. Die Statistiken zeigen auch, dass die Anzahl von 60 auf 59 gesunken ist. Jetzt exportieren wir die Cache-Schlüssel. Wir sollten jetzt 100 Schlüssel sehen. Perfekt! Wir können also nicht sehen, dass der Kunde, den wir zuvor in der Zählung hinzugefügt haben, wieder auf 100 zurückgegangen ist. Damit sind wir so ziemlich am Ende dieser Demonstration angelangt. Vielen Dank fürs Zuschauen.

Nächste Schritte

Herunterladen NCache

Als Teil der nächsten Schritte können Sie nun Folgendes tun: Wenn Sie herunterladen möchten NCacheDann erhalten Sie eine kostenlose 30-Tage-Testversion, mit der Sie ein voll funktionsfähiges Produkt erhalten. Sie können dies tun, indem Sie zu gehen alachisoft.com hier und gehen Sie dann zu herunterladen Abschnitt von hier aus, und hier finden Sie die Angebote, die Sie basierend auf Ihren Anforderungen in Ihrer .NET-Version herunterladen können.

Versuchen Sie Playground

Du kannst dich Versuche das NCache Spielplatz für 30 Minuten. Dadurch erhalten Sie eine vollständige Sandbox-Sitzung, in der Sie mit dem Code herumspielen, sich ansehen können, wie die Beispiele ausgeführt werden, und ein Gefühl für das Produkt im Allgemeinen bekommen.

Vereinbaren Sie einen personalisierten Termin NCache Demo

Schließlich können Sie auch Vereinbaren Sie einen individuellen Termin NCache Demo wo wir Ihnen einen einstündigen Dump der anbieten NCache Funktionen und wie gut es funktioniert. Wir können die Art des Anwendungsfalls auch Ihren Schwachstellen zuordnen und sehen, wie gut Caching in Ihrer Umgebung funktionieren würde. Sie können also einfach ausfüllen dieses Formular hier und senden Sie die Anfrage ab. Sie können sicher sein, dass wir es bekommen und die Demo entsprechend planen.

Und damit sind wir so ziemlich am Ende dieser Demo angelangt. Vielen Dank fürs Zuschauen. Ich wünsche Ihnen einen wundervollen Tag. Auf Wiedersehen.