Usar NCache en EF Core y SQL Server

Hoy te voy a mostrar cómo puedes integrar NCache en sus aplicaciones Entity Framework Core existentes para obtener los beneficios de alto rendimiento y escalabilidad. Hay mucho que cubrir, así que voy a saltar directamente a ello.

Ejemplo de aplicación EF Core

Lo primero que tenemos es esto. muestra de aplicación Entity Framework Core que tengo que utiliza bases de datos SQL Northwind. Entonces, si venimos aquí, pueden ver que estoy obteniendo estos pedidos entre estos ID de pedido 10249 y 10268, y podemos ver que estoy obteniendo estos clientes de EE. UU. y estos productos entre estos ID de producto 10 y 20. Eso es todo lo que hace esta muestra. Sigamos adelante y echemos un vistazo a los resultados que esto nos traerá de la base de datos. Perfecto. Entonces, podemos ver que recuperamos estos productos entre 10 y 20, estos 11 productos, estos 13 clientes de EE. UU. y estos 20 pedidos entre esos ID de pedido.

Entonces, ahora que se ejecutó el ejemplo, echemos un vistazo a la base de datos con la que estamos trabajando. Entonces, como puede ver, estamos trabajando con bases de datos de Northwind y estos son los clientes que ya tenemos en la tabla de nuestros clientes. Entonces, eso está muy bien, hemos visto el trabajo de muestra.

Pasos de integración

Ahora, hablemos de cómo podemos integrar NCache en esta aplicación Entity Framework Core existente. Vamos a hacer esto siguiendo cinco pasos muy simples.

Instalar NCache Paquete EF Core Nuget
Añada NCache Espacio de nombres EntityFrameworkCore
Especificar configuraciones de caché en DbContext
Hacer modelos serializables
Uso NCache Métodos de extensión de EF Core

Instalar NCache Paquete EF Core Nuget

Entonces, el primer paso será instalar el NCache Paquete Entity Framework Core NuGet en la aplicación. Entonces, si administro los paquetes NuGet para esta aplicación, podemos ver que ya tengo instalado EntityFrameworkCore.NCache Paquete NuGet que corresponde a NCache 5.3 SP2. Perfecto. Así que voy a cerrar esto.

Añada NCache Espacio de nombres EntityFrameworkCore

Echemos un vistazo al siguiente paso. Entonces, el siguiente paso es agregar el NCache Espacio de nombres Entity Framework Core en nuestra aplicación. Entonces, si subo aquí solo necesito agregar "usando Alachisoft.NCache.EntityFrameworkCore". Voy a necesitar hacer lo mismo para mi contexto. Entonces, guardo esto aquí, me muevo al contexto, lo pegaré allí también y lo guardaré, perfecto.

Especificar configuraciones de caché en el contexto de la base de datos

Ahora, el siguiente paso es especificar las configuraciones de caché dentro del contexto de la base de datos. Ahora, si me desplazo hacia abajo, busco mi método "OnConfiguring". Ahí está el método OnConfiguring. Y aquí lo que voy a hacer es agregar el caché con el que estoy trabajando, así que ese es el 'efcorecache' aquí, y agrego el 'NCacheConfiguration.Configure’ y digo que este caché y el tipo de dependencia sean SQL server ya que estoy trabajando con un servidor SQL, perfecto.

Dependencia de caché en SQL Server

Hacer modelos serializables

Y ahora que ya está hecho, el siguiente paso es hacer que nuestros modelos sean serializables. Entonces, voy a dirigirme a mis modelos, iré a mi cliente y agregaré [Serializable], perfecto. Voy a copiar esto, voy a ir al pedido y pegarlo ahí, guardarlo, y en el producto, y simplemente lo voy a pegar ahí, perfecto. Entonces, ahora que ya está hecho, solo voy a mirar a este empleado y mostrarles que ya marqué todos los demás modelos como serializables, por lo que no necesito hacer esto para más modelos.

Uso NCache Métodos de extensión de EF Core

Entonces, ahora que nuestros modelos están marcados como serializables, eso nos lleva al quinto paso. Y el quinto paso es el más interesante, donde usaremos la versión real. NCache Métodos de extensión principales de Entity Framework dentro de nuestra aplicación. Ahora bien, esto dependerá del caso de uso de los datos que existen dentro de nuestra aplicación, y estos podrían ser uno de dos casos de uso. Podríamos tener datos transaccionales o podríamos tener datos de referencia en nuestra aplicación.

