Datenbanken sind ein wesentlicher Bestandteil von .NET Anwendungen, da Sie große Datenmengen effizient abrufen und bearbeiten können. Bei der Verarbeitung hoher Transaktionsdaten führen Datenbanken jedoch zu Leistungseinbußen in Ihren .NET-Anwendungen. Dies liegt daran, dass Datenbanken nicht auf mehrere Maschinen skaliert werden können – Sie können nur eine Servermaschine für die Datenbankschicht dedizieren und keine weiteren hinzufügen. Die Datenbank wird somit zum Performance-Engpass. Um dieses Problem zu lösen, verwenden wir eine verteilte Caching-Lösung, wie z NCache um unnötige und teure Zugriffe auf die Datenbank zu vermeiden.
NCache Details Herunterladen NCache Editionsvergleich
Wie speichert man eine Datenbank zwischen?
Das Zwischenspeichern einer Datenbank ist viel einfacher, als es sich anhört. Sie müssen eine Caching-Ebene mit einem Cache wie integrieren NCache zwischen Ihrer Anwendung und der Datenbankschicht, sodass Datenbankdaten aus dem Cache bereitgestellt werden. Der Einfachheit halber wurden die vier häufigsten Muster der Cache-Nutzung zusammengefasst. Nachfolgend werden sie informiert:
1. Objekt-Caching
Diese Strategie schlägt vor, dass Sie Ihre Daten, wenn sie nicht im Cache vorhanden sind, aus der Datenbank abrufen und dann in den Cache einfügen, z NCache. Nachfolgende Aufrufe werden anschließend aus dem Cache bearbeitet. Bei Problemen mit veralteten Daten fügen Sie hinzu Ablauf zu den Cache-Element damit es aus der Datenbank aktualisiert werden kann.
Der folgende Codeabschnitt ruft eine Instanz von „Customer“ aus dem Cache ab, sofern vorhanden. Andernfalls ruft es es aus der Datenbank ab und fügt es dem Cache für einen Cache-Treffer in aufeinanderfolgenden Aufrufen hinzu.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
var key = "Customer:1001"; // Get Customer from cache if it exists var customer = cache.Get<Customer>(key); // If customer does not exist in cache if (customer == null) { // Fetch from database customer = GetCustomerFromDB(1001); // Create sliding expiration of 15 seconds. Cache removes item after this time var expiration = new Expiration (ExpirationType.Sliding, TimeSpan.FromSeconds(15.0)); var cacheItem = new CacheItem(customer) { Expiration = expiration }; // Insert the item with expiration into cache cache.Insert(cacheKey, cacheItem); } |
NCache Details Daten-Caching-Dokumente NCache Programmierhandbuch
2. Referenzdaten zwischenspeichern und mithilfe von SQL-Abfragen durchsuchen
Daten, die nur gelesen und nicht häufig geändert werden, werden als Referenzdaten bezeichnet. Es kommt durchaus vor, dass eine .NET-Anwendung wiederholt Daten liest und nur selten Daten in die Datenbank schreibt. Der Cache (wie NCache) ist leistungsfähiger, wenn es für Referenzdaten verwendet wird, da es mit solchen Daten am schnellsten arbeitet.
Es wird dringend empfohlen, die gesamten Referenzdaten zwischenzuspeichern und dann zu verwenden SQL-Abfragen zum Durchsuchen des Caches dafür statt in die Datenbank zu gehen. Bitte beachten Sie, dass Ihre SQL-Abfragen für den Cache ungültige Ergebnisse zurückgeben, wenn Sie nicht den gesamten Referenzdatensatz (z. B. alle Kunden) zwischenspeichern, da einige der Daten nur in der Datenbank vorhanden sind.
Wenn du schon hast den Cache vorgeladen mit all Ihren Referenzdaten, dann erklärt das folgende Beispiel, wie Sie danach suchen können:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// Pre-Requisite: All customer instances have already been added into cache var customerName = "John Smith"; // Write SQL query for cache var query = "SELECT $Value$ FROM Northwind.Model.Customer WHERE Name = ?"; // Create the query command that cache understands from the query var queryCommand = new QueryCommand(query); // Provide the parameters for the query queryCommand.Parameters.Add("Name", customerName); // Execute the query on cache var reader = cache.SearchService.ExecuteReader(queryCommand, true); var customer; // If a valid projection was made in the query if (reader.FieldCount > 0) { while (reader.Read()) { customer = reader.GetValue<Customer>(1); // Perform operation according to business logic } } |
NCache Details SQL-Caching-Dokumente Daten-Caching-Dokumente
3. Umgang mit Eins-zu-Viele-Beziehungen im Cache
Meistens enthalten unsere Daten Beziehungen zwischen ihnen. Beispielsweise ist im Kontext der Northwind-Datenbank (von Microsoft verwendet) die Tabelle „Bestellungen“ mit der Tabelle „Kunden“ verknüpft. Diese Entitäten gelten als verwandte Entitäten in der Domäne der .NET-Anwendung. Verwenden eines Caches wie z NCache, können Sie diese Entitäten auch innerhalb des Caches verknüpfen.
Dies geschieht durch Verknüpfen aller zugehörigen Entitäten mit einer Tag-ID Anstatt also jede Kundenbestellung einzeln abzurufen, können Sie alle Bestellungen des Kunden in einem einzigen Aufruf abrufen, indem Sie den Cache über die Tag-ID durchsuchen. Der angegebene Beispielcode veranschaulicht, wie wir dieses Verhalten herbeiführen können:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
var cacheKey = "Customer:1001"; var tagName = "Customer:1001_Orders"; // Check if customer exists in cache var cachedCustomer = cache.Get<Customer>(cacheKey); // If customer does not exist in cache if (cachedCustomer == null) { // Fetch from database var customer = GetCustomerFromDb(1001); // Insert customer into cache cache.Insert(cacheKey, customer); // Fetch orders of the customer from database var relatedOrders = GetRelatedOrdersFromDb(customer); // Create a tag for all orders of the customer var tag = new Tag(tagName); foreach (Order order in relatedOrders) { var orderCacheKey = $"Customer:1001_Order:{order.OrderID}"; // Create a cache item and set the tag identifier var orderCacheItem = new CacheItem(order) { Tags = new[] { tag } }; // Insert the tagged cache item into cache cache.Insert(orderCacheKey, orderCacheItem); } } else { // Item exists in the cache // Create a tag to fetch the related orders var tagIdentifier = new Tag(relatedEntityIdentifier); // Fetch the related orders based on the tag identifier var cachedOrders = cache.SearchService.GetByTag<Order>(tagIdentifier); } |
NCache Details Mit Tags versehene Datendokumente im Cache speichern Daten-Caching-Dokumente
4. Zwischenspeichern von Datenbankabfrageergebnissen (Transaktionsdaten)
In den meisten Fällen werden Daten aus der Datenbank in Form von Abfrageergebnissätzen zurückgegeben. Diese Strategie schlägt vor, dass Sie den gesamten Ergebnissatz in den Cache einfügen, sodass aufeinanderfolgende Abfragen aus dem Cache bedient werden. Abfragen mit denselben Kriterien beziehen sich immer auf denselben Ergebnissatz. Daher können wir Abfragebefehle selbst als eindeutige Kennung für die Ergebnismenge betrachten und sie als Schlüssel im Cache verwenden.
Der folgende Code zeigt, wie Abfrageergebnismengen als Sammlungen zwischengespeichert werden können:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// Query to select East Coast Customers var query = "SELECT * FROM Northwind.Model.Customer WHERE Region = ‘EastCoast’"; // Create cache key based on the query var key = query; // Fetch the entities based on query var resultSet = cache.Get<IList<Customer>>(key); // If data against query not found in cache if (resultSet == null) { // Fetch the result set from database var customers = GetCustomersFromDb(query); // Convert the result set into a collection var cacheReadyCustomers = customers.ToList(); // Add result set to cache against query cache.Insert(cacheKey, cacheReadyCustomers); } |
NCache Details Daten-Caching-Dokumente SQL-Caching-Dokumente
Zusammenfassung
Wie Sie sehen, ist das Zwischenspeichern einer Datenbank in .NET-Anwendungen mit einem Cache vergleichbar NCache ist ganz einfach. Basierend auf Nutzungsmustern in der Anwendung können Sie Ihre Daten zwischenspeichern und über Abfragen abrufen, als ob Sie dies für eine Datenbank tun würden.
Außerdem, NCache ist eine verteilte In-Memory-Caching-Lösung. Alle bei der Verwendung einer Datenbank auftretenden Probleme werden darin behandelt und es sind alle Implementierungen für einen Cache mit Standardanforderungen und vieles mehr vorhanden.