Comportement et utilisation du dictionnaire dans le cache

NCache Un dictionnaire distribué est une structure de données distribuée et non ordonnée permettant de stocker des paires clé-valeur au sein d'un cluster. Il est idéal pour des recherches rapides par clé. Il prend en charge le cache et les événements au niveau des éléments. NCache améliore encore le type de données du dictionnaire en fournissant NCache-des fonctionnalités spécifiques telles que Groupes, Tags, Expiration, Verrouillable, Dépendanceset plus encore.

Également appelé hachage, table de hachage ou HashMap, un NCache Un dictionnaire est une structure de données générique permettant de stocker un groupe d'objets. Il associe des clés de type chaîne de caractères à des valeurs. Par exemple, un dictionnaire peut servir à stocker les informations de tous les produits d'un supermarché en fonction de leur catégorie. ID de produit comme clé d'entrée du dictionnaire.

Note

En Java, une Map correspond à un Dictionary en .NET.

NCache Comportement du dictionnaire distribué

  • Une valeur de dictionnaire peut être de n'importe quel type primitif ou objet personnalisé.
  • Un dictionnaire de CacheItem et les dictionnaires imbriqués ne sont pas encore pris en charge.
  • Les dictionnaires sont nommés. Par conséquent, vous devez fournir une clé de cache unique pour chaque dictionnaire.
  • Une clé de dictionnaire ne peut être que de type chaîne.
  • Les clés de dictionnaire en double ne sont pas autorisées.

Pré-requis :

Avant d'utiliser le NCache Pour les API côté client, assurez-vous que les conditions préalables suivantes sont remplies :

Comment créer un dictionnaire et y ajouter des données

L'exemple de code suivant montre comment un dictionnaire est créé dans le cache par rapport à la clé de cache Dictionnaire des produits, puis les données sont ajoutées au dictionnaire.

Astuce

Vous pouvez aussi vous configurer les attributs de recherche tels que Groupes/Tags/Tags nommés et attributs d'invalidation tels que l'expiration/l'expulsion/la dépendance lors de la création d'une structure de données.

try
{
  // Precondition: Cache must be connected

  // Specify unique cache key for dictionary
  string key = "ProductDictionary";

  // Create dictionary of Product type
  IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key);

  // Adding products to dictionary
  Product[] products = FetchProducts();
  foreach(var product in products)
  {
      // Add products
      string productKey = $"Product:{product.ProductID}";
      dictionary.Add(productKey, product);
  }
}
catch (OperationFailedException ex)
{
    // NCache specific exception
    if(ex.ErrorCode == NCacheErrorCodes.KEY_ALREADY_EXISTS)
    {
        // The specified key already exists in cache,
        // Either remove the existing object from cache
        // Or specify another key
    }
    else if (ex.ErrorCode == NCacheErrorCodes.CACHEITEM_IN_DATA_STRUCTURES)
    {
        // Data structures cannot be of CacheItem type
        // CacheItems cannot be added in data structures
    }
    else
    {
        // NCache specific exception
        // Exception can occur due to:
        // Connection Failures
        // Operation Timeout
        // Operation performed during state transfer
    }
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException 
}
Note

Pour garantir la sécurité de l'opération, il est recommandé de gérer toutes les exceptions potentielles au sein de votre application, comme expliqué dans Gestion des échecs.

Comment récupérer un dictionnaire depuis le cache

Vous pouvez récupérer un dictionnaire du cache qui prend une clé de cache comme paramètre. Cette clé est le nom du dictionnaire, qui est spécifié lors de la création du dictionnaire.

Avertissement

Si l'élément récupéré n'est pas de type dictionnaire, un Type mismatch l'exception est levée.

// Precondition: Cache is already connected

// Dictionary with this key already exists in cache
string key = "ProductDictionary";

// Get the dictionary and iterate through its items
IDistributedDictionary<string, Product> retrievedDictionary = cache.DataTypeManager.GetDictionary<string, Product>(key);
if (retrievedDictionary != null)
{
    foreach (var item in retrievedDictionary)
    {
        // Perform operations
    }
}
else
{
    // Dictionary does not exist
}

Comment récupérer les valeurs de clés spécifiques d'un dictionnaire

Vous pouvez récupérer les valeurs d'entrées spécifiques du dictionnaire en utilisant Get. L'exemple de code suivant utilise le dictionary instance de l'exemple pour ajouter des données au dictionnaire et obtient des valeurs par rapport aux clés spécifiées.

Note

Si aucune valeur n'existe pour la clé spécifiée, null est renvoyé.

// Precondition: Cache is already connected

// Dictionary exists in cache
// Create list of keys to fetch corresponding values
var keys = new List<string>();
keys.Add("Product:1001");
keys.Add("Product:1002");
keys.Add("Product:1003");

