Notificar el uso e implementación de la dependencia extensible
Note
Esta función solo está disponible en el NCache Enterprise para Servidores .NET.
Además de nuestras localidaded en Dependencia extensible masiva, NCache proporciona otro método para la dependencia de la caché llamado Dependencia extensible basada en notificaciones o Dependencia extensible de notificación. En Notificar dependencia extensible, el lado del cliente es responsable de implementar un proveedor que contenga la lógica detrás de la dependencia y cuándo invocar esa dependencia. Luego, el servidor invoca el caché para métodos relacionados con la dependencia considerando la lógica proporcionada por el cliente. La caché busca elementos en Notificar dependencia extensible y si es necesario eliminarlos o no.
En la dependencia extensible basada en notificaciones, los clientes tienen todo el control sobre cuándo y cómo llamar a una dependencia de un elemento. De esta manera, los elementos pueden caducar de la caché de una manera extremadamente flexible.
NCache proporciona una clase abstracta NotifyExtensibleDependency
, una extensión de dependencias personalizadas proporcionada por NCache, que implementa este comportamiento.
Consejo
Consulte Dependencias de caché personalizadas para familiarizarse con todos los métodos personalizados de dependencia de caché proporcionados por NCache.
Requisitos previos
- Para obtener información sobre los requisitos previos estándar necesarios para trabajar con todos NCache funciones del lado del servidor, consulte la página dada en Requisitos previos de la API del lado del servidor.
- El proyecto debe implementarse como una biblioteca de clases (.dll) en Visual Studio. Esto se implementará en NCache racimo.
- Asegúrese de Implementar proveedores de dependencia personalizados usando el NCache Centro de Gestión.
- El
NotifyExtensibleDependency
la clase debe ser desplegado en caché - Para obtener detalles de la API, consulte: Dolor, Artículo de caché, Añada, insertar, Eliminar, Dependencia personalizada, Crear dependencia, ICustomDependencyProviderICustomDependencyProvider, NotifyExtensibleDependencyNotifyExtensibleDependency, DependenciaChangedHandler.
Note
Para obtener información detallada sobre los métodos implementados en NotifyExtensibleDependency
, referirse a Métodos .
Paso 1: implementar la clase NotifyExtensibleDependency
El primer paso para introducir su propia lógica para Notificar dependencia extensible es heredar el NotifyExtensibleDependency
clase.
Supongamos que desea agregar clientes a su base de datos de Cosmos con su propia lógica de dependencia. Aquí se explica cómo implementar la Dependencia extensible de notificación con Cosmos DB en su aplicación.
[Serializable]
public class NotificationDependency<T> : NotifyExtensibleDependency
{
// Class parameters
public NotificationDependency(/* */)
{
// Assign values to class members
}
public override bool Initialize()
{
// Register dependency against key
RegisterDependency(_key, this);
return true;
}
public bool RegisterDependency(string key, NotifyExtensibleDependency dependency)
{
lock (this)
{
// Your logic here
dependencies.Add(key, dependency);
}
return true;
}
public void OnFeedChange(params object[] args)
{
// Find the matching dependency and fire its DependencyChangedEvent
var key = args[0];
var notifyExtensibleDep = (dependencies[key] as NotifyExtensibleDependency);
notifyExtensibleDep?.DependencyChanged.Invoke(this);
// Remove the matched keys from cache
lock (dependencies)
{
dependencies.Remove(key);
}
}
protected override void DependencyDispose()
{
// Dispose off resources
}
// This class is to be deployed on NCache
}
Paso 2: implementar NotifyCustomDependencyProvider
Para implementar el proveedor Notificar dependencia extensible en su aplicación, use el siguiente fragmento de código.
public class NotifyCustomDependencyProvider : ICustomDependencyProvider
{
private string cacheName;
private string monitoredUri;
private string authKey;
private string databaseName;
public void Init(IDictionary<string, string> parameters, string cacheName)
{
// Initialize cache and class parameters
}
public NotificationDependency CreateDependency(string key, IDictionary<string, string> dependencyParameters)
{
string customerId="";
string monitoredCollection = "";
string leaseCollection = "";
if (dependencyParameters != null)
{
if (dependencyParameters.ContainsKey("Key"))
customerId = dependencyParameters["Key"];
if (dependencyParameters.ContainsKey("MonitoredCollectionName"))
monitoredCollection = dependencyParameters["MonitoredCollectionName"];
if (dependencyParameters.ContainsKey("LeaseCollectionName"))
leaseCollection = dependencyParameters["LeaseCollectionName"];
// Create notify extensible dependency
NotificationDependency<Customer> cosmosDbDependency = new NotificationDependency<Customer>(customerId,
monitoredUri, authKey, databaseName, monitoredCollection, databaseName, leaseCollection);
return cosmosDbDependency;
}
else
{
// Dependency parameters not found
}
}
public void Dispose ()
{
// Dispose off all resources
}
}
Paso 3: implementar la implementación en caché
Implemente esta clase y todos los demás ensamblajes dependientes en NCache haciendo referencia a Implementar proveedores en la Guía del administrador para obtener ayuda.
Paso 4: Use la dependencia extensible de notificación
Una vez que se haya implementado e implementado la dependencia extensible basada en notificaciones en la memoria caché, estará lista para usarse en su aplicación. El siguiente código muestra cómo agregar datos usando el recuadro método con dependencia personalizada basada en notificaciones.
Note
En el caso de la memoria caché del cliente, el usuario debe implementar explícitamente estos ensamblajes en la memoria caché del cliente.
// Specify the connection credentials
string endPoint = ConfigurationManager.AppSettings["EndPoint"];
string authKey = ConfigurationManager.AppSettings["AuthKey"];
string monitoredCollection = ConfigurationManager.AppSettings["MonitoredCollection"];
string leaseCollection = ConfigurationManager.AppSettings["LeaseCollection"];
string databaseName = ConfigurationManager.AppSettings["DatabaseName"];
string providerName = ConfigurationManager.AppSettings["ProviderName"];
// Fetch a sample customer from the database
Customer customer = LoadCustomerFromDatabase(customerId);
// Specify the unique key of the item
string key = "Customer#" + customer.Id ;
// Create dictionary for dependency parameters
IDictionary<string, string> param = new Dictionary<string, string>();
param.Add("CustomerID", customer.Id);
param.Add("EndPOint", endPoint);
param.Add("AuthKey", authKey);
param.Add("MonitoredCollection", monitoredCollection);
param.Add("LeaseCollection", leaseCollection);
param.Add("DatabaseName", databaseName);
//Creating notification dependency
CustomDependency cosmosDbDependency = new CustomDependency(providerName, param);
// Create a cacheItem
var cacheItem = new CacheItem(customer);
cacheItem.Dependency = cosmosDbDependency;
// Add cacheItem to the cache with notification dependency
cache.Insert(key, cacheItem);
Métodos
Inicializar()
Cada vez que se agrega un elemento al caché, el Initialize
Se llama al método para verificar si el caché tiene una conexión segura con la fuente de datos o no. Si este método devuelve verdadero, significa que el caché puede establecer una conexión segura con la fuente de datos. Luego coloca el elemento en el almacén de valores-clave y en la lista de dependencias del caché hasta que sea necesario eliminarlo.
Pero, en caso de que este método devuelva falso, muestra que la fuente de datos necesaria para acceder y monitorear los datos no está disponible para el caché, por lo tanto, ese elemento se elimina del caché. El método de inicialización está disponible para todas las dependencias extensibles.
DependenciaCambiada()
Después de que un elemento se coloca con éxito en el caché, es necesario saber cómo invocar la dependencia de él. Por ello, un delegado DependencyChanged
se usa Un controlador de este delegado se implementa en la memoria caché. El cliente puede controlar cuándo llamar a este delegado e invocar la dependencia de un elemento. Cada vez que se llama a este delegado, elimina el elemento contra el que se llamó de la memoria caché.
Recursos adicionales
NCache proporciona una aplicación de muestra para la dependencia extensible de notificación en GitHub.
Vea también
.NETO: Alachisoft.NCache.Dependencias.de.tiempo de ejecución espacio de nombres