Types de dépendances de données clés et utilisation

Dépendance des données clés dans NCache est un mécanisme de gestion des relations qui relie le cycle de vie des éléments mis en cache dépendants à une ou plusieurs clés « maîtresses ». Il est principalement utilisé pour maintenir l’intégrité des données entre les entités liées, notamment pour garantir une Commande est supprimé si son associé Produit Une fois le cache supprimé, cette fonctionnalité automatise son nettoyage.

Note

La rubrique dépendante est supprimée en cas de deux types de modifications dans la clé maîtresse :

  • Mises à jour
  • Supprimer

Les clés peuvent avoir deux types de dépendances :

Dépendance à plusieurs niveaux

Un élément du cache peut dépendre d'un nombre quelconque d'autres éléments du cache, formant ainsi une chaîne. La relation est alors de type un-à-un. Prenons par exemple trois types d'éléments liés : Produit, Commande et Détails de la commande. Un Commande dépend d'un Produit, alors qu'un Détails de la commande dépend du correspondant Commande. Si l' Produit L'article a été retiré. NCache supprime sa dépendance Commandece qui, à son tour, invalide la relation Détails de la commande.

Utilisation de la dépendance de clé à plusieurs niveaux dans NCache

Dépendance multiple

Un même élément peut dépendre de plusieurs éléments du cache. De même, cet élément peut dépendre de plusieurs éléments. Cela peut entraîner une relation « 1:n » entre les éléments. Par exemple, dans un cache, si un Commande appartient à un Le client et comprend un Produit, le Commande Depend de Le client et Produit. De même, le Détails de la commande dépend de la Commandes. Le diagramme suivant représente visuellement l’ensemble du scénario.

Utilisation de plusieurs dépendances de clés dans NCache

Si la Le client est supprimé, Commandes et Détails de la commande sont supprimés du cache. De même, si le Produit est supprimé, Commandes et Détails de la commande sont supprimés du cache.

Note

Vous ne pouvez spécifier que des clés existantes dans un cache pour la dépendance de clé. Une clé inexistante spécifiée pour la dépendance de clé entraînera une OperationFailedException. Alors qu’un objet peut être considéré comme dépendant d’une autre clé au moment de l’ajout.

Pré-requis :

Avant d'utiliser le NCache Les API côté client doivent s'assurer que les conditions préalables suivantes sont remplies :

Ajouter un élément de cache au cache avec dépendance de clé

Le CacheItem est une classe personnalisée fournie par NCache qui peut être utilisé pour ajouter des données au cache et vous permet de définir des métadonnées supplémentaires associées à un objet de cette classe. Ces métadonnées définissent les propriétés de l'élément telles que les dépendances, les expirations, etc. Ajouter la méthode ajoute un nouvel élément avec des métadonnées de dépendance, tandis que la insérer Cette méthode ajoute l'élément si la clé n'existe pas, ou écrase l'élément existant si la clé est déjà présente. CacheItem existe déjà dans le cache, il écrase ses propriétés.

Important

Notez que cette API spécifie également CacheItem priorité pour l'expulsion et l'expiration, où la valeur de ce paramètre est transmise comme Default.

L'exemple suivant ajoute un client au cache, crée une commande qui dépend de la clé du client, ce qui signifie que dès que le client est mis à jour ou supprimé, la commande du client est également supprimée du cache.

