NCache ist ein extrem schneller und skalierbarer verteilter Cache für .NET/.NET Core, Java-, Node.js- und Python-Anwendungen. NCache wird von hochtransaktionsfähigen .NET-Serveranwendungen für das Zwischenspeichern von Anwendungsdaten verwendet, ASP.NET / ASP.NET Core Sitzungsspeicher und Pub/Sub-Messaging.
NCache hat sich auch zu einem wirklich leistungsstarken verteilten In-Memory-Datenspeicher entwickelt, der von mehreren .NET- und Java-Anwendungen gemeinsam genutzt wird. Aus diesem Grund möchten Anwendungen immer mehr Arten von Daten speichern NCache von mehreren Anwendungen gemeinsam genutzt werden. Um diesem Bedarf gerecht zu werden, NCache stellt verteilte Datenstrukturen in Java und .NET bereit, die von mehreren Benutzern gemeinsam genutzt werden können. Sie sind:
Jede dieser Datenstrukturen wird nachstehend ausführlicher beschrieben.
Mit einer verteilten Warteschlange können Sie eine Warteschlange erstellen, die von mehreren .NET- und Java-Anwendungen gemeinsam genutzt werden kann, die in einer verteilten Umgebung ausgeführt werden. Und die Warteschlange stellt sicher, dass die Reihenfolge, in der Sie Daten eingegeben haben, beibehalten wird. Und alle Anwendungen, die Daten aus der Warteschlange abrufen, können sich darauf verlassen, dass diese Reihenfolge immer korrekt ist.
string cacheName = "demoCache";
string QueueName = "DistributedQueue:Customers";
// Initialize an instance of the cache to begin performing operations:
ICache cache = NCache.Client.CacheManager.GetCache(cacheName);
// Creating a named distributed queue
IDistributedQueue<Customer> distQueue =
cache.DataTypeManager.CreateQueue<Customer>(QueueName);
distQueue.Enqueue(new Customer {
ContactName = "David Johnes",
CompanyName = "Lonesome Pine Restaurant"
});String cacheName = "demoCache";
String queueName = "DistributedQueue:Customers";
// Initialize an instance of the cache to begin performing operations:
Cache cache = CacheManager.getCache(cacheName);
// Creating a named distributed queue
DistributedQueue<Customer> distQueue = cache.getDataStructuresManager().createQueue(queueName, Customer.class);
distQueue.add(new Customer("David Johnes", "Lonesome Pine Restaurant"));
distQueue.add(new Customer("Carlos Gonzalez", "LILA-Supermercado"));
Wie Sie oben sehen können, ermöglicht Ihnen eine Distributed Queue das Hinzufügen (Enqueue) von Elementen in einer Sequenz, sodass Sie sie später in derselben Sequenz (FIFO) entfernen (Dequeue) können. Hier ist die Schnittstelle der verteilten Warteschlange:
public interface IDistributedQueue<T> : IEnumerable<T>, IEnumerable, ICollection,
IDistributedDataTypes, ILockable, INotifiable
{
void Clear();
bool Contains(T item);
void CopyTo(T[] array, int arrayIndex);
T Dequeue();
void Enqueue(T item);
T Peek();
T[] ToArray();
}public interface DistributedQueue<T> extends Queue<T>, DistributedDataStructure, Notifiable
{
void clear();
void copyTo(T[] array, int arrayIndex);
T peek();
public interface Queue<E> extends Collection<E> {
boolean add(E e);
E remove();
}
public interface Collection<E> extends Iterable<E> {
boolean contains(Object o);
}
}Wie Sie an der oben erwähnten IDistributedQueue-Schnittstelle sehen können, stehen Ihnen alle herkömmlichen Warteschlangenfunktionen zur Verfügung.
Ein Distributed HashSet verhält sich genau wie die .NET-HashSet-Klasse, jedoch auf gemeinsame Weise für mehrere Anwendungen und Benutzer. Und ein HashSet bietet alle Set-Operationen wie:
Und da es sich um ein gemeinsam genutztes HashSet für mehrere Anwendungen oder Benutzer handelt, wird dies zu einer leistungsstarken Datenstruktur, die verwendet werden kann. Hier ist ein Beispiel für die Verwendung.
string cacheName = "demoCache";
string hashSetName = "DistributedHashSet:UniqueValueHashSet";
// Initialize an instance of the cache to begin performing operations:
ICache cache = NCache.Client.CacheManager.GetCache(cacheName);
// Creating distributed HashSet with absolute expiration
IDistributedHashSet<string> hashSet;
hashSet = cache.DataTypeManager.CreateHashSet<string>(hashSetName);
// Create data for HashSet
var daysOfWeek = new string[] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };
// Add multiple entries to the HashSet
hashSet.AddRange(daysOfWeek);
// Since this entry already exists, no change to the HashSet is made by this call
hashSet.Add("Monday");String cacheName = "demoCache";
String hashSetName = "DistributedHashSet:UniqueValueHashSet";
// Initialize an instance of the cache to begin performing operations:
Cache cache = CacheManager.getCache(cacheName);
// Creating distributed HashSet with absolute expiration
DistributedHashSet<String> hashSet;
hashSet = cache.getDataStructuresManager().createHashSet(hashSetName, String.class);
// Add entries to the hashset
hashSet.add("Monday");
hashSet.add("Tuesday");
hashSet.add("Wednesday");
hashSet.add("Thursday");
hashSet.add("Friday");
hashSet.add("Saturday");
hashSet.add("Sunday");
// Since this entry already exists, no change to the hashset is made by this call
hashSet.add("Monday");Wie Sie sehen können, wird „Montag“ beim zweiten Hinzufügen nicht zum HashSet hinzugefügt.
Ein verteiltes Wörterbuch (IDistributedDictionary) verhält sich genauso wie die reguläre .NET-IDictionary-Schnittstelle, jedoch auf eine gemeinsam genutzte Weise für mehrere Anwendungen und Benutzer. Und ein verteiltes Wörterbuch bietet alle Wörterbuchoperationen wie Hinzufügen, Aktualisieren, Entfernen, Enthält und mehr.
Zusätzlich zu den regulären Wörterbuchfunktionen bietet Distributed Dictionary die Möglichkeit, Elemente basierend auf ablaufen zu lassen NCache Ablaufoptionen wie Absoluter Ablauf und Gleitender Ablauf.
ICache cache = NCache.Client.CacheManager.GetCache("demoCache");
string dictName = "DistributedDictionary:Customers";
IDistributedDictionary<string, Customer> dict = cache.DataTypeManager.GetDictionary<string, Customer>(dictName);
if (dict == null)
{
DataTypeAttributes attributes = new DataTypeAttributes {
Expiration = new Expiration(ExpirationType.Absolute, new TimeSpan(0, 1, 0))
};
// Creating distributed Dictionary with absolute expiration of 1 minute
dict = cache.DataTypeManager.CreateDictionary<string, Customer>(dictName, attributes);
}
Customer cust = new Customer
{
CustomerID = "customer1",
ContactName = "David Johnes",
CompanyName = "Lonesome Pine Restaurant",
ContactNo = "(1) 408-354-9768",
Address = "Silicon Valley, Santa Clara, California",
};
dict.Add("customer1", cust);
Customer cachedCust;
bool fetched = dict.TryGetValue("customer1", out cachedCust);String cacheName = "demoCache";
String dictName = "DistributedDictionary:Customers";
// Initialize an instance of the cache to begin performing operations:
Cache cache = CacheManager.getCache(cacheName);
DistributedMap<string, Customer> dict = cache.getDataStructuresManager().createMap(dictName, Customer.class);
Customer customer = new Customer("David Johnes", "Lonesome Pine Restaurant", "Customer1", "(1) 408-354-9768");
dict.put("customer1", customer);
Customer cachedCustomer = dict.get("customer1");
Wie Sie sehen können, verhält sich das Distributed Dictionary genau wie ein normales .NET Distributed (IDictionary-Schnittstelle). Aber hinter den Kulissen ist es verteilt, was es sehr skalierbar macht. Und es wird auch von mehreren Anwendungen gemeinsam genutzt.
Die verteilte Liste verhält sich genauso wie die reguläre .NET-IList, jedoch mit dem Unterschied, dass sie verteilt ist und von mehreren Anwendungen und Prozessen gemeinsam genutzt werden kann. Die verteilte Liste ist eine unsortierte Liste und Sie können Elemente entweder am Ende der Liste über hinzufügen Hinzufügen () Methode oder an einem beliebigen Ort durch die Einfügung() Methode durch Bereitstellung eines Index.
Nachfolgend finden Sie ein Beispiel für die Verwendung einer verteilten Liste.
ICache cache = NCache.Client.CacheManager.GetCache("demoCache");
string listName = "DistributedList:Customers";
IDistributedList<Customer> distList = cache.DataTypeManager.GetList<Customer>(listName);
if (distList == null)
{
DataTypeAttributes attributes = new DataTypeAttributes {
Expiration = new Expiration(ExpirationType.Absolute, new TimeSpan(0, 1, 0))
};
// Creating Distributed List with absolute expiration of 1 minute
distList = cache.DataTypeManager.CreateList<Customer>(listName, attributes);
}
Customer cust = new Customer
{
CustomerID = "customer1",
ContactName = "David Johnes",
CompanyName = "Lonesome Pine Restaurant",
ContactNo = "(1) 408-354-9768",
Address = "Silicon Valley, Santa Clara, California",
};
distList.Add(cust);
Customer cachedCustomer = distList[0];String cacheName = "demoCache";
String listName = "DistributedList:Customers";
// Initialize an instance of the cache to begin performing operations:
Cache cache = CacheManager.getCache(cacheName);
DistributedList distributedList = cache.getDataStructuresManager().createList(listName, Customer.class);
Customer customer = new Customer("David Johnes", "Lonesome Pine Restaurant", "Customer1", "(1) 408-354-9768");
distributedList.add(customer);
Customer cachedCustomer = (Customer) distributedList.get(0);Sie können auch Elemente aus der Liste entfernen, darüber iterieren und viele andere Vorgänge ausführen.
Distributed Counter ist eine leistungsstarke Datenstruktur in NCache Dadurch können Sie einen eindeutigen Zähler in einer verteilten Umgebung verwalten, die von mehreren Anwendungen gemeinsam genutzt wird. Dies hat viele Einsatzmöglichkeiten und ermöglicht Ihnen die schnelle Entwicklung von Anwendungen darauf. Nachfolgend finden Sie ein Beispiel:
ICache cache = NCache.Client.CacheManager.GetCache("demoCache");
string counterName = "DistributedCounter:Customers";
ICounter counter = cache.DataTypeManager.GetCounter(counterName);
if (counter == null)
{
DataTypeAttributes attributes = new DataTypeAttributes {
Expiration = new Expiration(ExpirationType.Absolute, new TimeSpan(0, 1, 0))
};
// Creating Distributed Counter with absolute expiration to modify cache properties of the Counter, provide an instance of DataTypeAttributes in the second parameter
counter = cache.DataTypeManager.CreateCounter(counterName, attributes);
}
counter.SetValue(1000);
long newValue = counter.IncrementBy(5);
newValue = counter.Value;
newValue = counter.DecrementBy(2);String cacheName = "demoCache";
String counterName = "DistributedCounter:Customers";
// Initialize an instance of the cache to begin performing operations:
Cache cache = CacheManager.getCache(cacheName);
Counter counter = cache.getDataStructuresManager().createCounter(counterName);
counter.setValue(1000);
long newValue = counter.incrementBy(5);
newValue = counter.getValue();
newValue = counter.decrementBy(2);