Sincronizzare la cache con database SQL/NoSQL

Dipendenza SQL

Dipendenza Sql è usato da NCache nel caso in cui il tuo database sia SQL Server. Puoi specificare una SqlDependency per qualsiasi elemento memorizzato nella cache quando lo aggiungi o lo aggiorni nella cache. SQL Server monitora il set di dati per eventuali aggiunte, aggiornamenti o rimozioni e invia notifiche NCache tramite notifiche SQL quasi immediatamente dopo un aggiornamento del database. Si tratta di notifiche del database che vengono trasformate in eventi .NET.

SqlDependency può essere uno dei seguenti:

• Query in linea
• Procedura di archiviazione

Puoi trovare maggiori dettagli su questo argomento nel Sincronizza la cache con SQL Server Documenti.

Come funziona la dipendenza SQL

• Trigger: SQL Server rileva una modifica ai dati (inserimento, aggiornamento o eliminazione).
• Notificare: SQL Server invia una notifica di evento .NET a NCache.
• Azione: NCache invalida o ricarica automaticamente l'elemento per mantenerne l'integrità.

Utilizzo di query in linea

Ecco come puoi creare una dipendenza SQL utilizzando una query SQL costruita dinamicamente:

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

Utilizzo delle stored procedure

Ecco come puoi utilizzare la dipendenza SQL nel tuo codice .NET con le stored procedure:

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

Dipendenza da Oracle

NCache Utilizza la notifica continua delle query (CQN) di Oracle per monitorare le modifiche al database. A differenza del polling tradizionale, questo meccanismo basato su push garantisce che il server Oracle comunichi solo con NCache quando viene modificato il set di dati specifico definito dalla query SQL. Ciò riduce significativamente il sovraccarico di rete e garantisce la sincronizzazione della cache in tempo reale.

Dipendenza Oracle è usato da NCache nel caso in cui il tuo database sia Oracle 10g o successivo e sia in esecuzione su Windows o Unix. Proprio come SqlDependency, puoi specificare OracleDependency per qualsiasi elemento memorizzato nella cache quando lo aggiungi o lo aggiorni nella cache.

OracleDependency può essere uno dei seguenti:

• Query in linea
• Procedura memorizzata

Oracle Server monitora quindi questo set di dati per eventuali aggiunte, aggiornamenti o rimozioni e, quando ciò accade, lo notifica NCache tramite Oracle Notifications quasi immediatamente dopo l'aggiornamento del database.

Utilizzo di query in linea

Ecco come puoi utilizzare la dipendenza Oracle nel tuo codice .NET tramite query inline:

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

Utilizzo delle stored procedure

È possibile utilizzare chiamate di stored procedure con parametri nella dipendenza Oracle come mostrato di seguito:

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

Sincronizza la cache con MongoDB

NCache Offre flessibilità e controllo sull'invalidazione della cache tramite dipendenze di notifica personalizzate. Per MongoDB, è possibile sincronizzare la cache in tempo reale con il database MongoDB utilizzando Change Streams.

Rileva inserimenti, aggiornamenti, eliminazioni e sostituzioni nelle raccolte MongoDB. NCache può rimuovere o aggiornare immediatamente le voci della cache corrispondenti quando si verifica una modifica, garantendo che la cache rimanga aggiornata e coerente con il database.

Ecco un esempio di come implementare questa sincronizzazione utilizzando i flussi di modifiche di MongoDB nella tua applicazione .NET:

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

Dipendenza da OleDB

Dipendenza da OleDB è usato da NCache nel caso in cui il database non sia né SQL Server né Oracle, ma sia un database compatibile con OLEDB. Puoi anche utilizzare DbDependency con SQL Server e Oracle se non desideri ricevere notifiche di eventi, che potrebbero risultare fastidiose se i dati cambiano molto rapidamente.

In DbDependency, si crea una tabella denominata ncache_db_sync nel database, che contiene una riga per ogni elemento memorizzato nella cache con DbDependency. Si modificano i trigger del database per aggiornare le righe di questa tabella quando i dati corrispondenti nel database cambiano. NCache interroga questa tabella per le righe aggiornate, quindi in un sondaggio, NCache recupera migliaia di righe e le sincronizza con il database.

Ecco come puoi usare DbDependency nel tuo codice .NET.

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

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

Procedure CLR

Quando hai un numero molto elevato di elementi nella cache e tutti devono essere sincronizzati con il database, è molto meglio scrivere un Procedura CLR in SQL Server su Windows. Questa procedura CLR viene richiamata dai trigger del database quando i dati rilevanti cambiano. Questa procedura CLR rende quindi asincrona NCache Chiamate API per aggiungere, aggiornare o rimuovere l'elemento memorizzato nella cache corrispondente dalla cache.

Ecco un esempio di una procedura CLR che rimuove l'oggetto se viene aggiornato.

[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();
    }

Ricarica automatica con gestore read-through

Il comportamento predefinito della sincronizzazione del database è quello di rimuovere l'elemento memorizzato nella cache dal database quando i dati corrispondenti nel database cambiano. Tuttavia, ci sono situazioni in cui si desidera semplicemente aggiornarlo con la versione più recente dei dati.

Per gestire questa esigenza, NCache consente di combinare la sincronizzazione del database con il Lettura funzionalità di memorizzazione nella cache di NCache. Con questo, NCache chiama semplicemente il gestore Read-through per ricaricare la copia più recente dell'elemento memorizzato nella cache e quindi aggiorna la cache con essa. Questa funzione offre la flessibilità per la sincronizzazione NCache con qualsiasi database relazionale o NoSQL configurato, inclusi i seguenti (e altri):

1. SQL Server
2. Oracle
3. MongoDB

Il seguente frammento di codice mostra come i dati possono essere ricaricati automaticamente in blocco in NCache dal database tramite Read-through. Puoi anche trovare maggiori dettagli Qui..

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);

Ambienti supportati per la sincronizzazione

• Relazionale: SQL Server, Oracle, PostgreSQL, MySQL (tramite OLEDB/CLR).
• NessunSQL: MongoDB, Azure Cosmos DB.
• Personalizzato: Qualsiasi origine dati tramite i gestori CustomDependency e Read-Through.