Elenca il comportamento e l'utilizzo nella cache

Una lista distribuita è una struttura dati ordinata in cui è possibile aggiungere o rimuovere dati. Ad esempio, le liste gestiscono i prodotti aggiunti al carrello di un sito web di e-commerce. Supponiamo che un utente aggiunga al carrello prodotti come Ombrello, Mele Verdi e Caffè. Prima di completare la transazione, il prodotto Mele Verdi viene rimosso e sostituito con un nuovo prodotto Pere. Questo è possibile perché la lista può essere aggiornata in qualsiasi punto, senza influire sulle prestazioni.

NCache migliora ulteriormente la struttura dei dati dell'elenco fornendo NCache-funzioni specifiche come Gruppi, Tags, Scadenza, Blocco, dipendenzee altro ancora. In questo scenario, l'azienda desidera che l'elenco del carrello venga mantenuto solo finché la sessione è attiva. Pertanto, è possibile associare una scadenza a ciascun elenco creato, pari al valore di timeout della sessione.

NCache Comportamento e limitazioni dell'elenco

Dal NCache Gli elenchi sono progettati per il ridimensionamento dinamico: grandi set di dati possono essere archiviati in uno spazio di memoria distribuito, pur mantenendo un rapido accesso basato sull'indice.

  • Un elenco può essere di qualsiasi tipo primitivo o oggetto personalizzato.
  • Un elenco di CacheItem e le liste annidate non sono ancora supportate.
  • Gli elenchi sono accessibili direttamente dall'indice.
  • Gli elenchi hanno un nome. Pertanto, è necessario fornire una chiave di cache univoca per ogni elenco.
  • I valori nulli non sono supportati.
  • Sono supportati valori duplicati.

Prerequisiti

Prima di usare il NCache Per le API lato client, assicurarsi che siano soddisfatti i seguenti prerequisiti:

Come creare un elenco distribuito e aggiungere dati

CreateList consente alle applicazioni di creare una raccolta distribuita dedicata che supporta criteri di invalidazione automatica dei dati, come Scadenza o Espulsione.

L'esempio di codice seguente mostra come un elenco di Prodotto i tipi possono essere creati nella cache utilizzando CreateList contro la chiave della cache Elenco prodotti. I prodotti vengono aggiunti all'elenco utilizzando Add, quindi una nuova gamma di prodotti viene aggiunta all'elenco utilizzando AddRange.

Consiglio

Puoi anche configurare gli attributi ricercabili come Gruppi/Tag/Tag con nome e attributi di invalidamento come scadenza/eliminazione/dipendenza durante la creazione di una struttura dati.

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:

Per garantire che l'operazione sia a prova di errore, si consiglia di gestire eventuali potenziali eccezioni all'interno dell'applicazione, come spiegato in Gestione dei guasti.

Come aggiornare gli elementi in un elenco distribuito

È possibile aggiornare gli elenchi e i relativi elementi utilizzando gli indici, poiché è possibile accedere agli elenchi tramite indice. Il seguente esempio di codice aggiorna un valore in un elenco esistente (creato nell'esempio precedente) utilizzando l'indice. Quindi recupera un articolo in vendita e lo aggiunge al primo indice dell'elenco utilizzando 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);

Come recuperare un elenco dalla cache

Puoi recuperare un elenco dalla cache usando GetList, che accetta come parametro una chiave di cache. Questa chiave è il nome dell'elenco specificato durante la creazione dell'elenco.

Avvertenza

Se l'elemento recuperato non è di tipo Elenco, a Type mismatch viene generata un'eccezione.

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

Come rimuovere elementi da un elenco

Consiglio

Per rimuovere l'intero elenco dalla cache, fare riferimento al file Rimuovere le strutture di dati dalla cache .

È possibile rimuovere da un elenco singoli elementi o un determinato intervallo di elementi. L'esempio di codice seguente rimuove un singolo elemento utilizzando Remove e una gamma di prodotti scaduti utilizzando RemoveRange.

Note:

Se la chiave specificata da rimuovere non esiste, non viene restituito nulla. È possibile verificare il numero di elementi restituiti utilizzando il tipo di ritorno di 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);

Come registrare le notifiche degli eventi negli elenchi

È possibile registrare eventi cache, eventi basati su chiave ed eventi struttura dati su una struttura dati come un elenco. Per il comportamento, fare riferimento a comportamento in termini di funzionalità.

Il seguente esempio di codice registra ItemAdded, ItemUpdatede ItemRemoved eventi della struttura dati sull'elenco. La creazione dell'elenco attiva un ItemAdded evento a livello di cache. L'aggiunta di un elemento all'elenco esistente attiva un ItemAdded evento della struttura dati e un ItemUpdated Evento a livello di cache. DataTypeEventDataFilter specifica la quantità di dati restituiti con l'evento della struttura dati.

Come registrare eventi in un elenco creato

// 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

Come specificare il callback per la notifica degli eventi

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

Come implementare il blocco distribuito su una lista

Gli elenchi possono essere bloccati e sbloccati in modo esplicito per garantire la coerenza dei dati. L'esempio di codice seguente crea un elenco e lo blocca per un periodo di 10 secondi utilizzando bloccare, quindi lo sblocca utilizzando Sbloccare.

// 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();

Risorse addizionali

NCache fornisce un'applicazione di esempio per la struttura dei dati dell'elenco GitHub.

Vedere anche

.NETTO: Alachisoft.NCache.Tipi.dati.client spazio dei nomi.
Giava: com.alachisoft.ncache.client.datastructures spazio dei nomi.
Node.js: Elenco distribuito classe.