Manejo de datos transaccionales

Entonces, si hablamos de datos transaccionales, y cuando hablamos de manejar datos transaccionales, los datos transaccionales son los datos que se espera que se lean y se escriban con mucha frecuencia. Un buen ejemplo de estos datos sería llevar un registro de vuelos. Entonces, hay muchos vuelos que ocurren dentro de un día, y todos ellos tienen algo diferente, por lo que si los registrara en una base de datos, escribiría constantemente nuevos vuelos, y eso puede considerarse un caso de uso transaccional. . Entonces, cuando tenemos este tipo de caso de uso transaccional en nuestras aplicaciones, para ese tipo de datos decimos que es ideal usar el método de extensión 'FromCache'.

Ahora, lo que hace el método de extensión FromCache es la primera vez que funciona, funciona y se comporta como una aplicación Entity Framework Core normal donde sus entidades se recuperan de la base de datos. Sin embargo, en este momento el método FromCache llena esas entidades en la caché, y el beneficio de esto es que la próxima vez que tenga que llamar a esas consultas, o necesite esas entidades en su aplicación, no regresará completamente a la caché. base de datos para obtener esas entidades y, en su lugar, las recupera rápidamente del caché y recibe el beneficio de un alto rendimiento y rápidamente prepara todos sus datos para su aplicación.

Ahora, sigamos adelante y hagamos esta implementación y echemos un vistazo a cómo funciona. Entonces, volviendo a nuestra aplicación, lo que voy a hacer aquí es trabajar con pedidos y agregar algunas opciones de almacenamiento en caché de pedidos, ahí vamos, y digo que tengo 'nuevas Opciones de Caching()'. 'aquí, y simplemente voy a definir 'StoreAsType' como una 'Colección'. Entonces, quiero que todos los pedidos se almacenen como una única colección en el caché. También quiero que caduquen, así que voy a agregar un vencimiento, así que voy a 'SetSlidingExpiration'. Voy a agregar un 'TimeSpan()' de 10 minutos para que estos pedidos caduquen después de 10 minutos, perfecto . Y ahora que ya está hecho, me desplazaré hacia abajo aquí y agregaré el método de extensión '.FromCache' y agregaré 'order_caching_options', perfecto. Eso es todo lo que necesito hacer aquí.

var order_caching_options = new CachingOptions()
{
	StoreAs = StoreAs.SeparateEntities
};
order_caching_options.SetSlidingExpiration(new TimeSpan(0, 10, 0));

//Orders 
var order_resultset = context.Orders
		     .Where(o => o.OrderId >= 10249 && o.OrderId <= 10268)
		     .FromCache(order_caching_options)
		     .ToList();

Console.WriteLine($"Orders between 10249 and 10268 fetched: {order_resultset.Count}
\n--------------------------------------------------------------------------\n\n"
+ String.Format("{0,-25}  {1,-40}  {2,-10}", $"Order ID", $"Date", $"Shipper Name") + "\n");

order_resultset.ForEach(order =>
{
    Console.WriteLine(String.Format("{0,-25}  {1,-40}  {2,-10}", $"{order.OrderId}", $"{order.OrderDate}", $"{order.ShipName}"));
});

Ahora, antes de ejecutarlo, echemos un vistazo a nuestro caché. Ahora, aquí tengo la configuración 'EFCoreCache' en mis dos nodos que podemos ver aquí. Si va al Monitor, podemos ver que está completamente conectado, en buen estado, funcionando y en buen estado, sin nada dentro. Y, si vamos a las estadísticas, esto nos cuenta la misma historia, es un caché saludable con cero elementos en su interior listos para funcionar, perfecto. Ahora, sigamos adelante y ejecutemos nuestra aplicación, y echemos un vistazo a los resultados que obtenemos, perfectos.

Ahora que la aplicación está ejecutada, cerraré esta ventana de consola aquí y podremos ver estas solicitudes que obtuvimos en nuestro caché en esta adición que ocurrió, y si nos desplazamos hacia abajo podemos ver este recuento, lo que significa que nuestra colección se ha completado en el caché.

