Notify Extensible Database Dependency Usage and Implementation
Oltre Dipendenza estensibile di massa, NCache provides another method for cache dependency called Notification Based Extensible Dependency or Notify Extensible Database Dependency. In Notify Extensible Database Dependency, the client side is responsible for deploying a provider that holds the logic behind the dependency and when to invoke that dependency.
Note:
Questa funzione è disponibile solo in NCache Enterprise per Server .NET.
The server then invokes the cache for database dependency-related methods considering the logic provided by the client. The cache checks for items under Notify Extensible Dependency and whether they need to be removed or not.
Nella dipendenza estensibile basata su notifiche, i client hanno tutto il controllo su quando e come chiamare una dipendenza su un elemento. In questo modo è possibile far scadere gli elementi dalla cache in modo estremamente flessibile.
NCache fornisce una classe astratta NotifyExtensibleDependency
, un'estensione delle dipendenze personalizzate fornita da NCache, che implementa questo comportamento.
Consiglio
Fare riferimento a Dipendenze cache personalizzate per familiarizzare con tutti i metodi personalizzati di dipendenza della cache forniti da NCache.
Prerequisiti
- Per conoscere i prerequisiti standard richiesti per lavorare con all NCache caratteristiche lato server si prega di fare riferimento alla pagina indicata su Prerequisiti API lato server.
- Il progetto deve essere implementato come libreria di classi (.dll) in Visual Studio. Questo sarà distribuito NCache grappolo.
- Assicurati che Distribuire provider di dipendenze personalizzate usando il NCache Centro Direzionale.
- I
NotifyExtensibleDependency
la classe deve essere distribuito su cache - Per i dettagli dell'API fare riferimento a: ICache, CacheItem, Aggiungi, insert, Rimuovere, Dipendenza personalizzata, Crea dipendenza, ICustomDependencyProvider, NotificaExtensibleDependency, DependencyChangedHandler.
Note:
Per ottenere informazioni dettagliate sui metodi implementati in NotifyExtensibleDependency
, fare riferimento a Metodi .
Passaggio 1: implementare la classe NotifyExtensibleDependency
Il primo passaggio per introdurre la propria logica per Notify Extensible Dependency consiste nell'ereditare il file NotifyExtensibleDependency
classe.
Supponiamo che tu voglia aggiungere clienti al tuo database Cosmos con la tua logica di dipendenza. Ecco come implementare Notification Extensible Dependency con Cosmos DB nell'applicazione.
[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
}
Passaggio 2: implementare NotifyCustomDependencyProvider
Per implementare il provider Notify Extensible Dependency nella tua applicazione, usa il seguente frammento di codice.
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
}
}
Passaggio 3: distribuire l'implementazione nella cache
Distribuire questa classe e tutti gli altri assembly dipendenti su NCache facendo riferimento a Distribuire fornitori nella Guida dell'amministratore per assistenza.
Passaggio 4: utilizzare la dipendenza estensibile di notifica
Una volta implementata e distribuita nella cache, la dipendenza estensibile basata su notifiche è pronta per essere utilizzata nell'applicazione. Il codice seguente mostra come aggiungere dati utilizzando il file inserire metodo con dipendenza personalizzata basata su notifica.
Note:
In caso di cache del client, l'utente deve distribuire in modo esplicito questi assembly nella cache del client.
// 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);
Metodi
Inizializzare()
Ogni volta che un elemento viene aggiunto alla cache, il file Initialize
viene chiamato per verificare se la cache ha una connessione sicura con l'origine dati o meno. Se questo metodo restituisce true, significa che la cache può stabilire una connessione sicura con l'origine dati. Quindi inserisce l'elemento nell'archivio valori-chiave e nell'elenco delle dipendenze della cache finché non deve essere rimosso.
Tuttavia, nel caso in cui questo metodo restituisca false, mostra che l'origine dati richiesta per accedere e monitorare i dati non è disponibile nella cache e pertanto l'elemento viene rimosso dalla cache. Il metodo di inizializzazione è disponibile per tutte le dipendenze estendibili.
Dipendenza modificata()
Dopo che un elemento è stato posizionato correttamente nella cache, è necessario sapere come invocare la dipendenza da esso. Per questo un delegato DependencyChanged
si usa. Un gestore di questo delegato viene distribuito nella cache. Il client può controllare quando chiamare questo delegato e richiamare la dipendenza da un elemento. Ogni volta che questo delegato viene chiamato, rimuove dalla cache l'elemento rispetto al quale è stato chiamato.
Risorse addizionali
NCache fornisce un'applicazione di esempio per Notification Extensible Dependency on GitHub.
Vedere anche
.NETTO: Alachisoft.NCache.Dipendenze.di.runtime spazio dei nomi.