Massenerweiterbare Datenbankabhängigkeitsnutzung und -implementierung
In Extensible Dependency benötigt jede Abhängigkeit Zeit, um Änderungen festzustellen, die zu einer Ablaufverzögerung führen können. Mit der Zunahme der Anzahl benutzerdefinierter Abhängigkeiten nimmt der Ablauf jedes Elements Zeit in Anspruch, weshalb einige Elemente lange nach ihrem Ablauf im Cache verbleiben.
Note
Diese Funktion ist nur in der verfügbar NCache Enterprise für .NET-Server.
Um diesem Problem entgegenzuwirken, NCache stellt eine weitere Klasse mit dem Namen bereit BulkExtensibleDependency
, wobei eine Vielzahl benutzerdefinierter Abhängigkeiten und Datenbankabhängigkeiten gleichzeitig ausgewertet werden. Dies trägt dazu bei, die Leistung der Anwendung zu steigern, da abgelaufene Elemente rechtzeitig aus dem Cache entfernt werden.
BulkExtensibleDependency
wird zur Laufzeit bereitgestellt, über die der Benutzer Daten und Datenbankabhängigkeiten in großen Mengen auswerten und aufrufen kann Expire()
auf den Abhängigkeiten, die aus dem Cache entfernt werden müssen.
Wichtig
Wenn Ihre Geschäftsanforderung eine Methode ist, bei der ein Artikel einzeln und nicht in großen Mengen bewertet werden muss, dann verwenden Sie diese ExtensibleDependency
. Andernfalls treten Leistungsprobleme auf.
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 zum Konfigurieren der Abhängigkeit einer massenhaft erweiterbaren Datenbank
- 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 auf der bereitgestellt NCache Cluster.
- Das
BulkExtensibleDependency
Klasse muss sein im Cache bereitgestellt. - Einzelheiten zur API finden Sie unter: ICache, CacheItem, Speichern, einfügen, ExecuteReader, Benutzerdefinierte Abhängigkeit, BulkExtensibleDependency, Bulk auswerten, Abhängigkeit erstellen, IList, ICustomDependencyProvider.
Schritt 1: Implementieren Sie die BulkExtensibleDependency-Klasse
Der erste Schritt bei der Einführung Ihrer eigenen Logik für die Bulk Extensible Database Dependency besteht darin, die zu erben BulkExtensibleDependency
Klasse.
Die folgende Klasse implementiert Ihre benutzerdefinierte Logik, um mithilfe von Bulk Extensible Dependency mehrere Elemente gleichzeitig zu entfernen.
[Serializable]
public class BulkDependency : BulkExtensibleDependency
{
// Class parameters
public BulkDependency(string connString, int ProductId)
{
connection = DriverManager.GetConnection(connString);
connection.open();
productID = ProductId;
}
private Dictionary<int,int> UnitsInStockStatus(List<int> productIds)
{
String queryString = "your_query_here";
Dictionary<int, int> productsInfo = new Dictionary<int, int>();
using (var cmd = new SqlCommand(queryString, connection))
{
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
int units = 0;
Int32.TryParse(reader["UnitsInStock"].ToString(), out units);
productsInfo.Add((int)reader.GetValue(0), units);
}
}
}
return productsInfo;
}
}
public override void EvaluateBulk(IEnumerable<BulkExtensibleDependency> dependencies)
{
List<BulkDependency> dependencyList = new List<BulkDependency>();
foreach (BulkDependency bulkDependency in dependencies)
{
dependencyList.Add(bulkDependency);
}
List<int> productIds = GetOutofStockProducts(dependencyList);
var productsInfo = UnitsInStockStatus(productIds);
foreach (BulkDependency bulkDependency in dependencyList)
{
if (productsInfo.ContainsKey(bulkDependency.productId))
{
if (productsInfo[bulkDependency.productId] != bulkDependency.unitsInStock)
{
bulkDependency.Expire();
}
}
}
}
private List<int> GetOutofStockProducts()
{
List<int> productIds = new List<int>();
foreach(BulkDependency bulkDependency in dependencies)
{
productIds.Add(bulkDependency.productId);
}
}
return productIds;
}
private Dispose()
{
// Dispose off all resources
}
// This class is to be deployed on NCache
}
Wichtig
Verwenden Sie keine this.Expire()
um ein Objekt ablaufen zu lassen, das nicht mehr gültig ist. Rufen Sie stattdessen an .Expire()
Methode auf der Instanz der Abhängigkeit, die abgelaufen sein muss, z myDep.Expire()
Schritt 2: Implementieren Sie BulkCustomDependencyProvider
Um einen Bulk Extensible Database Dependency-Anbieter in Ihrer Anwendung zu implementieren, verwenden Sie den folgenden Codeausschnitt.
Ein benutzerdefinierter Abhängigkeitsanbieter für erweiterbare Massenabhängigkeiten implementiert die Logik, die Sie in Schritt 1 erstellt haben, auf der Serverseite. So können Sie Ihren eigenen Anbieter implementieren:
public class BulkCustomDependencyProvider : ICustomDependencyProvider
{
public void Init(IDictionary<string, string> parameters, string cacheName)
{
// Initialize cache and class parameters
}
public BulkDependency CreateDependency(string key, IDictionary<string, string> dependencyParameters)
{
int productId = 0;
int units = 0;
string connectionString = "";
if (dependencyParameters != null)
{
if (dependencyParameters.ContainsKey("ProductID"))
productId = Int32.Parse(dependencyParameters["ProductID"]);
if (dependencyParameters.ContainsKey("UnitsAvailable"))
units = Int32.Parse(dependencyParameters["UnitsAvailable"]);
if (dependencyParameters.ContainsKey("ConnectionString"))
connectionString = dependencyParameters["ConnectionString"];
// Create bulk extensible dependency
BulkDependency dependency = new BulkDependency(connectionString, productId, units);
return dependency;
}
}
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 Massenabhängigkeit
Sobald die Bulk Extensible Dependency-Klasse implementiert und bereitgestellt wurde, kann sie in Ihrer Anwendung verwendet werden.
Der folgende Code zeigt, wie Sie mit dem Daten zum Cache hinzufügen Einfügung() mit Massenabhängigkeit.
// Specify the connection string
string connectionString = ConfigurationManager.AppSettings["connectionstring"];
// Fetch the product to be added to the cache
Product product = FetchProductFromDB(productId);
// Specify the unique key of the item
string key = $"Product:{product.ProductID}";
// Create a cacheItem
var cacheItem = new CacheItem(product);
// Create dictionary for dependency parameters
IDictionary<string, string> param = new Dictionary<string, string>();
param.Add("ProductID", products.Id.ToString());
param.Add("ConnectionString", _connectionString);
// Create Bulk Extensible Dependency using Provider and Add it to Cache Item
CustomDependency customDependency = new CustomDependency(ConfigurationManager.AppSettings["ProviderName"], param);
cacheItem.Dependency = customDependency;
// Add cacheItem to the cache with bulk dependency
cache.Insert(key, cacheItem);
Weitere Informationen
NCache stellt eine Beispielanwendung für Bulk Extensible Dependency bereit GitHub.
Siehe auch
.NETZ: Alachisoft.NCache.Laufzeitabhängigkeiten Namespace.