Las bases de datos han sido una parte integral de .NET aplicaciones, ya que puede obtener y manipular grandes conjuntos de datos de manera eficiente. Sin embargo, cuando se trata de datos transaccionales elevados, las bases de datos provocan una degradación del rendimiento en sus aplicaciones .NET. Esto se debe a que las bases de datos no se pueden escalar a varias máquinas: solo puede tener una máquina de servidor dedicada al nivel de la base de datos y no puede agregar más. La base de datos se convierte así en un cuello de botella de rendimiento. Para resolver este problema, utilizamos una solución de almacenamiento en caché distribuida, como NCache para mitigar viajes innecesarios y costosos a la base de datos.
NCache Detalles Descargar NCache Comparación de ediciones
¿Cómo almacenar en caché la base de datos?
Almacenar en caché una base de datos es mucho más simple de lo que parece. Debe incorporar un nivel de almacenamiento en caché con un caché como NCache entre su aplicación y el nivel de la base de datos para que los datos de la base de datos se sirvan desde el caché. Para simplificar, se han resumido los cuatro patrones más comunes de uso de caché. Se resumen a continuación:
1. Almacenamiento en caché de objetos
Esta estrategia sugiere que si sus datos no existen en el caché, los obtiene de la base de datos y luego los inserta en el caché, como NCache. Posteriormente, las llamadas sucesivas se tratan desde la memoria caché. Para problemas relacionados con datos obsoletos, agregue caducidad En el correo electrónico “Su Cuenta de Usuario en su Nuevo Sistema XNUMXCX”. elemento de caché para que se pueda actualizar desde la base de datos.
El siguiente fragmento de código obtiene una instancia de Customer de la memoria caché, si existe. De lo contrario, lo obtiene de la base de datos y lo agrega al caché para un acierto de caché en llamadas sucesivas.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
var key = "Customer:1001"; // Get Customer from cache if it exists var customer = cache.Get<Customer>(key); // If customer does not exist in cache if (customer == null) { // Fetch from database customer = GetCustomerFromDB(1001); // Create sliding expiration of 15 seconds. Cache removes item after this time var expiration = new Expiration (ExpirationType.Sliding, TimeSpan.FromSeconds(15.0)); var cacheItem = new CacheItem(customer) { Expiration = expiration }; // Insert the item with expiration into cache cache.Insert(cacheKey, cacheItem); } |
NCache Detalles Documentos de almacenamiento en caché de datos NCache Guía del programador
2. Caché de datos de referencia y uso de consultas SQL para buscarlos
Los datos que solo se leen y no se cambian con frecuencia se conocen como datos de referencia. Es bastante común que una aplicación .NET lea datos repetidamente y, con poca frecuencia, escriba datos en la base de datos. El caché (como NCache) es más potente cuando se utiliza para datos de referencia, ya que funciona más rápido con dichos datos.
Se recomienda encarecidamente almacenar en caché todos los datos de referencia y luego utilizar Consultas SQL para buscar en el caché para ello en lugar de ir a la base de datos. Tenga en cuenta que si no almacena en caché todo el conjunto de datos de referencia (p. ej., todos los clientes), sus consultas SQL contra el caché arrojarán resultados no válidos porque algunos de los datos solo están en la base de datos.
Si ya has precargado el caché con todos sus datos de referencia, el siguiente ejemplo explica cómo puede buscarlos:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// Pre-Requisite: All customer instances have already been added into cache var customerName = "John Smith"; // Write SQL query for cache var query = "SELECT $Value$ FROM Northwind.Model.Customer WHERE Name = ?"; // Create the query command that cache understands from the query var queryCommand = new QueryCommand(query); // Provide the parameters for the query queryCommand.Parameters.Add("Name", customerName); // Execute the query on cache var reader = cache.SearchService.ExecuteReader(queryCommand, true); var customer; // If a valid projection was made in the query if (reader.FieldCount > 0) { while (reader.Read()) { customer = reader.GetValue<Customer>(1); // Perform operation according to business logic } } |
NCache Detalles Documentos de almacenamiento en caché de SQL Documentos de almacenamiento en caché de datos
3. Manejo de relaciones de uno a muchos en la memoria caché
En su mayoría, nuestros datos contienen relaciones entre ellos. Por ejemplo, en el contexto de la base de datos Northwind (utilizada por Microsoft), la tabla 'Pedidos' está relacionada con la tabla 'Clientes'. Estas entidades se consideran entidades relacionadas en el dominio de la aplicación .NET. Usando un caché como NCache, también puede relacionar estas entidades dentro del caché.
Esto se hace por asociar todas las entidades relacionadas con un identificador de etiqueta de modo que en lugar de obtener cada pedido de los clientes individualmente, puede obtener todos los pedidos del cliente en una sola llamada buscando en el caché a través del identificador de etiqueta. El código de ejemplo dado ilustra cómo podemos provocar este comportamiento:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
var cacheKey = "Customer:1001"; var tagName = "Customer:1001_Orders"; // Check if customer exists in cache var cachedCustomer = cache.Get<Customer>(cacheKey); // If customer does not exist in cache if (cachedCustomer == null) { // Fetch from database var customer = GetCustomerFromDb(1001); // Insert customer into cache cache.Insert(cacheKey, customer); // Fetch orders of the customer from database var relatedOrders = GetRelatedOrdersFromDb(customer); // Create a tag for all orders of the customer var tag = new Tag(tagName); foreach (Order order in relatedOrders) { var orderCacheKey = $"Customer:1001_Order:{order.OrderID}"; // Create a cache item and set the tag identifier var orderCacheItem = new CacheItem(order) { Tags = new[] { tag } }; // Insert the tagged cache item into cache cache.Insert(orderCacheKey, orderCacheItem); } } else { // Item exists in the cache // Create a tag to fetch the related orders var tagIdentifier = new Tag(relatedEntityIdentifier); // Fetch the related orders based on the tag identifier var cachedOrders = cache.SearchService.GetByTag<Order>(tagIdentifier); } |
NCache Detalles Caché de documentos de datos etiquetados Documentos de almacenamiento en caché de datos
4. Almacenamiento en caché de los resultados de la consulta de la base de datos (datos transaccionales)
La mayoría de las veces, los datos de la base de datos se devuelven en forma de conjuntos de resultados de consultas. Esta estrategia sugiere que inserte todo el conjunto de resultados en la memoria caché para que las consultas sucesivas se atiendan desde la memoria caché. Las consultas con los mismos criterios siempre se referirán al mismo conjunto de resultados. Por lo tanto, podemos considerar los comandos de consulta en sí mismos como el identificador único para el conjunto de resultados y usarlo como clave en el caché.
El siguiente fragmento de código muestra cómo los conjuntos de resultados de consultas se pueden almacenar en caché como colecciones:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// Query to select East Coast Customers var query = "SELECT * FROM Northwind.Model.Customer WHERE Region = ‘EastCoast’"; // Create cache key based on the query var key = query; // Fetch the entities based on query var resultSet = cache.Get<IList<Customer>>(key); // If data against query not found in cache if (resultSet == null) { // Fetch the result set from database var customers = GetCustomersFromDb(query); // Convert the result set into a collection var cacheReadyCustomers = customers.ToList(); // Add result set to cache against query cache.Insert(cacheKey, cacheReadyCustomers); } |
NCache Detalles Documentos de almacenamiento en caché de datos Documentos de almacenamiento en caché de SQL
Conclusión
Como puede ver, almacenar en caché una base de datos en aplicaciones .NET con un caché como NCache es bastante fácil En función de los patrones de uso de la aplicación, puede almacenar en caché sus datos y obtenerlos mediante consultas como si lo hiciera para una base de datos.
Además, NCache es una solución de almacenamiento en caché distribuido en memoria. Todos los problemas encontrados al usar una base de datos se manejan en ella y tiene todas las implementaciones para un caché con requisitos estándar y mucho más.