Ahora, si ejecuto 'export-cachekeys', perfecto, podemos ver esta colección que se ha ingresado en el caché. Ahora, digamos que quiero agregar cada pedido como una entidad separada, así que lo que voy a hacer es agregar 'SeparateEntities' a mi tipo 'StoreAs' en lugar de colección. Voy a ejecutar esta aplicación nuevamente. . Y ahora lo que esto hará es que, en lugar de esa colección única, agregará esos pedidos como entidades separadas. Ahora que las aplicaciones se ejecutan, puedo cerrarlas y podemos ver toda esta actividad que sucedió y, lo que es más importante, estas adiciones. Estas 16 y 4 incorporaciones, y este conteo que ha subido.

Entonces, si vamos a Estadísticas, podemos ver 16 y 5. Ahora, voy a exportar las claves de caché nuevamente y podemos ver que tenemos un recuento de caché de 21 y que todos nuestros pedidos se han completado por separado. entidades en el caché, así como una colección. Entonces, eso es perfecto, y en cierto modo resume cómo se usa el método de extensión FromCache.

Manejo de datos de referencia

Ahora, hablemos de cómo maneja los datos de referencia y qué son los datos de referencia. Los datos de referencia son el tipo de datos que se leen con mucha más frecuencia de lo que se escriben. Entonces, estos son datos que más o menos permanecen bastante estáticos. Por ejemplo, tienes un catálogo de productos. Ahora no se espera que sus productos cambien con mucha frecuencia, por lo que podrían ser datos de referencia que se leen constantemente desde la base de datos y que rara vez, o nunca, se modifican. Y, en el caso de los datos de referencia, la recomendación es que traiga todo su conjunto de trabajo de datos de referencia al caché y luego solo lea del caché cuando desee recuperar esos datos de referencia. Déjame mostrarte cómo vas a hacer eso.

Entonces, el primer método que tenemos, o el segundo método de extensión que tenemos, es el método de extensión 'LoadIntoCache()'. Ahora, el método de extensión LoadIntoCache() es extremadamente poderoso para cargar su conjunto completo de datos de trabajo en el caché. Entonces, esto ejecutará la consulta en la base de datos, obtendrá el resultado de la consulta, completará el resultado completo de la consulta en el caché y luego devolverá ese resultado a la aplicación.

Y esto es útil nuevamente para llevar los datos al caché, y puede ejecutarlo en intervalos regulares siempre que espere que los datos cambien. Por lo tanto, si espera que los datos cambien dentro de una semana, puede ejecutarlos nuevamente después de una semana para seguir actualizando los datos en el caché y asegurarse de no recibir resultados parciales cuando consulte solo desde el caché para estas entidades. Hablando de consultar sólo desde el caché, la forma en que lo haría es utilizando el método de extensión 'FromCacheOnly()'. Ahora, el método de extensión FromCacheOnly() solo busca datos dentro del caché y nunca va a la base de datos back-end para obtener esos resultados. Este es un método de extensión extremadamente rápido y garantiza que usted reciba el beneficio completo de rendimiento del almacenamiento en caché en memoria, ya que recibe todas las entidades de un caché agrupado y nunca tendrá que mirar su base de datos.

Ahora, sigamos adelante e implementemos estos métodos de extensión en nuestra aplicación. Pero hay un requisito previo que debemos completar antes de usarlos. Entonces, para usar estos métodos de extensión de datos de referencia, tendríamos que definir los índices de consulta dentro de nuestra aplicación, y esto se puede hacer de dos maneras. Ahora, puedo crear dinámicamente esos índices de consulta aquí agregando la etiqueta '[QueryIndexable]' que también incluirá el espacio de nombres 'NCache.Runtime.Caching’ en la aplicación y ahora lo he hecho dinámicamente. Pero voy a hacer esto de otra manera. Entonces, voy a comentar esto aquí, y si voy a las cachés de mi clúster, puedo mostrarles que ya he definido estos índices de consulta en mi caché, como podemos ver aquí.

