Comportement et utilisation de la liste dans le cache

Une liste distribuée est une structure de données ordonnée permettant d'ajouter ou de supprimer des données. Par exemple, les listes gèrent les produits ajoutés au panier d'un site e-commerce. Supposons qu'un utilisateur ajoute des produits comme un parapluie, des pommes vertes et du café à son panier. Avant de finaliser la transaction, le produit « Pommes vertes » est retiré et remplacé par un nouveau produit, « Poires ». Ceci est possible car la liste peut être mise à jour à n'importe quel niveau, sans impact sur les performances.

NCache améliore encore la structure des données de la liste en fournissant NCache-des fonctionnalités spécifiques telles que Groupes, Tags, Expiration, Verrouillable, DépendancesDans ce cas précis, l'entreprise souhaite que la liste du panier ne soit conservée que pendant la durée de la session. Par conséquent, une durée d'expiration, égale à celle de la session, peut être associée à chaque liste créée.

NCache Comportement et limitations de la liste

Depuis que NCache Les listes sont conçues pour une mise à l'échelle dynamique ; les grands ensembles de données peuvent être stockés dans un espace mémoire distribué tout en conservant un accès rapide basé sur l'index.

  • Une liste peut être de n'importe quel type primitif ou objet personnalisé.
  • Une liste de CacheItem et les listes imbriquées ne sont pas encore prises en charge.
  • Les listes sont directement accessibles par index.
  • Les listes sont nommées. Par conséquent, vous devez fournir une clé de cache unique pour chaque liste.
  • Les valeurs nulles ne sont pas prises en charge.
  • Les valeurs en double sont prises en charge.

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 une liste distribuée et y ajouter des données

CreateList permet aux applications de créer une collection distribuée dédiée qui prend en charge les politiques d'invalidation automatique des données telles que l'expiration ou l'éviction.

L'exemple de code suivant montre comment une liste de Produit les types peuvent être créés dans le cache en utilisant CreateList contre la clé de cache Liste de produits. Les produits sont ajoutés à la liste à l'aide de Add, puis une nouvelle gamme de produits est ajoutée à la liste à l'aide de AddRange.

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 is already connected

  // Specify unique cache key for list
  string key = "ProductList";

  // Create list of Product type
  IDistributedList<Product> list = cache.DataTypeManager.CreateList<Product>(key);

  // Get products to add to list
  Product[] products = FetchProducts();

  foreach (var product in products)
  {
      // Add products to list
      list.Add(product);
  }

  // Get new products
  Product[] newProducts = FetchNewProducts();

  // Append list of new Products to existing list
  list.AddRange(newProducts);
}
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
    {
        // 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 mettre à jour les éléments d'une liste distribuée

Vous pouvez mettre à jour les listes et leurs éléments à l'aide d'index, car les listes sont accessibles par leur index. L'exemple de code suivant met à jour une valeur dans une liste existante (créée dans l'exemple précédent) à l'aide de l'index. Il récupère ensuite un article en promotion et l'ajoute au premier élément de la liste. InsertAtHead.

// Precondition: Cache is already connected

// "list" is created in the previous example
// Update value of index with updated product
Product updatedProduct = GetUpdatedProductByID(11);
list[11] = updatedProduct;

// Get product on sale to insert at the head of the list
Product saleProduct = FetchSaleItem();
list.InsertAtHead(saleProduct);

Comment récupérer une liste depuis le cache

Vous pouvez récupérer une liste du cache en utilisant GetList, qui prend une clé de cache comme paramètre. Cette clé correspond au nom de la liste spécifiée lors de sa création.

Avertissement

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

// Precondition: Cache is already connected

// List with this key already exists in cache
string key = "ProductList";

// Get the list and iterate through its items
IDistributedList<Product> retrievedList = cache.DataTypeManager.GetList<Product>(key);

if (retrievedList != null)
{
    foreach (var item in retrievedList)
    {
        // Perform operations
    }
}
else
{
    // List does not exist
}

Comment supprimer des éléments d'une liste

Astuce

Pour supprimer toute la liste du cache, reportez-vous au Supprimer les structures de données du cache .

Des éléments individuels ou une gamme donnée d'éléments peuvent être supprimés d'une liste. L'exemple de code suivant supprime un élément individuel à l'aide de Remove et une gamme de produits périmés utilisant RemoveRange.

Note

Si la clé à supprimer n'existe pas, aucune valeur n'est renvoyée. Vous pouvez vérifier le nombre d'éléments renvoyés à l'aide du type de retour. RemoveRange.

// Precondition: Cache is already connected

// List with this key already exists in cache
string key = "ProductList";

// Get list to remove items
IDistributedList<Product> retrievedList = cache.DataTypeManager.GetList<Product>(key);

// Get a range of out-of-stock products to be removed
List<Product> outOfStockProducts = FetchOutOfStockProducts();

// Remove each item individually from retrievedList
foreach(Product prod in outOfStockProducts)
{
    retrievedList.Remove(prod);
}

// Get range of discontinued products to be removed
List<Product> discontinuedProducts = FetchDiscontinuedProducts();

// Remove this range from retrievedList
// Number of keys removed is returned
int itemsRemoved = retrievedList.RemoveRange(discontinuedProducts);

Comment enregistrer les notifications d'événements sur les listes

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'une liste. Pour le comportement, reportez-vous à comportement en termes de fonctionnalités.

L'exemple de code suivant enregistre ItemAdded, ItemUpdated et ItemRemoved événements de structure de données sur la liste. La création de la liste déclenche un ItemAdded événement au niveau du cache. L'ajout d'un élément à la liste existante déclenche un ItemAdded événement de structure de données et un ItemUpdated Événement au niveau du cache. DataTypeEventDataFilter spécifie la quantité de données renvoyées avec l'événement de structure de données.

Comment inscrire des événements sur une liste créée

// Precondition: Cache is already connected

// Unique cache key for list
string key = "ProductList";

// Create a list of Product type
IDistributedList<Product> list = cache.DataTypeManager.CreateList<Product>(key);

// Register ItemAdded, ItemUpdated, ItemRemoved events on list created
// DataTypeNotificationCallback is callback method specified
list.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 implémenter le verrouillage distribué sur une liste

Les listes peuvent être explicitement verrouillées et déverrouillées pour assurer la cohérence des données. L'exemple de code suivant crée une liste et la verrouille pendant 10 secondes à l'aide de Verrouillage, puis le déverrouille à l'aide de Accéder.

// Precondition: Cache is already connected

// List exists with key "ProductList"
string key = "ProductList";

// Get list
IDistributedList<Product> list = cache.DataTypeManager.GetList<Product>(key);

// Lock list for 10 seconds
bool isLocked = list.Lock(TimeSpan.FromSeconds(10));

if (isLocked)
{
    // List is successfully locked for 10 seconds
    // Unless explicitly unlocked
}
else
{
    // List is not locked because either:
    // List is not present in the cache
    // List is already locked
}

list.Unlock();

Ressources supplémentaires

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

Voir aussi

.RAPPORTER: Alachisoft.NCache.Client.DataTypes espace de noms.
Java: com.alachisoft.ncache.client.datastructures espace de noms.
Node.js : ListeDistribuée classe.