Comportement et utilisation de la file d'attente dans le cache

Une file d'attente est une structure de données ordonnée qui utilise le principe du comportement Premier entré, premier sorti (FIFO). NCache La file d'attente distribuée permet d'ajouter et de retirer des éléments de la file d'attente sur plusieurs instances d'application avec une forte cohérence. Elle prend en charge nativement les opérations en masse et les notifications d'événements. NCache améliore encore la structure des données de la file d'attente en fournissant NCache-des fonctionnalités spécifiques telles que Groupes, Tags, Expiration, Verrouillable, Dépendanceset plus encore.

Vous pouvez utiliser des files d'attente dans NCache Pour assurer la continuité du traitement des informations en temps réel, on peut utiliser une file d'attente. Par exemple, les identifiants des candidats à un poste au sein d'une entreprise peuvent être stockés dans une file d'attente. Cette file d'attente fonctionnant selon le principe du premier arrivé, premier servi, le premier candidat à postuler sera convoqué en entretien, et ainsi de suite. De plus, l'entreprise peut définir un groupe pour la file d'attente des personnes ayant postulé à des postes administratifs.

NCache Comportement des files d'attente distribuées

  • Une file d'attente peut être de n'importe quel type primitif ou objet personnalisé.
  • Files d'attente de CacheItem et les files d'attente imbriquées ne sont pas encore prises en charge.
  • Les files d'attente sont nommées. Par conséquent, vous devez fournir une clé de cache unique pour chaque file d'attente.
  • 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 file d'attente et y ajouter des données

L'exemple de code suivant montre comment créer une file d'attente de Candidat saisissez dans le cache en fonction de la clé de cache File d'attente des candidats et comment les éléments sont ajoutés à la file d'attente.

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

Comment créer une file d'attente et y ajouter des données en masse

Si vous souhaitez ajouter plusieurs éléments en un seul appel, vous pouvez utiliser le EnqueueBulk méthode. L'exemple de code suivant montre comment une file d'attente de Candidat type peut être créé dans le cache par rapport à la clé de cache File d'attente des candidats et comment plusieurs éléments peuvent être ajoutés à la file d'attente en masse.

Note

Le EnqueueBulk La méthode garantit que les éléments sont ajoutés dans le même ordre que celui dans lequel ils apparaissent dans la liste fournie.

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

Si une erreur se produit lors de l'ajout d'un élément pendant le EnqueueBulk L'opération annule l'intégralité du processus. Soit tous les éléments sont mis en file d'attente, soit une exception est levée, sans ajout d'éléments.

Comment récupérer et exécuter d'autres méthodes sur la file d'attente

L'exemple de code suivant récupère une file d'attente à partir du cache à l'aide de GetQueue la méthode puis vérifie si un élément existe dans la file d'attente en utilisant la Contains Cette méthode permet de récupérer un élément du début de la file d'attente sans le supprimer. Peek Cette méthode permet de copier l'intégralité de la file d'attente source vers le tableau cible. CopyTo la méthode, et la convertir en un tableau unidimensionnel en utilisant la ToArray méthode.

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

Comment supprimer des éléments de la file d'attente

Les éléments peuvent être supprimés de la file d'attente de manière FIFO. L'exemple de code suivant supprime le premier candidat de la file d'attente.

Astuce

Pour supprimer toute la file d'attente du cache, reportez-vous à la Supprimer les structures de données du 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

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 supprimer des données en masse

Si vous souhaitez supprimer plusieurs éléments en un seul appel, vous pouvez utiliser le DequeueBulk méthode. le DequeueBulk la méthode prend un maxItems Paramètre spécifiant le nombre maximal d'éléments à retirer de la file d'attente. Si la file contient moins d'éléments que le nombre spécifié, seuls les éléments disponibles seront retirés. Par exemple, si vous spécifiez 10 éléments, mais qu'il n'en existe que 7, ils seront tous retirés. La valeur par défaut du nombre maximal d'éléments est 7.

L'exemple de code suivant montre comment récupérer la file d'attente de Candidat tapez en utilisant la clé de cache File d'attente des candidats et comment plusieurs éléments peuvent être supprimés de la file d'attente en masse.

Note

Le DequeueBulk La méthode garantit que les éléments sont supprimés de la file d'attente dans le même ordre dans lequel ils ont été ajoutés, jusqu'au nombre spécifié.

Avertissement

Lorsque vous utilisez le DequeueBulk Il est recommandé, pour cette méthode, de ne retirer de la file d'attente que le nombre d'éléments nécessaires au traitement immédiat. Retirer plus d'éléments que nécessaire peut augmenter le temps de traitement, car chaque opération a un coût, surtout si la file d'attente contient une grande quantité de données.

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

Si la file d'attente est vide pendant la DequeueBulk opération, une exception sera levée.

Similaire à EnqueueBulk, si une erreur se produit lors de la suppression d'un élément pendant le DequeueBulk L'opération annule l'intégralité du processus. Soit l'utilisateur reçoit tous les éléments demandés, soit une exception est levée, sans aucun élément retourné.

Inscription des notifications d'événements dans les files d'attente

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 file d'attente. Pour plus de détails, reportez-vous à comportement en termes de fonctionnalités.

Comment inscrire un événement dans la file d'attente créée

Les exemples de code suivants enregistrent les notifications d'événements de structure de données dans la file d'attente. L'exemple .NET enregistre : ItemAdded, ItemUpdated et ItemRemoved Les exemples Java et Node.js enregistrent les événements ItemAdded et ItemRemoved. La création d'une file d'attente déclenche un événement. ItemAdded un événement au niveau du cache, tandis que l'ajout d'un élément à une file d'attente existante déclenche un ItemAdded événement de structure de données et un ItemUpdated Événement au niveau du 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

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

L'exemple de code suivant montre comment spécifier une méthode de rappel pour recevoir des notifications pour différents événements, par exemple lorsqu'un élément est ajouté, mis à jour ou supprimé d'une collection. En gérant ces événements, vous pouvez déclencher des actions spécifiques en réponse aux modifications apportées au 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;
    }
}

Comment verrouiller les files d'attente

Les files d'attente peuvent être explicitement verrouillées et déverrouillées pour garantir la cohérence des données. L'exemple de code suivant crée une file d'attente et la 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

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

Ressources supplémentaires

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

Voir aussi

.RAPPORTER: Alachisoft.NCache.Client.DataTypes espace de noms.
Java: com.alachisoft.ncache.client.datastructures espace de noms.
Node.js : File d'attente distribuée classe.