Définit le comportement et l'utilisation dans le cache

Un HashSet est une structure de données non ordonnée qui ne contient pas de valeurs dupliquées. Par exemple, un HashSet peut être utilisé pour stocker l'identifiant de tous les utilisateurs se connectant à un site de commerce électronique un jour donné. Si l'utilisateur se reconnecte, son identifiant n'est pas stocké car les doublons sont interdits. Contrairement à un HashSet local, un HashSet stocke les identifiants de tous les utilisateurs se connectant à un site de commerce électronique un jour donné. Si l'utilisateur se reconnecte, son identifiant n'est pas stocké car les doublons ne sont pas autorisés. NCache Cette implémentation vous permet d'effectuer des opérations ensemblistes (Union, Intersection, Différence) directement sur le cluster de cache sans avoir à récupérer la collection complète sur le client, garantissant ainsi des performances élevées pour les grands ensembles de données.

NCache améliore encore HashSet en fournissant NCache caractéristiques spécifiques telles que Groupes, Tags, Expiration, Verrouillable, Dépendanceset plus encore.

Comportement

  • Un HashSet ne peut être que de type primitif.
  • Les HashSets sont nommés. Par conséquent, vous devez fournir une clé de cache unique pour chaque HashSet.
  • Null n'est pas un type de valeur pris en charge.
  • Les valeurs en double ne sont pas 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 :

Créer un HashSet et ajouter des données

Note

Un ensemble ne peut pas contenir de valeurs en double.

L'exemple de code suivant crée deux HashSets de type int dans le cache à l'aide de CreateHashSet pour les utilisateurs se connectant le lundi et le mardi. Il ajoute ensuite des données à ces deux HashSets.

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

  // Create unique keys for HashSets
  string mondayUsersKey = "MondayUsers";
  string tuesdayUsersKey = "TuesdayUsers";

  // Create HashSets of int type
  IDistributedHashSet<int> userSetMonday = cache.DataTypeManager.CreateHashSet<int>(mondayUsersKey);

  // Add user IDs for Monday
  userSetMonday.Add(1223);
  userSetMonday.Add(34564);
  userSetMonday.Add(3564);
  IDistributedHashSet<int> userSetTuesday = cache.DataTypeManager.CreateHashSet<int>(tuesdayUsersKey);

  // Add userIDs for Tuesday
  userSetTuesday.Add(4545);
  userSetTuesday.Add(34564);
  userSetTuesday.Add(3564);
  userSetTuesday.Add(7879);
}
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.

Effectuer l'union et l'intersection sur les HashSets

NCache fournit également un support pour les opérations HashSet natives telles que Union, Intersection et Difference. L'exemple de code suivant crée trois HashSets de type int qui stockent le Union, Intersection et Difference des deux HashSets utilisateurSetMonday et userSetTuesday créé dans l'exemple précédent :

// Precondition: Cache is already connected

// Create unique keys for HashSets
string totalUsersKey = "TotalUsers";
string weeklyUsersKey = "WeeklyUsers";
string differenceKey = "Difference";

// Create HashSets of int type
IDistributedHashSet<int> userSetTotal = cache.DataTypeManager.CreateHashSet<int>(totalUsersKey);
IDistributedHashSet<int> userSetWeekly = cache.DataTypeManager.CreateHashSet<int>(weeklyUsersKey);
IDistributedHashSet<int> userSetDifference = cache.DataTypeManager.CreateHashSet<int>(differenceKey);

// userSetTotal will contain unique values from the HashSets userSetMonday and userSetTuesday after union
userSetMonday.StoreUnion(totalUsersKey, tuesdayUsersKey);

// userSetWeekly will contain common values from the HashSets userSetMonday and userSetTuesday after intersection
userSetMonday.StoreIntersection(weeklyUsersKey, tuesdayUsersKey);

// userSetDifference will contain the difference between the HashSets userSetMonday and userSetTuesday
userSetMonday.StoreDifference(differenceKey, tuesdayUsersKey);

Récupérer le HashSet du cache

Vous pouvez récupérer un HashSet à partir du cache en utilisant GetHashSet qui prend une clé de cache en paramètre. Cette clé est le nom du HashSet, qui est spécifié lors de la création du HashSet.

Avertissement

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

// Precondition: Cache is already connected

// HashSet with this key already exists in cache
string key = "ProductIDSet";

// Get HashSet and show items of HashSet
IDistributedHashSet<int> retrievedHashSet = cache.DataTypeManager.GetHashSet<int>(key);
if (retrievedHashSet != null)
{
    foreach (var item in retrievedHashSet)
    {
        // Perform operations
    }
}
else
{
    // HashSet does not exist
}

Supprimer des éléments de HashSet

Les éléments peuvent être supprimés d'un HashSet soit en spécifiant l'élément lui-même, soit au hasard. L'exemple de code suivant supprime les utilisateurs du lundi des utilisateurs hebdomadaires HashSet (qui ont déjà été ajoutés au cache).

Astuce

Pour supprimer l'ensemble du cache, reportez-vous au Supprimer les structures de données du cache .

// Precondition: Cache is already connected

// Get existing HashSets
string userIDMondayKey = "UserIDMonday";
string userIDWeeklyKey = "UserIDWeekly";
IDistributedHashSet<int> userSetMonday = cache.DataTypeManager.GetHashSet<int>(userIDMondayKey);
IDistributedHashSet<int> usersWeekly = cache.DataTypeManager.GetHashSet<int>(userIDWeeklyKey);

// Remove users of Monday from Weekly HashSet
var removedItem = usersWeekly.Remove(userSetMonday);

Notifications d'événements sur HashSet

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 HashSet. Pour le comportement, reportez-vous à comportement intelligent.

Les exemples de code suivants enregistrent des notifications d'événements de structure de données sur le HashSet. L'exemple .NET enregistre ItemAdded, ItemUpdated et ItemRemoved événements, tandis que l'exemple Java enregistre ItemAdded et ItemRemoved événements. La création d'un HashSet déclenche un ItemAdded événement au niveau du cache. L'ajout d'un élément à un HashSet existant déclenche un ItemAdded événement de structure de données et un ItemUpdated Événement au niveau du cache.

Enregistrer l'événement sur le HashSet créé

// Precondition: Cache is already connected

// Unique cache key for hashset
string key = "UserIDMonday";

// Create hashset
IDistributedHashSet<int> hashset = cache.DataTypeManager.CreateHashSet<int>(key);

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

// Perform operations

Spécifier le rappel pour la 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;
    }
}

Verrouillage de l'ensemble de hachage

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

// Precondition: Cache is already connected

// HashSet exists with key "UserIDMonday" Cache Key
string key = "UserIDMonday";

// Get HashSet
IDistributedHashSet<int> hashset = cache.DataTypeManager.GetHashSet<int>(key);

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

hashset.Unlock();

Ressources supplémentaires

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

Voir aussi

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