NCache como ya sabemos, almacena datos en la memoria caché para un mejor rendimiento y lograr un alto rendimiento y escalabilidad. Hemos visto NCache haciendo maravillas cuando se trata de un acceso rápido a los datos para aumentar el rendimiento de su aplicación, sin embargo, todavía tenemos que aprender qué tipo de datos NCache almacenar en el caché. como bases de datos, NCache le permite agregar datos siguiendo pasos simples y es muy flexible cuando se trata de agregar datos y proporciona un montón de tipos de datos que se adaptan a casi todas las necesidades de las aplicaciones. Este blog trata sobre las formas en que NCache almacena sus datos en el almacén de caché brindándole la máxima facilidad.
Pares clave-valor
Para empezar, NCache es un almacén de clave-valor que establece claramente que NCache almacena datos de tal manera que hay una clave contra ese valor. UN clave es un identificador basado en cadenas y tiene la siguiente lista de propiedades:
- Se supone que una clave es única y no hay duplicación de clave permitida por NCache.
- Una clave no puede ser nula.
- La clave distingue entre mayúsculas y minúsculas.
A propuesta de es el valor del objeto almacenado en la memoria caché. Veremos todos los tipos admitidos en el blog más adelante. Esto explica el par clave-valor donde la clave se usa como el atributo de identificación del valor almacenado en su contra. La figura 1 ilustra cómo se agregan y almacenan los datos en la memoria caché:
Tipos de datos admitidos en NCache
NCache admite los datos en forma de objetos. Estos objetos pueden tener cualquiera de las siguientes formas:
- Tipos primitivos
- Objeto de clase personalizado
- Estructuras de datos
- Datos JSON
Claves de caché y descripción general de los datos Adición de datos a la caché NCache Agrupación dinámica
Tipos de datos primitivos
NCache admite todos los tipos de datos primitivos de .NET. Puede agregar una cadena como un valor contra una clave. Los siguientes son los tipos soportados por NCache:
byte/sbyte | corto/ucorto | objeto | cadena | doble | bool | Espacio de tiempo |
int/uint | largo/muy largo | tanque | flotar | decimal | DateTime |
Veamos rápidamente un breve ejemplo de código que muestra la adición de una cadena contra la clave en el caché:
1 2 3 4 5 6 7 8 |
// Specify the customer name as string string customerName = "John Wick"; // Generate a unique cache key string key = "Customer"; // Add the string to cache cache.Add(key, customerName); |
Objeto de clase personalizado
El objeto de clase personalizado se refiere a un objeto de clase .NET o Java, por ejemplo, Productos, Pedidos, Clientes, etc. La única y muy importante condición para agregar un objeto de clase personalizado a tu caché es marcar los datos serializable. Puede serializar la clase en el caché ya sea:
- Agregar el atributo serializable .NET en su clase personalizada o
- Usar Serialización compacta dinámica que es un marco proporcionado por NCache proporcionando una serialización rentable para las clases registradas de forma dinámica.
Sin embargo, los datos no serializados no se pueden agregar al caché. mira el Publicación por entregas sección para obtener más detalles sobre la serialización de datos de caché.
Agreguemos un objeto de clase personalizado en el caché en el código a continuación. Antes de agregar los datos al caché, márquelos serializados como se muestra:
1 2 3 4 5 6 7 8 |
[Serializable] public class Product { public int ProductID { get; set; } public string ProductName { get; set; } public string Category { get; set; } public int Price { get; set; } } |
1 2 3 4 5 6 7 8 |
// Get product from database against given product ID Product product = FetchProductFromDB(1001); // Generate a unique cache key for this product string key = $"Product:{product.ProductID}"; // Add Product object to cache CacheItemVersion version = cache.Add(key, product); |
Estructuras de datos
NCache ser distribuida en la naturaleza ofrece la funcionalidad de estructuras de datos convencionales que permite la adición, eliminación y recuperación de datos sin afectar la consistencia de los datos. Las siguientes son las estructuras de datos soportadas por NCache:
- Lista distribuida: Implementación nativa .NET de la interfaz IList. Por ejemplo, en una plataforma de comercio electrónico, los clientes pueden agregar/quitar artículos usando un lista distribuida.
1 |
IDistributedList list = cache.DataTypeManager.CreateList(key, dataTypeAttributes); |
- Cola distribuida: La implementación de primero en entrar, primero en salir (FIFO) para elementos conocida como cola distribuida. Por ejemplo, el análisis de sentimientos realizado por una agencia de inteligencia para filtrar tweets amenazantes puede usar un cola distribuida para almacenar los tweets en él.
1 |
IDistributedQueue queue = cache.DataTypeManager.CreateQueue(key); |
- Hashset distribuido: Una implementación de tipos de datos desordenados donde los valores de un conjunto son únicos y distintivos. Por ejemplo, si tiene una librería en línea, Conjuntos de hash puede ayudarlo a identificar qué usuario está interesado en qué libros o ha comprado cuántos libros.
1 |
IDistributedHashSet userSetMonday = cache.DataTypeManager.CreateHashSet(mondayUsersIds); |
- Diccionario distribuido: Un par clave-valor que es una implementación nativa de .NET de la interfaz IDictionary. Se mantiene un valor contra una determinada clave, por ejemplo, puede almacenar las credenciales de inicio de sesión, es decir, el nombre de usuario y la contraseña en forma de un diccionario distribuido en un entorno de caché distribuida.
1 |
IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key); |
- Contador distribuido: Una estructura de datos utilizada para incrementar o disminuir el valor fácilmente. Por ejemplo, para llevar la cuenta de las visitas que recibe una página web por hora o por día, se puede implementar fácilmente usando contador distribuido.
1 |
ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue); |
Mire el código a continuación para tener una idea de cómo usar la lista distribuida en NCache donde se agrega una lista de productos en el caché:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// Specify unique cache key for list string key = "ProductList"; // Create list of Product type in cache IDistributedList list = cache.DataTypeManager .CreateList(key); // Get products to add to list Product[] products = FetchProducts(); foreach (var product in products) { // Add products to list list.Add(product); } |
Datos JSON en NCache
JSON es un lenguaje legible liviano utilizado por las aplicaciones por ser extremadamente rápido y compatible con todos los principales marcos de JavaScript. NCache te permite agrega tus datos JSON fácilmente en el almacén de caché al proporcionar algunas clases derivadas de una clase base JsonValueBase. Veamos las clases proporcionadas por NCache:
- Objeto Json: Este clase es para pares de nombre-valor no ordenados donde nombre es el nombre del objeto y valor es el valor del objeto JSON que puede ser de cualquier tipo primitivo.
- Valor Json: Este clase representa los tipos de datos primitivos en las convenciones de JSON, como cadena, entero o fecha y hora.
- Json Array: Este clase representa una colección de elementos y representa JArray en NCachedominio de .
- JsonNulo: Esta clase representa el valor NULL en los estándares de JSON.
El siguiente código muestra el uso de JSON en NCache con código de ejemplo. El ejemplo de código muestra un JsonObject formado a partir de una cadena e insertado en la memoria caché.
1 2 3 4 5 6 7 8 9 10 11 12 |
var product = GetProductFromDB(); string jsonString = $@"{{ 'ProductID': { product.ProductID}, 'ProductName': '{product.ProductName}', 'Category': '{product.Category}', 'UnitsAvailable' : { product.UnitsAvailable} }}"; JsonObject jsonObject = new JsonObject(jsonString); cache.Insert(key, jsonObject); // Fetch the jsonObject previously added var jsonObject = cache.Get(key); |
Soporte JSON en NCache Estructuras de datos distribuidos Adición de datos a la caché
Afinidad de ubicación
Una característica adicional de NCache para proporcionar un mayor rendimiento es Afinidad de ubicación. Para lograr un mayor rendimiento y mejores resultados para su aplicación, NCache le da el control de mantener los datos de dos clases diferentes en el mismo nodo. Esto crea una afinidad entre los diferentes elementos que pertenecen a diferentes clases, por lo que se ahorra el costo correspondiente al obtener esos elementos. Todo lo que necesita hacer es agregar los elementos que tienen afinidad con llaves similares {}, por lo tanto, asegúrese de que los elementos existan en el mismo nodo. Por ejemplo, Order_{Product:1001}” muestra afinidad entre los pedidos pertenecientes al objeto producto con la clave de producto 1001.
Déjame mostrarte un ejemplo de código donde Productos y Mis Pedidos se agregan en el mismo nodo mediante la afinidad de ubicación.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Product product = FetchProductFromDB(1001); string productKey = "Product:1001"; var productCacheItem = new CacheItem(product); // Add CacheItem to cache CacheItemVersion version = cache.Add(key, productCacheItem); Order order = FetchOrderFromDB(17); // Unique order key for this order using Location Affinity syntax // This will create an affinity for this orderKey with the respective productKey string orderKey = "Order_{Product:1001}"; var orderCacheItem = new CacheItem(order); // Add order with Location Affinity to cache CacheItemVersion version = cache.Add(key, orderCacheItem); |
Conclusión
En conclusión, NCache proporciona formas flexibles de agregar datos a la memoria caché que se adaptan a los requisitos de su aplicación. Todo lo que necesita hacer es usar una API simple para agregar los datos en el caché. la mejor parte de NCache es que con cada nueva versión, la adición de datos se vuelve más fácil y eficiente con el soporte de nuevas funciones. Puede ver otras características interesantes de NCache esta página.