Synchronisierung des Caches mit SQL-/NoSQL-Datenbanken

SQL-Abhängigkeit

SQL-Abhängigkeit wird verwendet von NCache falls Ihre Datenbank SQL Server ist. Sie können eine SqlDependency für jedes zwischengespeicherte Element angeben, wenn Sie es im Cache hinzufügen oder aktualisieren. SQL Server überwacht das Dataset auf Hinzufügungen, Aktualisierungen oder Entfernungen und benachrichtigt es NCache durch SQL-Benachrichtigungen fast unmittelbar nach einer Datenbankaktualisierung. Dies sind Datenbankbenachrichtigungen, die in .NET-Ereignisse umgewandelt werden.

SqlDependency kann eine der folgenden sein:

• Inline-Abfragen
• Gespeicherte Prozeduren

Weitere Details zu diesem Thema finden Sie im Cache mit SQL Server synchronisieren docs.

Wie SQL-Abhängigkeiten funktionieren

• Trigger: SQL Server erkennt eine Datenänderung (Einfügen, Aktualisieren oder Löschen).
• Benachrichtigen: SQL Server sendet eine .NET-Ereignisbenachrichtigung an NCache.
• Aktion: NCache Das Element wird automatisch ungültig gemacht oder neu geladen, um die Integrität zu gewährleisten.

Verwenden von Inline-Abfragen

So können Sie mithilfe einer dynamisch erstellten SQL-Abfrage eine SQL-Abhängigkeit erstellen:

// Precondition: Cache is already connected
// Creating a connection string to get connected with the database
string connectionString = "your_connection_string_here";

// Getting products from the database
List<Product> products = FetchProductFromDB();

foreach (Product product in products)
{
    string productKey = $"Product: {product.ProductID}";

    // Creating an SQL dependency on the UnitPrice of product. Whenever the UnitPrice changes, the product is removed from the cache
    string query = $"SELECT UnitPrice FROM dbo.Products WHERE ProductID = {product.ProductID}";

    // Creating dependency
    SqlCacheDependency dependency = new SqlCacheDependency(connectionString, query);

    CacheItem productItem = new CacheItem(product);

    // Adding Dependency to product item
    productItem.Dependency = dependency;

    // Adding CacheItem in cache
    _cache.Add(productKey, productItem);
}

Gespeicherte Prozeduren verwenden

So können Sie SQL-Abhängigkeiten in Ihrem .NET-Code mit gespeicherten Prozeduren verwenden:

// Precondition: Cache is already connected

// Creating connection string to get connected with the database
string connectionString = "your_connection_string_here";
string spGetUnitPriceByProductID = "sp_GetUnitPriceByProductID";

// Getting products from the database
List<Product> products = FetchProductFromDB();

// Creating dictionary of CacheItems
Dictionary<string, CacheItem> cacheItems = new Dictionary<string, CacheItem>();

foreach (Product product in products)
{
    string productKey = $"Product: {product.ProductID}";

    // Creating Param to be passed in stored procedure dictionary
    SqlCmdParams paramProductID = new SqlCmdParams
    {
        Type = CmdParamsType.Int,
        Value = product.ProductID
    };

    // Creating stored procedure params
    Dictionary<string, SqlCmdParams> parameters = new Dictionary<string, SqlCmdParams>();
    parameters.Add("@ProductID", paramProductID);

    CacheItem productItem = new CacheItem(product);

    // Creating an SQL dependency on the UnitPrice of the product. Whenever the UnitPrice changes, the product is removed from the cache
    SqlCacheDependency dependency = new SqlCacheDependency(connectionString, spGetUnitPriceByProductID, SqlCommandType.StoredProcedure, parameters);

    // Adding Dependency to product item
    productItem.Dependency = dependency;

    cacheItems.Add(productKey, productItem);
}
// Adding CacheItems in cache
_cache.AddBulk(cacheItems);

Oracle-Abhängigkeit

NCache nutzt Oracle Continuous Query Notification (CQN), um Datenbankänderungen zu überwachen. Im Gegensatz zum herkömmlichen Polling stellt dieser Push-basierte Mechanismus sicher, dass der Oracle-Server nur mit dem System kommuniziert. NCache Wenn der durch Ihre SQL-Abfrage definierte Datensatz geändert wird, reduziert dies den Netzwerk-Overhead erheblich und gewährleistet die Echtzeit-Cache-Synchronisierung.

