Benachrichtigen Sie die Nutzung und Implementierung erweiterbarer Abhängigkeiten
Note
Diese Funktion ist nur in der verfügbar NCache Enterprise für .NET-Server.
Zusätzlich zu den Modi Massenerweiterbare Abhängigkeit, NCache bietet eine weitere Methode für Cache-Abhängigkeiten namens Notification Based Extensible Dependency oder Notify Extensible Dependency. Bei Notify Extensible Dependency ist die Clientseite für die Bereitstellung eines Anbieters verantwortlich, der die Logik hinter der Abhängigkeit enthält, und für den Zeitpunkt, an dem diese Abhängigkeit aufgerufen werden soll. Der Server ruft dann den Cache für abhängigkeitsbezogene Methoden auf und berücksichtigt dabei die vom Client bereitgestellte Logik. Der Cache prüft, ob Elemente unter „Notify Extensible Dependency“ vorhanden sind und ob diese entfernt werden müssen oder nicht.
Bei der benachrichtigungsbasierten erweiterbaren Abhängigkeit haben Clients die vollständige Kontrolle darüber, wann und wie eine Abhängigkeit für ein Element aufgerufen wird. Auf diese Weise können Elemente äußerst flexibel aus dem Cache gelöscht werden.
NCache stellt eine abstrakte Klasse bereit NotifyExtensibleDependency
, eine Erweiterung der benutzerdefinierten Abhängigkeiten, die von bereitgestellt werden NCache, das dieses Verhalten implementiert.
Tipp
Beziehen auf Benutzerdefinierte Cache-Abhängigkeiten um sich mit allen von bereitgestellten benutzerdefinierten Methoden für Cache-Abhängigkeiten vertraut zu machen NCache.
Voraussetzungen:
- Lernen Sie die Standardvoraussetzungen kennen, die für die Arbeit mit allen erforderlich sind NCache serverseitige Features entnehmen Sie bitte der angegebenen Seite Serverseitige API-Voraussetzungen.
- Das Projekt muss als Klassenbibliothek (.dll) in Visual Studio implementiert werden. Dies wird am bereitgestellt NCache Cluster.
- Stelle sicher, dass Stellen Sie benutzerdefinierte Abhängigkeitsanbieter bereit Verwendung der NCache Managementzentrum.
- Das
NotifyExtensibleDependency
Klasse muss sein im Cache bereitgestellt - Einzelheiten zur API finden Sie unter: ICache, CacheItem, Speichern, einfügen, Entfernen, Benutzerdefinierte Abhängigkeit, Abhängigkeit erstellen, ICustomDependencyProvider, NotifyExtensibleDependency, DependencyChangedHandler.
Note
Um detaillierte Informationen zu den in implementierten Methoden zu erhalten NotifyExtensibleDependency
beziehen sich auf die Methoden .
Schritt 1: Implementieren Sie die NotifyExtensibleDependency-Klasse
Der erste Schritt bei der Einführung Ihrer eigenen Logik für Notify Extensible Dependency besteht darin, die zu erben NotifyExtensibleDependency
Klasse.
Angenommen, Sie möchten Ihrer Cosmos-Datenbank Kunden mit Ihrer eigenen Abhängigkeitslogik hinzufügen. So implementieren Sie Notification Extensible Dependency mit Cosmos DB in Ihrer Anwendung.
[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
}
Schritt 2: Implementieren Sie NotifyCustomDependencyProvider
Verwenden Sie den folgenden Codeausschnitt, um den Notify Extensible Dependency-Anbieter in Ihrer Anwendung zu implementieren.
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
}
}
Schritt 3: Implementierung im Cache bereitstellen
Stellen Sie diese Klasse und alle anderen abhängigen Assemblys bereit NCache unter Bezugnahme auf Anbieter bereitstellen Hilfe finden Sie im Administratorhandbuch.
Schritt 4: Verwenden Sie die erweiterbare Abhängigkeit von Benachrichtigungen
Sobald die benachrichtigungsbasierte erweiterbare Abhängigkeit implementiert und im Cache bereitgestellt wurde, kann sie in Ihrer Anwendung verwendet werden. Der folgende Code zeigt, wie Sie Daten mithilfe von hinzufügen Insert Methode mit benachrichtigungsbasierter benutzerdefinierter Abhängigkeit.
Note
Im Falle eines Client-Cache muss der Benutzer diese Assemblys explizit im Client-Cache bereitstellen.
// 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);
Methoden
Initialisieren()
Jedes Mal, wenn ein Element zum Cache hinzugefügt wird, wird die Initialize
Die Methode wird aufgerufen, um zu prüfen, ob der Cache eine sichere Verbindung mit der Datenquelle hat oder nicht. Wenn diese Methode „true“ zurückgibt, bedeutet dies, dass der Cache eine sichere Verbindung mit der Datenquelle herstellen kann. Anschließend wird das Element im Schlüsselwertspeicher und in der Abhängigkeitsliste des Caches abgelegt, bis es entfernt werden muss.
Wenn diese Methode jedoch „false“ zurückgibt, zeigt dies, dass die für den Zugriff auf und die Überwachung von Daten erforderliche Datenquelle nicht für den Cache verfügbar ist. Daher wird das Element aus dem Cache entfernt. Die Initialisierungsmethode ist für alle erweiterbaren Abhängigkeiten verfügbar.
DependencyChanged()
Nachdem ein Element erfolgreich im Cache abgelegt wurde, muss man wissen, wie man eine Abhängigkeit davon aufruft. Aus diesem Grund ein Delegierter DependencyChanged
wird eingesetzt. Ein Handler dieses Delegaten wird im Cache bereitgestellt. Der Client kann steuern, wann dieser Delegat aufgerufen und die Abhängigkeit von einem Element aufgerufen wird. Immer wenn dieser Delegat aufgerufen wird, entfernt er das Element, für das er aufgerufen wurde, aus dem Cache.
Weitere Informationen
NCache stellt eine Beispielanwendung für Notification Extensible Dependency on bereit GitHub.
Siehe auch
.NETZ: Alachisoft.NCache.Laufzeitabhängigkeiten Namespace.