try
{
      // Precondition: Cache is already connected
      // Get customer from database
      Customer customer = FetchCustomerFromDB("ALFKI");

      // Add customer in cache
      cache.Add(customer.CustomerID, customer);

      // Get order from customer
      Order order = new Order
      {
            OrderID = 10248,
            OrderDate = DateTime.Now,
            ShipAddress = "Carrera 22 con Ave. Carlos Soublette #8-35"
      };

      // Save order to database
      bool isOrderSaved = SaveOrderToDB(order);

      // Generate order Id
      string orderKey = $"Order:{order.OrderID}";

      if (isOrderSaved)
      {
            // Generate an instance of Key Dependency
            CacheDependency dependency = new KeyDependency(customer.CustomerID);

            // Create CacheItem to your desired object
            CacheItem cacheItem = new CacheItem(order);

            // Add Key Dependency to order
            cacheItem.Dependency = dependency;

      // Add order in cache
            cache.Add(orderKey, cacheItem);
      }

      // Create order detail for the order
      OrderDetail orderDetail = new OrderDetail
      {
            OrderID = order.OrderID,
            UnitPrice = 200,
            Discount = 25.5F,
            Quantity = 10,
      };

      // Save order detail to database
      bool isOrderDetailSaved = SaveOrderDetailToDB(orderDetail);

      if (isOrderDetailSaved)
      {
            // Generate order detail Id
            string orderDetailId = $"OrderDetail: {orderDetail.OrderID}";

            // Generate an instance of Key Dependency
            CacheDependency dependency = new KeyDependency(orderKey);

            // Create CacheItem with your desired object
            CacheItem cacheItem = new CacheItem(orderDetail);

            // Apply dependency on order
            cacheItem.Dependency = dependency;

            // Insert order detail in cache with dependency
            cache.Add(orderDetailId, cacheItem);
      }
}
catch (OperationFailedException ex)
{
      // NCache specific exception

      if (ex.ErrorCode == NCacheErrorCodes.DEPENDENCY_KEY_NOT_FOUND)
      {
            // The dependent item does not exist in the cache
      }
      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.

Ajouter une dépendance de clé sur plusieurs clés

Vous pouvez également ajouter une dépendance de clé à un élément qui dépend de plusieurs clés. Ainsi, un seul élément peut dépendre de plusieurs autres éléments. Ajouter or insérer méthode. le Add ajoute un nouvel élément dans le cache alors que la méthode Insert La méthode ajoute un nouvel élément avec dépendance et si l'élément existe déjà dans le cache, elle écrase ses propriétés. L’exemple suivant le démontre.

// Precondition: Cache is already connected
// Get customer from database
Customer customer = FetchCustomerFromDB();

// Get product from database
Product product = FetchProductFromDB();

// Add customer in cache
cache.Add(customer.CustomerID, customer);

// Add product to cache
string productId = $"Product: {product.ProductID}";
cache.Add(productId, product);

// Get order from customer
Order order = new Order
{
      OrderID = 10248,
      OrderDate = DateTime.Now,
      ShipAddress = "Carrera 22 con Ave. Carlos Soublette #8-35"
};

// Save order to database
bool isOrderSaved = SaveOrderToDB(order);

// Generate order Id
string orderKey = $"Order: {order.OrderID}";

if (isOrderSaved)
{
      string[] dependencyKeys = { productId, customer.CustomerID };
      // Generate an instance of Key Dependency
      CacheDependency dependency = new KeyDependency(dependencyKeys);

      // Create CacheItem with your desired object
      CacheItem cacheItem = new CacheItem(order);

      // Add Key Dependency to order
      cacheItem.Dependency = dependency;

      // Insert order into cache with dependencies
      cache.Insert(orderKey, cacheItem);
}

// Create order detail
OrderDetail orderDetail = new OrderDetail
{
      OrderID = order.OrderID,
      UnitPrice = 200,
      Discount = 25.5F,
      Quantity = 10,
};

// Save order's detail to database
bool isOrderDetailSaved = SaveOrderDetailToDB(orderDetail);

if (isOrderDetailSaved)
{
      // Generate order detail Id
      string orderDetailId = $"OrderDetail: {orderDetail.OrderID}";

      // Generate an instance of Key Dependency
      CacheDependency dependency = new KeyDependency(orderKey);

      // Create CacheItem with your desired object
      CacheItem cacheItem = new CacheItem(orderDetail);

      // Add Key Dependency to order
      cacheItem.Dependency = dependency;

      //  Insert order detail into cache with dependencies
      cache.Insert(orderDetailId, cacheItem);
}

Ajouter une dépendance de clé à un élément de cache existant

NCache vous permet d'ajouter une dépendance de clé à un élément déjà présent dans le cache, sans le réinsérer dans le cache. Ce processus se produit via le CacheItemAttributes classe qui possède la propriété de Dependency être opposé à CacheItem. L'attribut est ensuite comparé à la clé existante de l'élément, à l'aide du UpdateAttributes méthode de Cache classe.

L'exemple suivant suppose qu'une commande et un produit existent déjà dans le cache. Il établit une dépendance entre la clé du produit et la commande. La mise à jour ou la suppression du produit entraîne alors la suppression de la commande associée.

// Precondition: Cache is already connected
string orderId = "Order:10248";
string ProductId = "Product:8899";

// Create a Key Dependency
CacheDependency dependency = new KeyDependency(ProductId);

// Create a cache item attribute
CacheItemAttributes itemAttribute = new CacheItemAttributes();

// Set dependency to cache item attribute
itemAttribute.Dependency = dependency;

// Update attribute in cache
cache.UpdateAttributes(orderId, itemAttribute);

Ressources supplémentaires

NCache fournit un exemple d'application pour la dépendance de clé sur GitHub.

Voir aussi

.RAPPORTER: Alachisoft.NCache.Dépendances.d'exécution espace de noms.
Java: com.alachisoft.ncache.runtime.dependencies espace de noms.
python: ncache.runtime.dependencies module.
Node.js : Dépendance clé classe.