OracleAbhängigkeit wird verwendet von NCache falls Ihre Datenbank Oracle 10g oder höher ist und entweder unter Windows oder Unix läuft. Genau wie bei SqlDependency können Sie OracleDependency für jedes zwischengespeicherte Element angeben, wenn Sie es im Cache hinzufügen oder aktualisieren.

OracleDependency kann eine der folgenden sein:

• Inline-Abfragen
• Gespeicherte Prozedur

Oracle Server überwacht dann diesen Datensatz auf Ergänzungen, Aktualisierungen oder Entfernungen und benachrichtigt in diesem Fall NCache durch Oracle-Benachrichtigungen fast unmittelbar nach der Datenbankaktualisierung.

Verwenden von Inline-Abfragen

So können Sie Oracle-Abhängigkeiten in Ihrem .NET-Code mithilfe von Inline-Abfragen verwenden:

// Precondition: Cache is already connected

// Creating a connection string to get connected with the database
string connectionString = "your_connection_string_here";

// Getting products from the database
List<Product> products = FetchProductFromDB();

foreach (Product product in products)
{
      string productKey = $"Product: {product.ProductID}";

      // Creating an Oracle dependency on the UnitPrice of the product. Whenever the UnitPrice changes, the product is removed from the cache
      string query = $"SELECT ROWID, UnitPrice FROM Products WHERE ProductID = {product.ProductID}";

      OracleCacheDependency dependency = new OracleCacheDependency(connectionString, query);

      CacheItem productItem = new CacheItem(product);

      // Adding Dependency to product item
      productItem.Dependency = dependency;

      // Adding CacheItem in cache
      cache.Add(productKey, productItem);
}

Gespeicherte Prozeduren verwenden

Sie können parametrisierte gespeicherte Prozeduraufrufe in Oracle-Abhängigkeit wie hier gezeigt verwenden:

// Precondition: Cache is already connected

// Creating a connection string to get connected with the database
string connectionString = "your_connection_string_here";

string spGetUnitPriceByProductID = "sp_GetUnitPriceByProductID";

// Getting products from the database
List<Product> products = FetchProductFromDB();

foreach (Product product in products)
{
      string productKey = $"Product: {product.ProductID}";
      // Creating Param to be passed in stored procedure dictionary
      OracleCmdParams paramProductID = new OracleCmdParams
      {
            Type = OracleCmdParamsType.Int32,
            Value = product.ProductID
      };
      // Creating stored procedure params
      Dictionary<string, OracleCmdParams> parameters = new Dictionary<string, OracleCmdParams>();
      parameters.Add("@ProductID", paramProductID);

      CacheItem productItem = new CacheItem(product);

      // Creating an Oracle dependency on the UnitPrice of the product. Whenever the UnitPrice changes, the product is removed from the cache
      OracleCacheDependency dependency = new OracleCacheDependency(connectionString, spGetUnitPriceByProductID, OracleCommandType.StoredProcedure, parameters);

      // Adding Dependency to product item
      productItem.Dependency = dependency;

      // Adding CacheItem in cache
      cache.Add(productKey, productItem);
}

Cache mit MongoDB synchronisieren

NCache bietet Flexibilität und Kontrolle über die Cache-Invalidierung durch benutzerdefinierte Benachrichtigungsabhängigkeiten. Für MongoDB können Sie Ihren Cache mithilfe von Change Streams in Echtzeit mit Ihrer MongoDB-Datenbank synchronisieren.

Dadurch werden Einfügungen, Aktualisierungen, Löschungen und Ersetzungen in Ihren MongoDB-Sammlungen erkannt. NCache können Sie die entsprechenden Cache-Einträge sofort entfernen oder aktualisieren, wenn eine Änderung auftritt. So wird sichergestellt, dass Ihr Cache aktuell und mit der Datenbank konsistent bleibt.

Hier ist ein Beispiel für die Implementierung dieser Synchronisierung mithilfe der Change Streams von MongoDB in Ihrer .NET-Anwendung:

var pipeline = new EmptyPipelineDefinition<ChangeStreamDocument<Customer>>()
    .Match("{ operationType: { $in: ['insert', 'update', 'replace', 'delete'] } }");
 
var cursor = collection.Watch(pipeline);
await cursor.ForEachAsync(change =>
{
    string cacheKey = $"Customer:CustomerID:{change.FullDocument.Id}";
    cache.Remove(cacheKey);
});

