Comportamento della coda e utilizzo nella cache

Una coda è una struttura dati ordinata che utilizza il principio del comportamento First-In-First-Out (FIFO). NCache Distributed Queue consente di aggiungere e rimuovere elementi dalla coda su più istanze dell'applicazione con elevata coerenza. Offre supporto integrato per operazioni in blocco e notifiche di eventi. NCache migliora ulteriormente la struttura dei dati della coda fornendo NCache-funzioni specifiche come Gruppi, Tags, Scadenza, Blocco, dipendenzeE altro ancora.

È possibile utilizzare le code in NCache per mantenere aggiornate le informazioni in fase di elaborazione. Ad esempio, gli ID delle candidature dei candidati per un'azienda possono essere memorizzati in una coda. Poiché la coda segue la logica FIFO (First-In, First-Out), il primo candidato a candidarsi verrà intervistato per primo, e così via. Inoltre, l'azienda può specificare un gruppo per una coda di persone che si sono candidate per posizioni amministrative.

NCache Comportamento della coda distribuita

  • Una coda può essere di qualsiasi tipo primitivo o oggetto personalizzato.
  • Code di CacheItem Le code annidate non sono ancora supportate.
  • Le code hanno un nome. Pertanto, è necessario fornire una chiave di cache univoca per ogni coda.
  • 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 una coda e aggiungere dati

Il seguente esempio di codice mostra come creare una coda di Candidato digitare nella cache in base alla chiave della cache CandidateQueue e come gli elementi vengono aggiunti alla coda.

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 Queue
  string key = "CandidateQueue";

  // Create Queue of Candidate type
  IDistributedQueue<Candidate> queue = cache.DataTypeManager.CreateQueue<Candidate>(key);

  Candidate[] candidates = FetchCandidates();

  foreach(var candidate in candidates)
  {
      // Add candidates to Queue
      queue.Enqueue(candidate);
  }
}
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
}

Come creare una coda e aggiungere dati in blocco

Se vuoi aggiungere più elementi in una singola chiamata, puoi utilizzare EnqueueBulk metodo. Il seguente esempio di codice mostra come una coda di Candidato il tipo può essere creato nella cache rispetto alla chiave della cache CandidateQueue e come più elementi possono essere aggiunti alla coda in blocco.

Note:

Migliori EnqueueBulk Il metodo garantisce che gli elementi vengano aggiunti nello stesso ordine in cui appaiono nell'elenco fornito.

// Precondition: Cache is already connected

// Specify unique cache key for queue
string key = "CandidateQueue";

// Create Queue of Candidate type
IDistributedQueue<Candidate> queue = cache.DataTypeManager.CreateQueue<Candidate>(key);
Candidate[] candidates = FetchCandidates();

// Add a list of candidates to the queue
queue.EnqueueBulk(candidates);

Se si verifica un errore durante l'aggiunta di un elemento durante la EnqueueBulk operazione, l'intero processo viene annullato. L'utente avrà tutti gli elementi in coda oppure verrà generata un'eccezione, senza alcun elemento aggiunto.

Come recuperare ed eseguire altri metodi sulla coda

Il seguente esempio di codice recupera una coda dalla cache utilizzando GetQueue metodo e quindi controlla se un elemento esiste nella coda utilizzando il Contains metodo. Recupera un elemento dall'inizio della coda senza rimuoverlo utilizzando il Peek metodo. È possibile copiare l'intera coda di origine nell'array di destinazione utilizzando il metodo CopyTo metodo e convertirlo in un array unidimensionale utilizzando il ToArray metodo.

// Precondition: Cache is already connected

// Queue with this key already exists in cache
string key = "CandidateQueue";

// Get Queue and show items of Queue
IDistributedQueue<Candidate> retrievedQueue = cache.DataTypeManager.GetQueue<Candidate>(key);

// Get any candidate ID
Candidate candidate = GetCandidateByID(1002);

// Check whether Queue contains the particular candidate or not
if (retrievedQueue.Contains(candidate))
{
    // Candidate exists with this ID
}
// List of candidates for the Queue to be copied into
Candidate[] candidates = new Candidate[retrievedQueue.Count];

// Copy the Queue to another array
retrievedQueue.CopyTo(candidates, 0);

// Copy Queue to one-dimensional array
candidates = retrievedQueue.ToArray();

// Get an item at beginning from Queue without removing
Candidate firstCandidate = retrievedQueue.Peek();

Come rimuovere gli elementi dalla coda