Entonces, como ya hice esto, no necesito agregarlos dinámicamente dentro de mi aplicación. Entonces, ahora que ya está establecido, me desplazaré hacia abajo y tengo este fragmento de código aquí, y todo lo que hace, simplemente lo descomentará, es recuperar los productos de la base de datos. Los almacenará como entidades separadas usando el método de extensión 'LoadIntoCache()', y eso es todo lo que hará. Entonces, ahora voy a seguir adelante y ejecutar esto, y echemos un vistazo a los resultados que arroja, perfecto.

//Load ALL Products Into Cache
var products_caching_option = new CachingOptions
{
    StoreAs = StoreAs.SeparateEntities
};
var all_products = (from products in context.Products
                    select products)
                    .LoadIntoCache(products_caching_option)
                    .ToList();
Console.WriteLine($"\n\nAll Products Loaded into cache : {all_products.Count}\n\n");
all_products.ForEach(product =>
{
    Console.WriteLine(String.Format("{0,-25}  {1,-40}  {2,-10}", $"{product.ProductId}", $"{product.ProductName}", $"{product.UnitPrice}"));
});

Entonces, podemos ver que tenemos estos 77 productos cargados en el caché, y podemos ver este recuento que ha aumentado, estas adiciones que han ocurrido y estas solicitudes que han llegado. Si vamos a las estadísticas Podemos ver 42 y 57.

Ahora voy a exportar las claves de caché nuevamente, perfecto. Entonces, podemos ver estos 99 elementos dentro de nuestro caché y todo nuestro conjunto de productos de trabajo se ha incorporado al caché. Ahora que tenemos todo nuestro conjunto de trabajo dentro del caché, es seguro para mí volver a donde estaba consultando los productos, así que solo voy a comentar esto, vamos a subir y Voy a agregar el método de extensión 'FromCacheOnly()' donde estaba buscando mis productos, perfecto. Y ahora que ya está hecho, simplemente puedo ejecutar la aplicación nuevamente. Y echemos un vistazo a los resultados que obtiene mi aplicación con ese método de extensión 'FromCacheOnly()'. Aquí vamos.

Entonces, podemos ver que obtuvimos la misma cantidad de productos, esos 11 productos, por lo que sabemos que tenemos un resultado completo aquí y podemos ver que esta recuperación ocurrió desde nuestro caché, y esta actividad, lo que significa que este FromCacheOnly( ) el método de extensión funcionó y nos obtuvo los resultados del caché.

Específico del núcleo EF NCache API

Eso es todo por los métodos de extensión FromCacheOnly() y LoadIntoCache(). Ahora podemos hablar de la Específico de EF Core NCache API. Asi que, NCache le brinda la posibilidad de que no necesariamente tenga que usar un método de extensión para insertar o eliminar datos del caché. También puede obtener el identificador de caché del contexto usando la biblioteca EF Core y luego, usando ese identificador de caché, puede insertar entidades independientes y eliminar entidades independientes del caché. Una cosa que agregaría aquí es que esto no es lo mismo que el NCache API disponibles dentro del NCache SDK, y esta es la API dedicada o específica de Entity Framework Core.

Entonces, si echamos un vistazo a estas API y observamos cómo funcionan. Así es como los usaríamos. Entonces, recuperaríamos el caché del contexto y luego insertaríamos datos en el caché simplemente ejecutando un cache.Insert contra el cliente y proporcionando una clave de caché de cadena de salida. Esta clave de caché sería generada por las API principales de Entity Framework. Y luego, cuando desee eliminar un dato o eliminar algún elemento del caché usando el mismo identificador de caché, podría, por ejemplo, encontrar esos datos dentro del caché usando context.find y luego simplemente realizar un cache.Remove.

Ahora, sigamos adelante y hagamos esto en nuestra aplicación. Entonces, si vuelvo a mi aplicación aquí y me desplazo hacia abajo, tengo este fragmento de código que agrega el cliente al caché. Simplemente voy a descomentar este código, y si se desplaza hacia arriba podemos ver que simplemente estoy obteniendo el caché del contexto que crea este cliente y quiero almacenarlo como una entidad separada, quiero guardar los cambios. y realice este caché. Inserte y luego escriba que he agregado este cliente al caché. Entonces, sigamos adelante, ejecútelo y echemos un vistazo a lo que hace.