OleDB-Abhängigkeit

OleDB-Abhängigkeit wird verwendet von NCache falls Ihre Datenbank weder SQL Server noch Oracle ist, sondern eine OLEDB-kompatible Datenbank. Sie können DbDependency auch mit SQL Server und Oracle verwenden, wenn Sie deren Ereignisbenachrichtigungen nicht wünschen, die bei sehr schnellen Datenänderungen zeitaufwändig sein können.

In DbDependency erstellen Sie in der Datenbank eine Tabelle namens ncache_db_sync, die für jedes zwischengespeicherte Element mit DbDependency eine Zeile enthält. Sie ändern Ihre Datenbanktrigger, um Zeilen in dieser Tabelle zu aktualisieren, wenn sich die entsprechenden Daten in der Datenbank ändern. NCache fragt diese Tabelle nach aktualisierten Zeilen ab, also in einer Abfrage, NCache ruft Tausende von Zeilen ab und synchronisiert sie mit der Datenbank.

So können Sie DbDependency in Ihrem .NET-Code verwenden.

DBCacheDependency oledbDependency = DBDependencyFactory.CreateOleDbCacheDependency(connectionString, "PrimaryKey:dbo.Products");

var cacheItem = new CacheItem(product);
cacheItem.Dependency = oledbDependency;
cache.Insert(key, cacheItem);

CLR-Prozeduren

Wenn Sie eine sehr große Anzahl von Elementen im Cache haben und alle mit der Datenbank synchronisiert werden müssen, ist es viel besser, eine zu schreiben CLR-Verfahren in SQL Server unter Windows. Diese CLR-Prozedur wird von Ihren Datenbank-Triggern aufgerufen, wenn sich die relevanten Daten ändern. Diese CLR-Prozedur macht dann asynchron NCache API-Aufrufe zum Hinzufügen, Aktualisieren oder Entfernen des entsprechenden zwischengespeicherten Elements aus dem Cache.

Hier ist ein Beispiel für eine CLR-Prozedur, die das Objekt entfernt, wenn es aktualisiert wird.

[Microsoft.SqlServer.Server.SqlProcedure]
    public static void RemoveOnUpdate(string cacheName, string key)
    {

        // Connect to the cache
        ICache cache = CacheManager.GetCache(cacheName);

        // Remove specified item
        cache.Remove(key);

        // Dispose the cache
        cache.Dispose();
    }

Automatisches Neuladen mit Read-Through-Handler

Das Standardverhalten der Datenbanksynchronisierung besteht darin, das zwischengespeicherte Element aus der Datenbank zu entfernen, wenn sich die entsprechenden Daten in der Datenbank ändern. Es gibt jedoch Situationen, in denen Sie es einfach mit der neuesten Version der Daten aktualisieren möchten.

Um diesem Bedarf gerecht zu werden, NCache ermöglicht es Ihnen, die Datenbanksynchronisierung mit der zu kombinieren Durchlesen Caching-Funktion von NCache. Mit diesem, NCache Ruft einfach den Read-Through-Handler auf, um die neueste Kopie des zwischengespeicherten Elements neu zu laden, und aktualisiert dann den Cache damit. Diese Funktion bietet die Flexibilität zum Synchronisieren NCache mit jeder konfigurierten relationalen oder NoSQL-Datenbank, einschließlich der folgenden (und weiterer):

1. SQL Server
2. Oracle
3. MongoDB

Der folgende Codeausschnitt zeigt, wie Daten automatisch in großen Mengen neu geladen werden können in NCache aus der Datenbank mit Read-through. Weitere Details finden Sie auch werden auf dieser Seite erläutert.

String[] keys = { "Product:1001", "Product:1002",
"Product:1003","Product:1004"};

// Specify the readThruOptions for Read-through operations
var readThruOptions = new ReadThruOptions();
readThruOptions.Mode = ReadMode.ReadThru;

// Retrieve the dictionary of Products with corresponding products
IDictionary<string, Product> retrievedItems = cache.GetBulk<Product>(keys, readThruOptions);

Unterstützte Umgebungen für die Synchronisierung

• Relational: SQL Server, Oracle, PostgreSQL, MySQL (über OLEDB/CLR).
• NoSQL: MongoDB, Azure Cosmos DB.
• Benutzerdefiniert: Beliebige Datenquelle über CustomDependency- und Read-Through-Handler.