Gli elementi possono essere rimossi dalla coda in modalità FIFO. Il seguente esempio di codice rimuove il primo candidato dalla coda.

Consiglio

Per rimuovere l'intera coda dalla cache, fare riferimento a Rimuovere le strutture di dati dalla cache .

// Precondition: Cache is already connected

// Queue with this key already exists in cache
string key = "CandidateQueue";
IDistributedQueue<Candidate> retrievedQueue = cache.DataTypeManager.GetQueue<Candidate>(key);

// Remove the first item of the queue
retrievedQueue.Dequeue();
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 rimuovere i dati in blocco

Se vuoi rimuovere più elementi in una singola chiamata, puoi utilizzare DequeueBulk metodo. Il DequeueBulk il metodo richiede a maxItems Parametro che specifica il numero massimo di elementi da rimuovere dalla coda. Se la coda contiene meno elementi del numero specificato, verranno rimossi dalla coda solo gli elementi disponibili. Ad esempio, se si specifica 10 ma sono presenti solo 7 elementi, tutti e 7 gli elementi verranno rimossi dalla coda. Il valore predefinito per il numero massimo di elementi è 10.

Il seguente esempio di codice mostra come recuperare la coda di Candidato digitare utilizzando la chiave cache CandidateQueue e come più elementi possono essere rimossi dalla coda in blocco.

Note:

Migliori DequeueBulk Il metodo garantisce che gli elementi vengano rimossi dalla coda nello stesso ordine in cui sono stati aggiunti, fino al numero specificato.

Avvertenza

Quando si utilizza la DequeueBulk Con questo metodo, si consiglia di estrarre dalla coda solo il numero di elementi necessari per l'elaborazione in quel momento. Estrarre dalla coda un numero di elementi superiore al necessario può aumentare i tempi di elaborazione, poiché ogni operazione comporta un proprio costo di elaborazione, soprattutto se la coda contiene una grande quantità di dati.

// Precondition: Cache is already connected

// Queue with this key already exists in cache
string key = "CandidateQueue";
IDistributedQueue<Candidate> retrievedQueue = cache.DataTypeManager.GetQueue<Candidate>(key);

// Remove at most the first 10 items in the Queue
IList<Candidate> dequeuedItems = retrievedQueue.DequeueBulk(10);
Note:

Se la coda è vuota durante la DequeueBulk operazione, verrà generata un'eccezione.

Simile a EnqueueBulk, se si verifica un errore durante la rimozione di un elemento durante la DequeueBulk operazione, l'intero processo viene annullato. L'utente riceverà tutti gli elementi richiesti oppure verrà generata un'eccezione, senza restituzione di alcun elemento.

Registrazione delle notifiche degli eventi nelle code

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

Come registrare un evento nella coda creata

I seguenti esempi di codice registrano le notifiche degli eventi della struttura dati sulla coda. L'esempio .NET registra ItemAdded, ItemUpdatede ItemRemoved eventi, mentre gli esempi Java e Node.js registrano gli eventi ItemAdded e ItemRemoved. La creazione di una coda attiva un ItemAdded evento a livello di cache, mentre l'aggiunta di un elemento a una coda esistente attiva un ItemAdded evento della struttura dati e un ItemUpdated Evento a livello di cache.

// Precondition: Cache is already connected

// Unique cache key for Queue
string key = "CandidateQueue";

// Create Queue of Candidate type
IDistributedQueue<Candidate> queue = cache.DataTypeManager.CreateQueue<Candidate>(key);

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

// Perform operations

Come specificare il callback per la notifica degli eventi

Il seguente esempio di codice mostra come specificare un metodo di callback per ricevere notifiche per diversi eventi, come quando un elemento viene aggiunto, aggiornato o rimosso da una raccolta. Gestire questi eventi consente di attivare azioni specifiche in risposta a modifiche nella cache.

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 bloccare le code

Le code possono essere bloccate e sbloccate in modo esplicito per garantire la coerenza dei dati. Il seguente esempio di codice crea una coda e la blocca per un periodo di 10 secondi utilizzando bloccare e poi lo sblocca usando Sbloccare.

// Precondition: Cache is already connected

// Queue exists with key "CandidateQueue" cache key
string key = "CandidateQueue";

// Get Queue
IDistributedQueue<Candidate> queue = cache.DataTypeManager.GetQueue<Candidate>(key);

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

queue.Unlock();

Risorse addizionali

NCache fornisce un'applicazione di esempio per la struttura dati della coda su GitHub.

Vedere anche

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