NCache est un cache distribué extrêmement rapide et évolutif pour .NET/.NET Core, Java, Node.js et Python. NCache est utilisé par les applications serveur .NET à transaction élevée pour la mise en cache des données d'application, ASP.NET / ASP.NET Core stockage de session et messagerie Pub/Sub.
NCache est également devenu une banque de données distribuée en mémoire très puissante, partagée entre plusieurs applications .NET et Java. En conséquence, les applications souhaitent stocker de plus en plus de types de données dans NCache à partager entre plusieurs applications. Pour répondre à ce besoin, NCache fournit des structures de données distribuées en Java et .NET à partager entre plusieurs utilisateurs. Ils sont:
Chacune de ces structures de données est décrite plus en détail ci-dessous.
Une file d'attente distribuée vous permet de créer une file d'attente à partager entre plusieurs applications .NET et Java exécutées dans un environnement distribué. Et la file d'attente garantit que l'ordre dans lequel vous y avez saisi les données est conservé. Et toutes les applications récupérant des données de la file d’attente peuvent compter sur cette séquence pour être toujours correcte.
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"));
Comme vous pouvez le voir ci-dessus, une file d'attente distribuée vous permet d'ajouter (Mettre en file d'attente) des éléments dans une séquence afin que vous puissiez les supprimer ultérieurement (Dequeue) dans la même séquence (FIFO). Voici l'interface de la file d'attente distribuée :
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);
}
}Comme vous pouvez le voir dans l'interface IDistributedQueue mentionnée ci-dessus, elle vous offre toutes les fonctionnalités de file d'attente traditionnelles.
Un HashSet distribué se comporte comme la classe .NET HashSet mais de manière partagée pour plusieurs applications et utilisateurs. Et, un HashSet fournit toutes les opérations Set comme :
Et, étant un HashSet partagé pour plusieurs applications ou utilisateurs, cela devient une structure de données puissante à utiliser. Voici un exemple d'utilisation.
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");Comme vous pouvez le voir, lorsque vous ajoutez "Monday" la deuxième fois, il n'est pas ajouté au HashSet.
Un dictionnaire distribué (IDistributedDictionary) se comporte comme l'interface IDictionary .NET standard, mais de manière partagée pour plusieurs applications et utilisateurs. De plus, un dictionnaire distribué fournit toutes les opérations de dictionnaire telles que Ajouter, Mettre à jour, Supprimer, Contient, etc.
En plus des fonctionnalités habituelles du dictionnaire, Distributed Dictionary offre la possibilité d'expirer des éléments en fonction de NCache options d'expiration comme Expiration absolue ainsi que Expiration glissante.
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");
Comme vous pouvez le voir, le dictionnaire distribué se comporte comme un .NET distribué classique (interface IDictionary). Mais, en coulisses, il est distribué, ce qui le rend très évolutif. Et il est également partagé entre plusieurs applications.
La liste distribuée se comporte comme la liste .NET IList classique, mais à la différence qu'elle est distribuée et peut être partagée entre plusieurs applications et processus. La liste distribuée est une liste non triée et vous pouvez ajouter des éléments soit à la fin de la liste via le Ajouter () méthode ou à tout endroit via le Insérer () méthode en fournissant un index.
Vous trouverez ci-dessous un exemple d'utilisation d'une liste distribuée.
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);Vous pouvez également supprimer des éléments de la liste, parcourir celle-ci et effectuer de nombreuses autres opérations.
Distributed Counter est une structure de données puissante dans NCache qui vous permet de maintenir un compteur unique dans un environnement distribué partagé par plusieurs applications. Cela a de nombreuses utilisations et vous permet de développer rapidement des applications autour de cela. Ci-dessous un exemple :
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);