//Add Customer Using Cache Handle
Cache cache = context.GetCache();
var cust = new Customer
{
    CustomerId = "HANIH",
    ContactName = "Hanih Moos",
    ContactTitle = "Sales Representative",
    CompanyName = "Blauer See Delikatessen",
};

var options = new CachingOptions
{
    StoreAs = StoreAs.SeparateEntities
};

context.Customers.Add(cust);
context.SaveChanges(true);

cache.Insert(cust, out string cacheKey, options);
Console.WriteLine($"Customer ID: {cust.CustomerId} -> Added to Cache");

Entonces, podemos ver que agregamos este cliente al caché. Entonces, si cierro esta aplicación, podemos ver esta adición que se han realizado estas solicitudes, y podemos ver una pequeña caída, por lo que hemos pasado de 42 a 43. Si vamos a las estadísticas, podemos ver 43 y 57. lo que completa 100. Entonces, si exporto las claves de caché, podemos ver ese cliente independiente, ahí vamos. Entonces, podemos ver esa entidad separada e independiente que hemos agregado al caché. Eso es perfecto.

Ahora, sigamos adelante y eliminemos este cliente. Entonces, solo voy a comentar este fragmento de código. Nuevamente, me desplazaré hacia abajo aquí y descomentaré este fragmento de código, y todo lo que este fragmento de código hace es buscar al cliente dentro del caché del mismo nombre de cliente, y si encuentra ese cliente, es Lo eliminaré del contexto, guardaré los cambios y luego lo eliminaré del caché. Y luego imprimirá que así lo ha hecho. De lo contrario, dirá que no pudo encontrar al cliente.

//Remove Customer Using Cache Handle
Cache cache = context.GetCache();
Customer customerToRemove = context.Customers.Find("HANIH");
if (customerToRemove != null)
{
    context.Customers.Remove(customerToRemove);
    context.SaveChanges(true);
    cache.Remove(customerToRemove);
    Console.WriteLine($"Customer ID: {customerToRemove.CustomerId} -> Removed from Cache");
}
else
{
    Console.WriteLine("could not find the customer within the cache");
}
Console.ReadLine();

Entonces, sigamos adelante, ejecutemos esta aplicación y echemos un vistazo a los resultados, perfecto. Entonces, podemos ver que el cliente ha sido eliminado del caché, y podemos ver en las estadísticas que hemos pasado de 43 a 42, y el monitor mostraría lo mismo, perfecto.

Ahora, si volvemos a las estadísticas, simplemente abriré el NCache PowerShell, y voy a exportar las claves de caché, perfecto. Y podemos ver que ya no tenemos ese cliente en nuestro caché. Y así es como puede agregar y eliminar clientes o cualquier dato utilizando el NCache API específicas de EF Core.

Siguientes Pasos

Descargar NCache

Y eso nos lleva al final de esta demostración, muchas gracias. Si quieres descargar NCache Puede recibir una prueba gratuita de 30 días y un producto funcional completo con todas las funciones desde nuestra página de descargas. Déjame llevarte allí ahora. Entonces, si venimos aquí, puedes ver que estas son las ofertas para .NET que puedes descargar para Windows y Linux que NCache proporciona.

Prueba el patio de recreo

Además, puedes probar NCache en el NCache Patio de juegos. Además, puede tener una idea del producto y ver cómo funcionan sus funciones. Entonces, si vas aquí al Prueba el patio de recreo Puede ver que puede iniciar esta sesión de espacio aislado durante 30 minutos que le permite ejecutar algunos ejemplos y ver cómo se ejecutarían y cómo se sentirían los ejemplos de .NET y Java.

Programe una personalizada NCache De demostración

Y por último, puedes reservar un viaje personalizado. NCache demostración donde le brindaríamos una sesión técnica de una hora donde discutiríamos NCache arquitectura y características, y mapearlas según el caso de uso que encontremos dentro de sus entornos. Y hacer eso es extremadamente simple. Simplemente deberá visitar nuestro sitio web aquí y programar esta demostración personalizada en vivo desde esta página aquí. Y una vez que esté aquí, puede enviar esa solicitud, la recibiremos y programaremos algo. Y eso nos lleva al final de esta demostración. Muchas gracias por mirar, que tengas un día maravilloso. Adiós.