Sincronizar la caché con bases de datos SQL/NoSQL

Dependencia SQL

Dependencia Sql es utilizado por NCache en caso de que su base de datos sea SQL Server. Puede especificar una SqlDependency para cualquier elemento en caché cuando lo agregue o actualice en el caché. SQL Server supervisa el conjunto de datos en busca de adiciones, actualizaciones o eliminaciones y notifica NCache Mediante notificaciones SQL casi inmediatamente después de una actualización de la base de datos. Estas notificaciones se transforman en eventos .NET.

SqlDependency puede ser cualquiera de los siguientes:

• Consultas en línea
• Procedimientos almacenados

Puede encontrar más detalles sobre este tema en el Sincronizar caché con SQL Server docs.

Cómo funciona la dependencia de SQL

• Trigger: SQL Server detecta un cambio de datos (Insertar, Actualizar o Eliminar).
• Notificar: SQL Server envía una notificación de evento .NET a NCache.
• Acción: NCache invalida o recarga automáticamente el elemento para mantener la integridad.

Uso de consultas en línea

A continuación se explica cómo crear una dependencia SQL mediante una consulta SQL construida dinámicamente:

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

Usar procedimientos almacenados

A continuación se explica cómo puede utilizar la dependencia SQL en su código .NET con procedimientos almacenados:

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

Dependencia de Oracle

NCache Utiliza la Notificación Continua de Consultas (CQN) de Oracle para supervisar los cambios en la base de datos. A diferencia del sondeo tradicional, este mecanismo basado en push garantiza que el servidor Oracle solo se comunique con NCache Cuando se modifica el conjunto de datos específico definido por la consulta SQL. Esto reduce significativamente la sobrecarga de la red y garantiza la sincronización de la caché en tiempo real.

OracleDependencyOracleDependency es utilizado por NCache en caso de que su base de datos sea Oracle 10g o posterior y se ejecute en Windows o Unix. Al igual que SqlDependency, puede especificar OracleDependency para cualquier elemento en caché cuando lo agregue o actualice en el caché.

OracleDependency puede ser cualquiera de los siguientes:

• Consultas en línea
• Procedimiento almacenado

Luego, Oracle Server supervisa este conjunto de datos para detectar cualquier adición, actualización o eliminación y, cuando eso sucede, notifica. NCache a través de Oracle Notifications casi inmediatamente después de la actualización de la base de datos.

Uso de consultas en línea

A continuación se explica cómo puede utilizar la dependencia de Oracle en su código .NET mediante consultas en línea:

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

Usar procedimientos almacenados

Puede usar llamadas de procedimientos almacenados parametrizados en la dependencia de Oracle como se muestra aquí:

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

Sincronizar caché con MongoDB

NCache Ofrece flexibilidad y control sobre la invalidación de caché mediante dependencias de notificación personalizadas. En MongoDB, puede sincronizar su caché en tiempo real con su base de datos MongoDB mediante flujos de cambios.

Esto detecta inserciones, actualizaciones, eliminaciones y reemplazos en sus colecciones de MongoDB. NCache puede eliminar o actualizar inmediatamente las entradas de caché correspondientes cuando ocurre un cambio, lo que garantiza que su caché permanezca actualizado y consistente con la base de datos.

A continuación se muestra un ejemplo de cómo implementar esta sincronización utilizando los flujos de cambios de MongoDB en su aplicación .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);
});

Dependencia OleDB

Dependencia OleDB es utilizado por NCache Si su base de datos no es SQL Server ni Oracle, sino compatible con OLEDB, también puede usar DbDependency con SQL Server y Oracle si no desea recibir sus notificaciones de eventos, que podrían resultar confusas si sus datos cambian rápidamente.

En DbDependency, se crea una tabla llamada ncache_db_sync en la base de datos, que contiene una fila por cada elemento almacenado en caché con DbDependency. Se modifican los disparadores de la base de datos para actualizar las filas de esta tabla cuando cambian los datos correspondientes. NCache sondea esta tabla en busca de filas actualizadas, por lo que en una encuesta, NCache recupera miles de filas y las sincroniza con la base de datos.

Así es como puede usar DbDependency en su código .NET.

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

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

Procedimientos CLR

Cuando tiene una gran cantidad de elementos en el caché y todos deben sincronizarse con la base de datos, es mucho mejor escribir un Procedimiento CLR en SQL Server en Windows. Este procedimiento CLR se llama desde los disparadores de su base de datos cuando cambian los datos relevantes. Este procedimiento CLR luego hace asíncrono NCache Llamadas a la API para agregar, actualizar o eliminar el elemento almacenado en caché correspondiente de la memoria caché.

Aquí hay un ejemplo de un procedimiento CLR que elimina el objeto si se actualiza.

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

Recarga automática con controlador de lectura

El comportamiento predeterminado de la sincronización de la base de datos es eliminar el elemento almacenado en caché cuando los datos correspondientes cambian. Sin embargo, en ocasiones simplemente se desea actualizarlo con la última versión de los datos.

Para manejar esta necesidad, NCache le permite combinar la sincronización de la base de datos con la Leer de parte a parte función de almacenamiento en caché de NCache. Con este, NCache simplemente llama al controlador de lectura completa para recargar la última copia del elemento en caché y luego actualiza el caché con él. Esta característica proporciona la flexibilidad para sincronizar NCache con cualquier base de datos relacional o NoSQL que haya sido configurada, incluyendo las siguientes (y más):

1. SQL Server
2. el
3. MongoDB

El siguiente fragmento de código muestra cómo se pueden recargar automáticamente los datos de forma masiva en NCache de la base de datos mediante lectura directa. También puede encontrar más detalles. aquí.

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

Entornos compatibles para la sincronización

• Relacional: SQL Server, Oracle, PostgreSQL, MySQL (a través de OLEDB/CLR).
• No SQL: MongoDB, Azure Cosmos DB.
• Personalizada: Cualquier fuente de datos a través de los controladores CustomDependency y Read-Through.