NCache est un cache distribué extrêmement rapide et évolutif pour .NET, Java, Node.js et Python applications. NCache est utilisé par les applications serveur .NET à transactions élevées pour la mise en cache des données d'application, ASP.NET / ASP.NET Core stockage de session, et Messagerie Pub/Sub.
NCache offre Structures de données distribuées qui peuvent être partagées entre plusieurs utilisateurs. Contrairement aux structures locales résidant dans le tas de l'application cliente, ces structures sont hébergées dans le cluster de cache distribué, ce qui réduit la pression sur la mémoire locale et la charge du ramasse-miettes. Elles comprennent :
| Fonctionnalité | Collections en cours de traitement standard | NCache Structures distribuées |
|---|---|---|
| Domaine | Lié aux processus (Tas local) | Ressource réseau partagée à l'échelle du cluster |
| Cycle de vie | Perdu lors du redémarrage/recyclage de l'application | Indépendamment du cycle de vie de l'application |
| Disponibilité | Point de défaillance unique (le processus) | Haute disponibilité (via des topologies de partitionnement/réplication) |
| Cohérence | Sécurité des threads uniquement au sein d'un seul processus | Cohérence garantie sur plusieurs serveurs |
Les sections suivantes fournissent des détails et des exemples de code pour les applications .NET et Java.
A File d'attente distribuée met en œuvre le IDistributedQueue<T> Cette interface permet de créer une file d'attente partagée entre plusieurs applications .NET et Java exécutées dans un environnement distribué. La file d'attente garantit le maintien de l'ordre d'entrée des données. Toutes les applications récupérant des données de cette file d'attente peuvent ainsi se fier à l'exactitude de cet ordre.
string cacheName = "demoCache";
string QueueName = "DistributedQueue:Customers";
// Initialize an instance of the cache to begin performing operations
ICache cache = CacheManager.GetCache(cacheName);
// Create a thread-safe distributed queue visible to all cluster nodes
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);
// Create a thread-safe distributed queue visible to all cluster nodes
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();
IList<T> DequeueBulk(int maxitems = 10);
void Enqueue(T item);
void EnqueueBulk(IList<T> items);
T Peek();
T[] ToArray();
}public interface DistributedQueue<T> extends Queue<T>, DistributedDataStructure, Notifiable {
void clear();
void copyTo(T[] var1, int var2);
T peek();
Object[] toArray();
}A Ensemble de hachage distribué Se comporte comme la classe .NET HashSet, mais de manière partagée par plusieurs applications et utilisateurs. Elle fournit toutes les opérations Set, telles que :
Étant un HashSet partagé par plusieurs applications ou utilisateurs, il constitue une structure de données puissante. Voici un exemple d'utilisation.
string cacheName = "demoCache";
string hashSetName = "DistributedHashSet:UniqueValueHashSet";
// Initialize an instance of the cache to begin performing operations:
ICache cache = CacheManager.GetCache(cacheName);
// Creating a 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 a 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 « lundi » la deuxième fois, il n’est pas ajouté au HashSet.
A Dictionnaire distribué L'interface IDistributedDictionary remplace avantageusement l'interface IDictionary standard de .NET, mais de manière partagée entre plusieurs applications et utilisateurs. Elle offre toutes les opérations de dictionnaire, telles que l'ajout, la mise à jour, la suppression, la vérification du contenu, 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 et Expiration glissante.
ICache cache = 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 a distributed Dictionary with an 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");Liste distribuée met pleinement en œuvre le System.Collections.Generic.IList<T> L'interface permet à cette liste de remplacer avantageusement les listes standard. Sa principale différence réside dans sa nature distribuée, ce qui lui permet d'être partagée entre plusieurs applications et processus. Une liste distribuée est une liste non triée, et vous pouvez y ajouter des éléments, soit à la fin, soit via l'interface. 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 = 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.
Compteur distribué 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 = 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);IDictionary<K,V> et IList<T>Vous pouvez utiliser des méthodes standard (comme Ajouter, Supprimer, Contient) et remplacez simplement l'initialisation de l'objet pour utiliser le NCache manipuler.© Copyright Alachisoft 2002 - . Tous droits réservés. NCache est une marque déposée de Diyatech Corp.