// Get values against keys
// "dictionary" instance was created while creating dictionary
ICollection<Product> values = dictionary.Get(keys);
foreach (var value in values)
{
    // Perform operations
}

Comment insérer des données dans un dictionnaire existant

Vous pouvez insérer des données dans un dictionnaire existant en utilisant Insert. L'exemple de code suivant récupère de nouveaux produits à partir de la source de données et les insère dans un dictionnaire qui existe déjà dans le cache.

Note

Si les clés existent déjà, cela écrasera les valeurs dans le dictionnaire.

// Precondition: Cache is already connected

// Dictionary with this key already exists in cache
string key = "ProductDictionary";

// Get dictionary to insert more values
IDistributedDictionary<string, Product> retrievedDictionary = cache.DataTypeManager.GetDictionary<string, Product>(key);

// Create dictionary of new products to be added
IDictionary<string, Product> newProducts = new Dictionary<string, Product>();
Product[] products = FetchProducts();
foreach (var product in products)
{
    // Add new products
    string productKey = $"Product:{product.ProductID}";
    newProducts.Add(productKey, product);
}
// Append dictionary entries to existing dictionary
retrievedDictionary.Insert(newProducts);

Comment supprimer des éléments du dictionnaire

Note

Si la clé à supprimer n'existe pas, rien n'est renvoyé. Vous pouvez vérifier le nombre de clés renvoyées à l'aide du type de retour de Remove.

Il est possible de supprimer des éléments d'un dictionnaire pour une collection de clés donnée. L'exemple de code suivant supprime les entrées du dictionnaire correspondant aux produits expirés. Remove.

Astuce

Pour supprimer tout le dictionnaire du cache, reportez-vous au Supprimer les structures de données du cache .

// Precondition: Cache is already connected

// Dictionary with this key already exists in cache
string key = "ProductDictionary";

// Get the dictionary and iterate through its items
IDistributedDictionary<string, Product> retrievedDictionary = cache.DataTypeManager.GetDictionary<string,  Product>(key);

// Create list of keys to remove
List<string> keysToRemove = FetchExpiredProducts();

// Number of keys removed is returned
int itemsRemoved = retrievedDictionary.Remove(keysToRemove);

Inscription aux notifications d'événements sur Dictionary.com

Vous pouvez enregistrer des événements de cache, des événements basés sur des clés et des événements de structure de données sur une structure de données telle qu'un dictionnaire. Pour le comportement, reportez-vous à comportement en termes de fonctionnalités.

Les exemples de code suivants enregistrent ItemAdded, ItemUpdated et ItemRemoved événements de structure de données sur le dictionnaire. La création d'un dictionnaire déclenche un ItemAdded événement au niveau du cache. L'ajout d'un élément à un dictionnaire existant déclenche un ItemAdded événement de structure de données et un ItemUpdated Événement au niveau du cache.

Comment enregistrer des événements dans un dictionnaire créé

// Precondition: Cache is already connected

// Unique cache key for dictionary
string key = "ProductDictionary";

// Create a dictionary of Product type
IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key);

// Register ItemAdded, ItemUpdated, ItemRemoved events on dictionary created
// DataTypeNotificationCallback is callback method specified
dictionary.RegisterNotification(DataTypeDataNotificationCallback, EventType.ItemAdded |
        EventType.ItemUpdated | EventType.ItemRemoved,
        DataTypeEventDataFilter.Data);

// Perform operations

Comment spécifier une fonction de rappel pour une notification d'événement ?

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;
    }
}

Comment verrouiller un dictionnaire

Le dictionnaire peut être explicitement verrouillé et déverrouillé pour garantir la cohérence des données. L'exemple de code suivant crée un dictionnaire et le verrouille pendant une période de 10 secondes à l'aide de Verrouillage puis le déverrouille en utilisant Accéder.

// Precondition: Cache is already connected

// Dictionary exists with key "ProductDictionary"
// Cache Key
string key = "ProductDictionary";

// Get dictionary
IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.GetDictionary<string, Product>(key);

// Lock dictionary for 10 seconds
bool isLocked = dictionary.Lock(TimeSpan.FromSeconds(10));
if (isLocked)
{
    // Dictionary is successfully locked for 10 seconds
    // Unless explicitly unlocked
}
else
{
    // Dictionary is not locked because either:
    // Dictionary is not present in the cache
    // Dictionary is already locked
}

dictionary.Unlock();

Ressources supplémentaires

NCache fournit un exemple d'application pour la structure de données du dictionnaire sur GitHub.

Voir aussi

.RAPPORTER: Alachisoft.NCache.Client.DataTypes espace de noms.
Java: com.alachisoft.ncache.client.datastructures espace de noms.