Gegenverhalten und Nutzung im Cache
Ein Zähler ist eine einzelne Datenstruktur mit langen Werten, die im Cache gespeichert ist. Sie können es inkrementieren, dekrementieren, sperren und Ereignisse dafür registrieren lassen. Beispielsweise kann ein Zähler verwendet werden, um die Aufrufe jedes Mal zu speichern, wenn ein Video auf einer Social-Media-Site angesehen wird. Es kann auch verwendet werden, um Abonnements für eine Website zu speichern, auf der sich Personen anmelden oder abmelden können.
NCache Verbessert diesen Zähler weiter durch die Bereitstellung NCache-Spezifische Funktionen wie z Groups, Schlüsselwörter, Ablauf, Sperrung, Abhängigkeiten, und mehr. Sie können beispielsweise einen Zähler für die Gruppe angeben Abonnementdetails die sowohl Kundenobjekte als auch den Abonnementzähler enthalten kann.
Verhalten
- Null ist kein unterstützter Werttyp.
- Zähler werden benannt. Daher müssen Sie einen eindeutigen Cache-Schlüssel für einen Zähler bereitstellen.
Voraussetzungen:
- Lernen Sie die Standardvoraussetzungen kennen, die für die Arbeit mit allen erforderlich sind NCache Weitere Informationen zu clientseitigen Funktionen finden Sie auf der angegebenen Seite Clientseitige API-Voraussetzungen.
- Einzelheiten zur API finden Sie unter: ICache, IZähler, IDataTypeManager, Zähler erstellen, SetValue, Inkrementieren, Inkrementieren um, Dekrement, Dekrementieren um, GetCounter, ICollectionManager, Registrierungsbenachrichtigung, DataTypeDataNotificationCallback, Ereignistyp, DataTypeEventDataFilter, Zahnscheiben, öffne es.
- Lernen Sie die Standardvoraussetzungen kennen, die für die Arbeit mit allen erforderlich sind NCache Weitere Informationen zu clientseitigen Funktionen finden Sie auf der angegebenen Seite Clientseitige API-Voraussetzungen.
- Einzelheiten zur API finden Sie unter: Cache-Speicher, Counter, getDataStructuresManager, unterstützt, getCounter, setValue, Zuwachs, Incrementby, Dekrement, dekrementierenBy, Ereignistyp, GetEventType, DataStructureDataChangeListener, onDataStructureChanged, DataStructureEventArg, DataTypeEventDataFilter, getCollectionItem, sperren, öffnen.
- Lernen Sie die Standardvoraussetzungen kennen, die für die Arbeit mit allen erforderlich sind NCache Weitere Informationen zu clientseitigen Funktionen finden Sie auf der angegebenen Seite Clientseitige API-Voraussetzungen.
- Einzelheiten zur API finden Sie unter: Cache-Speicher, Counter, DataStructureManager, getDataStructuresManager, unterstützt, getCounter, setValue, Zuwachs, Incrementby, Dekrement, dekrementierenBy, Ereignistyp , DataStructureDataChangeListener, Addchangelistener, DataTypeEventDataFilter, DataStructureEventArg, GetEventType, getCollectionItem.
- Lernen Sie die Standardvoraussetzungen kennen, die für die Arbeit mit allen erforderlich sind NCache Weitere Informationen zu clientseitigen Funktionen finden Sie auf der angegebenen Seite Clientseitige API-Voraussetzungen.
- Einzelheiten zur API finden Sie unter: Cache-Speicher, Counter, DataStructureManager, get_data_structures_manager, create_counter, get_counter, Zuwachs, get_event_type, DataTypeEventDataFilter, Ereignisdatenfilter.
Zähler erstellen
Das folgende Codebeispiel zeigt, wie mithilfe von ein Zähler im Cache erstellt werden kann CreateCounter
gegen den Cache-Schlüssel Abonnementzähler.
// Precondition: Cache must be connected
// Specify unique cache key for counter
string key = "SubscriptionCounter";
// Set initial value of counter
long initialValue = 15;
// Create counter
ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue);
// Precondition: Cache must be connected
// Specify unique cache key for counter
String key = "SubscriptionCounter";
// Set initial value of counter
long initialValue = 15;
// Create counter
Counter counter = cache.getDataStructuresManager().createCounter(key, initialValue);
// This is an async method
// Precondition: Cache must be connected
// Specify unique cache key for counter
var key = "SubscriptionCounter";
// Set initial value of counter
var initialValue = 15;
// Create counter
var manager = await this.cache.getDataStructuresManager();
var counter = await manager.createCounter(key, initialValue);
# Precondition: Cache must be connected
# Specify unique cache key for counter
key = "SubscriptionCounter"
# Set initial value of counter
initial_value = 15
# Create counter
manager = cache.get_data_structures_manager()
counter = manager.create_counter(key, initial_value)
Rufen Sie den Wert des Zählers ab und aktualisieren Sie ihn
Sie können den Wert eines Zählers nach seiner Erstellung aktualisieren. Das folgende Codebeispiel ruft mithilfe von einen Zähler aus dem Cache ab GetCounter
und setzt seinen Wert mit auf einen anderen Wert SetValue
. Anschließend erhöht es seinen Wert um Increment
or IncrementBy
und dekrementiert seinen Wert mit Decrement
or DecrementBy
.
// Unique key for counter
string key = "SubscriptionCounter";
// Get counter against key
ICounter retrievedCounter = cache.DataTypeManager.GetCounter(key);
// Set value of counter to 100
retrievedCounter.SetValue(100);
// Increment value
long newValue = retrievedCounter.Increment();
// Decrement value
newValue = retrievedCounter.Decrement();
// Increment value by number of 10
newValue = retrievedCounter.IncrementBy(10);
// Decrement value by number of 5
newValue = retrievedCounter.DecrementBy(5);
// Precondition: Cache is already connected
// Unique key for counter
String key = "SubscriptionCounter";
// Get counter against key
Counter retrievedCounter = cache.getDataStructuresManager().getCounter(key);
// Set Value of counter to 100
retrievedCounter.setValue(100);
// Increment value
long newValue = retrievedCounter.increment();
// Decrement value
newValue = retrievedCounter.decrement();
// Increment value by number of 10
newValue = retrievedCounter.incrementBy(10);
// Decrement value by number of 5
newValue = retrievedCounter.decrementBy(5);
// This is an async method
// Precondition: Cache is already connected
// Unique key for counter
var key = "SubscriptionCounter";
// Get counter against key
var manager = await this.cache.getDataStructuresManager();
var retrievedCounter = await manager.getCounter(key);
// Set Value of counter to 100
retrievedCounter.setValue(100);
// Increment value
var newValue = retrievedCounter.increment();
// Decrement value
newValue = retrievedCounter.decrement();
// Increment value by number of 10
newValue = retrievedCounter.incrementBy(10);
// Decrement value by number of 5
newValue = retrievedCounter.decrementBy(5);
# Precondition: Cache is already connected
# Unique key for counter
key = "SubscriptionCounter"
# Get counter against key
manager = cache.get_data_structures_manager()
retrieved_counter = manager.get_counter(key)
# Increment value of retrievedCounter on new subscription
retrieved_counter.increment()
Note
Um sicherzustellen, dass der Vorgang ausfallsicher ist, wird empfohlen, alle potenziellen Ausnahmen in Ihrer Anwendung zu behandeln, wie in erläutert Umgang mit Fehlern.
Ereignisbenachrichtigungen auf Zählern
Sie können Cache-Ereignisse, schlüsselbasierte Ereignisse und Datenstrukturereignisse in einer Datenstruktur wie einem Zähler registrieren. Informationen zum Verhalten finden Sie unter merkmalsorientiertes Verhalten.
Das folgende Codebeispiel registriert ein Cache-Ereignis von ItemAdded
und ItemUpdated
sowie eine Veranstaltung für registrieren ItemAdded
und ItemUpdated
auf dem Tresen im Cache. Sobald ein Zähler im Cache erstellt wurde, wird ein ItemAdded
Ein Ereignis auf Cache-Ebene wird ausgelöst. Sobald jedoch ein Artikel zum Zähler hinzugefügt wird, wird ein ItemAdded
Das Datenstrukturereignis wird ausgelöst und ein ItemUpdated
Das Ereignis auf Cache-Ebene wird ausgelöst.
Ereignis auf Zähler erstellen registrieren
// Unique cache key for counter
string key = "SubscriptionCounter";
// Set initial value of counter
long initialValue = 15;
// Create counter
ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue);
// Register ItemAdded, ItemUpdated, ItemRemoved events on counter created
// DataTypeNotificationCallback is callback method specified
counter.RegisterNotification(DataTypeDataNotificationCallback, EventType.ItemAdded |
EventType.ItemUpdated | EventType.ItemRemoved,
DataTypeEventDataFilter.Data);
// Perform operations
// Precondition: Cache is already connected
// Unique cache key for counter
String key = "SubscriptionCounter";
// Set initial value of counter
long initialValue = 15;
// Create counter
Counter counter = cache.getDataStructuresManager().createCounter(key, initialValue);
// Create EnumSet of event types
EnumSet<EventType> enumSet = EnumSet.of(com.alachisoft.ncache.runtime.events.EventType.ItemAdded,
EventType.ItemUpdated, EventType.ItemRemoved);
// Register ItemAdded, ItemUpdated, ItemRemoved events on queue created
// dataChangeListener is the specified callback method
DataStructureDataChangeListener dataChangeListener = dataStructureListener.onDataStructureChanged(collectionName, args);
counter.addChangeListener(dataChangeListener, enumSet, DataTypeEventDataFilter.Data);
// Perform operations
// This is an async method
// Precondition: Cache is already connected
// Unique cache key for counter
var key = "SubscriptionCounter";
// Set initial value of counter
var initialValue = 15;
// Create counter
var counter = await this.cache.getDataStructuresManager().createCounter(key, initialValue);
// Create EnumSet of event types
var enumSet = enumSet.of(
ncache.EventType.ItemAdded,
ncache.EventType.ItemUpdated,
ncache.EventType.ItemRemoved
);
// Register ItemAdded, ItemUpdated, ItemRemoved events on queue created
// dataChangeListener is the specified callback method
var dataChangeListener = dataStructureListener.onDataStructureChanged(
collectionName,
args
);
counter.addChangeListener(
dataChangeListener,
enumSet,
ncache.DataTypeEventDataFilter.Data
);
// Perform operations
def datastructure_callback_function(collection_name, collection_event_args):
# Perform Operations
print("Event Fired for " + str(collection_name))
# Precondition: Cache is already connected
# Unique cache key for counter
key = "SubscriptionCounter"
# Set initial value of counter
initial_value = 15
# Create counter
counter = cache.get_data_structures_manager().create_counter(key, initial_value)
# Register ItemAdded, ItemUpdated, ItemRemoved events on hashset created
events_list = [ncache.EventType.ITEM_ADDED, ncache.EventType.ITEM_UPDATED, ncache.EventType.ITEM_REMOVED]
counter.add_change_listener(datastructure_callback_function, events_list, ncache.DataTypeEventDataFilter.DATA)
# Perform operations
Geben Sie einen Rückruf für die Ereignisbenachrichtigung an
private void DataTypeDataNotificationCallback(string collectionName, DataTypeEventArg collectionEventArgs)
{
switch (collectionEventArgs.EventType)
{
case EventType.ItemAdded:
// Item has been added to the collection
break;
case EventType.ItemUpdated:
if (collectionEventArgs.CollectionItem != null)
{
// Item has been updated in the collection
// Perform operations
}
break;
case EventType.ItemRemoved:
// Item has been removed from the collection
break;
}
}
DataStructureDataChangeListener dataStructureListener = new DataStructureDataChangeListener() {
@Override
public void onDataStructureChanged(String collection, DataStructureEventArg dataStructureEventArg) {
switch (dataStructureEventArg.getEventType()) {
case ItemAdded:
// Item has been added to the collection
break;
case ItemUpdated:
if (dataStructureEventArg.getCollectionItem() != null) {
//Item has been updated in the collection
// perform operations
}
break;
case ItemRemoved:
//Item has been removed from the collection
break;
}
}
};
dataStructureListener = new ncache.DataStructureDataChangeListener();
{
function onDataStructureChanged(collection, dataStructureEventArg) {
switch (dataStructureEventArg.getEventType()) {
case ncache.EventType.ItemAdded:
//Item has been added to the collection
break;
case ncache.EventType.ItemUpdated:
if (dataStructureEventArg.getCollectionItem() != null) {
//Item has been updated in the collection
// perform operations
}
break;
case ncache.EventType.ItemRemoved:
//Item has been removed from the collection
break;
}
}
}
def datastructure_callback_function(collection_name: str, collection_event_args: DataStructureEventArg):
if collection_event_args.get_event_type() is ncache.EventType.ITEM_ADDED:
# Item has been added to the collection
print("Item added in " + collection_name)
elif collection_event_args.get_event_type() is ncache.EventType.ITEM_UPDATED:
# Item has been updated in the collection
print("Item updated in " + collection_name)
elif collection_event_args.get_event_type() is ncache.EventType.ITEM_REMOVED:
# Item has been removed from the collection
print("Item removed from " + collection_name)
Sperrzähler
Zähler können explizit gesperrt und entsperrt werden, um die Datenkonsistenz sicherzustellen. Das folgende Codebeispiel erstellt einen Zähler und sperrt ihn für einen Zeitraum von 10 Sekunden mit Zahnscheiben und entsperrt es dann mit öffne es.
// Counter exists with key "SubscriptionCounter"
// Cache Key
string key = "SubscriptionCounter";
// Get counter against key
ICounter counter = cache.DataTypeManager.GetCounter(key);
// Lock counter for 10 seconds
bool isLocked = counter.Lock(TimeSpan.FromSeconds(10));
if (isLocked)
{
// Counter is successfully locked for 10 seconds
// Unless explicitly unlocked
}
else
{
// Counter is not locked because either:
// Counter is not present in the cache
// Counter is already locked
}
counter.Unlock();
// Preconditions: Cache is already connected
// Counter exists with key "SubscriptionCounter"
// Cache Key
String key = "SubscriptionCounter";
// Get counter against key
Counter counter = cache.getDataStructuresManager().getCounter(key);
// Lock counter for 10 seconds
boolean isLocked = counter.lock(TimeSpan.FromSeconds(10));
if (isLocked) {
// Counter is successfully locked for 10 seconds
// Unless explicitly unlocked
} else {
// Counter is not locked because either:
// Counter is not present in the cache
// Counter is already locked
}
counter.unlock();
Weitere Informationen
NCache stellt eine Beispielanwendung für die Zählerdatenstruktur bereit GitHub.
Siehe auch
.NETZ: Alachisoft.NCache.Client.Datentypen Namespace.
Java: com.alachisoft.ncache.client.Datenstrukturen Namespace.
Node.js: Counter Klasse.
Python: ncache.client.Datenstrukturen Klasse.