Usar NCache en EF Core con Oracle
Hola a todos, soy Sean y hoy les mostraré cómo integrarse NCache en tu existente Aplicaciones principales de Entity Framework que están configurados con una base de datos Oracle. Haremos esto como una demostración práctica en la que trabajaremos con una aplicación de muestra que ya configuré para esta demostración y vamos a integrar NCache en ello. Así que son cosas muy interesantes las que hemos preparado. Déjame mostrarte cómo lo vamos a hacer.
Ejemplo de aplicación EF Core
Entonces, lo primero que tengo aquí es la aplicación de muestra en sí. Como pueden ver aquí, tengo la aplicación de muestra y estoy obteniendo algunos pedidos, clientes y productos aquí. Y tengo esto configurado para funcionar con una base de datos Oracle, que puedo mostrarles aquí. Si vamos al contexto, puedes ver que tengo este método UseOracle aquí para trabajar con mi base de datos Oracle.
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}Entonces, antes de ejecutar este programa, permítanme llevarlos a la base de datos y mostrarles con qué estamos trabajando. Entonces, estoy trabajando con la base de datos Northwind en Oracle. Y como tenemos muchas mesas, abrí aquí aquellas con las que estoy trabajando para que podamos verlas. El primero es PEDIDOS, y podemos ver estas propiedades aquí para los pedidos con los que vamos a trabajar. Entonces, echemos un vistazo a nuestros PRODUCTOS. Entonces, estas son las propiedades del producto que obtendremos o recuperaremos en nuestra aplicación. Y luego, la tercera tabla es CLIENTES, y podemos ver las propiedades de nuestros clientes aquí mismo. Y esas son prácticamente todas las tablas con las que vamos a trabajar.
Ahora, consultemos estas tablas y echemos un vistazo a lo que tenemos dentro. Entonces, puedes ver que tengo 77 productos en mi base de datos de Northwind, y estos son todos los productos aquí. Entonces, eso está muy bien. Ahora, echemos un vistazo a CLIENTES, clientes e ingrese, y si me desplazo hacia abajo, ¡perfecto! Entonces, podemos ver que tengo 89 clientes en mi base de datos de Northwind y todos esos clientes están aquí, como pueden ver frente a ustedes.
Ahora, echemos un vistazo a nuestros pedidos. Ahora, habrá muchos pedidos, desplácese hasta el final, ¡perfecto! Entonces, podemos ver que tenemos 830 pedidos en nuestra base de datos. Son muchos pedidos, y podemos verlos todos aquí. Entonces, vamos a buscar algunos criterios en la aplicación, y lo haremos ahora.
Así que ahora que la aplicación se ha ejecutado, podemos verlo perfectamente. Ahora permítanme desplazarme hacia arriba para ver estos productos entre ID 25 y 50. Entonces, tenemos 26 productos; clientes que son del Reino Unido, por lo que tenemos siete clientes; y pedidos entre 10280 y 10300, por lo que tenemos estos 21 pedidos, ¡perfecto!
NCache Configuración para EF Core
Entonces, ahora que sabemos que el ejemplo está funcionando, podemos continuar con la configuración. NCache en nuestra aplicación Entity Framework Core. Entonces, configurar nuestra aplicación para trabajar con NCache Es tan simple como cinco pasos que vamos a seguir en esta demostración.
- 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, comencemos con el primer paso, que es instalar el NCache Paquete Entity Framework Core NuGet en nuestra aplicación. Entonces, si me dirijo a los paquetes NuGet en mi aplicación, estamos buscando EntityFrameworkCore.NCache Paquete NuGet, que está justo aquí. Tengo esto instalado en mi aplicación, así que podemos verlo aquí. Y estoy ejecutando la versión 5.3.2.1, que corresponde a NCache versión 5.3 SP2. Entonces, eso es perfecto. Ahora, sigamos adelante, cerremos esta pestaña y pasemos al siguiente paso.
Añada NCache Espacio de nombres EntityFrameworkCore
Entonces, el siguiente paso es agregar el NCache Espacio de nombres Entity Framework Core en la aplicación. Entonces, abramos el código nuevamente y entremos a nuestro programa aquí. Y solo voy a agregar:
using Alachisoft.NCache.EntityFrameworkCore¡Perfecto! Así que guardaré esto, iré al contexto del modelo y lo pegaré aquí. ¡Perfecto! Entonces, una vez hecho esto, podemos pasar al siguiente paso, que es especificar las configuraciones de caché en el contexto de la base de datos.
Especificar configuraciones de caché en el contexto de la base de datos
Entonces, me desplazaré hacia abajo hasta mi método de configuración, agregaré el nombre del caché con el que vamos a trabajar y pasaré el NCache configuración. Entonces, este será mi 'efcoreoraclecache', ¡perfecto! Y tengo que agregar el NCacheConfiguración.Configurar el nombre del caché junto con DependencyType, que será Oracle, ¡perfecto! Y eso es prácticamente todo lo que tengo que hacer aquí.
...
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
string cache = "efcoreoraclecache";
NCacheConfiguration.Configure(cache, DependencyType.Oracle);
optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}
...Ahora echemos un vistazo al caché con el que vamos a trabajar. Como puede ver, tengo mi EFCoreOracleCache configurado aquí mismo en estas dos máquinas de demostración. Y echemos un vistazo a los detalles de este caché. Entonces, desde aquí, si queremos monitorear este caché, podemos hacer clic en este botón de monitor. Eso nos llevará al monitor que nos muestra el estado de nuestro caché y podemos ver que está bien y limpio y que tenemos un caché saludable con el que trabajar.
Si volvemos a nuestros detalles y hacemos clic en estadísticas, eso nos llevará a esta página que nos muestra las estadísticas de nuestro caché. Ahora, si volvemos a nuestro monitor, volvemos a nuestra aplicación y abrimos el siguiente paso.
Hacer modelos serializables
Entonces, el siguiente paso es hacer que nuestros modelos sean serializables. Perfecto. Ahora voy a pasar a mi modelo de cliente. Entonces eso va a quedar por ahí. Perfecto. Y solo voy a agregar [Serializable] aqui. Perfecto. Ahora que ya está hecho, puedo pasar a mi pedido. Y puedes ver que ya está marcado como [Serializable]. Y mi producto, que nuevamente ya está marcado como [Serializable]. Entonces, todos mis modelos son serializables y estamos listos para comenzar. Así que ahora podemos pasar al siguiente paso.
Uso NCache Métodos de extensión de EF Core
El siguiente paso es usar el NCache Métodos de extensión de Entity Framework Core dentro de nuestra aplicación. Y voy a hacer una pausa aquí porque los métodos de extensión que elijamos usar dependerán del tipo de datos que realmente estemos almacenando en caché.
Entonces, hay dos tipos de datos que podemos almacenar en caché: el primer tipo es transaccional y el segundo tipo es de referencia. Qué son estos tipos y cómo se supone que debes manejarlos es algo que abordaremos en breve. Así que hablemos del primero. Perfecto.
Manejo de datos transaccionales
Entonces, el primer tipo de datos que puede manejar son los datos transaccionales. Ahora bien, los datos transaccionales son datos que tienen un caso de uso intensivo de lectura y escritura. Entonces, un buen ejemplo de esto serían los datos de vuelos donde cada día hay tantos vuelos y esos datos se escriben en la base de datos todos los días, y también se obtienen de la base de datos todos los días. Este es un caso de uso intensivo de lectura y escritura que califica esos datos como transaccionales. En nuestro caso, se puede asignar un caso de uso similar a nuestros pedidos. Entonces podemos considerar nuestros pedidos como nuestros datos transaccionales. Entonces, cuando hablamos de manejar datos transaccionales en Entity Framework Core con NCache, usaremos el Desde caché() método de extensión.
Ahora, cuando asocie este método de extensión antes de sus consultas existentes, la primera vez que lo ejecute, se ejecutará como una consulta estándar. Su aplicación irá a la base de datos y buscará las entidades desde allí. Sin embargo, esta vez su aplicación las almacenará en caché en su caché agrupada, por lo que la próxima vez que su aplicación intente recuperar esas entidades, no hará ese viaje hasta la base de datos de back-end, sino que irá para traer esas entidades del caché agrupado nuevamente a su aplicación. Así que echemos un vistazo a cómo funciona este método.
Entonces, si vengo a mi solicitud, aquí estoy trayendo mis pedidos. Así que voy a agregar algunas opciones de almacenamiento en caché de pedidos. Así que voy a agregar order_caching_options aquí, y estas serán "nuevas CachingOptions". Así que voy a especificar mi tipo de tienda aquí para decir que quiero obtener una colección única de todos mis pedidos. Entonces StoreAs.Collection y luego complételo en mi caché. Además, voy a agregar una caducidad absoluta de 10 minutos a estos datos porque cuando se trata de datos transaccionales, estos datos cambian con frecuencia, por lo que conviene actualizarlos con la mayor regularidad posible. Así que voy a poner este vencimiento en 10 minutos para que después de 10 minutos, este conjunto de datos se actualice dentro del caché. Así que ahora voy a agregar el .FromCache () método de extensión y agregue mi order_caching_options dentro, y eso es perfecto. Esto es absolutamente perfecto y esto es todo lo que tenemos que hacer.
using OracleEFCore.Models;
using Alachisoft.NCache.EntityFrameworkCore;
namespace OracleEFCore
{
internal class Program
{
static void Main(string[] args)
{
using (var context = new Models.ModelContext())
{
//-----Orders-----
var order_caching_options = new CachingOptions()
{
StoreAs = StoreAs.Collection
};
order_caching_options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));
int upper_orderid = 10300;
int lower_orderid = 10280;
var order_resultset = context.Orders
.Where(o => o.Orderid >= lower_orderid && o.Orderid <= upper_orderid)
.FromCache(order_caching_options)
.ToList();
...Ahora, sigamos adelante, ejecutemos la muestra y echemos un vistazo a lo que obtenemos. Perfecto. Entonces se ejecuta la muestra, no hay cambios aquí, así que puedo cerrar esto aquí y ahora podemos echar un vistazo a estas solicitudes que tenemos en nuestro caché. Y podemos ver que este recuento también ha aumentado. Ahora exportemos las claves de caché para este caché y echemos un vistazo a la colección que acabamos de agregar a nuestro caché agrupado. Perfecto. Para que pueda ver esta colección que se ha agregado al caché. Eso es genial.
Pero digamos ahora que no quería poner una sola colección en el caché y en cambio quería cada pedido como una entidad separada. Bueno, en ese caso, puedo especificar la tienda como tipo para que sean entidades separadas.
//-----Orders-----
var order_caching_options = new CachingOptions()
{
StoreAs = StoreAs.SeparateEntities
};Ahora, cuando vuelva a ejecutar esta aplicación, colocará todos mis pedidos como entidades separadas en el caché. Ahora que la aplicación está ejecutada, cerrémosla. Podemos ver que el recuento ha aumentado por completo y podemos ver las adiciones que se han realizado y las solicitudes. Si me dirijo a las estadísticas, podemos ver esta cuenta de 7 y esta cuenta de 15. Perfecto.
Ahora, exportemos las claves de caché y echemos un vistazo a las claves que tenemos dentro de nuestro caché. Perfecto. Entonces tenemos estas 22 claves o elementos dentro de nuestro caché, y todos nuestros pedidos se almacenan en caché por separado. Esto resume bastante bien cómo se utiliza el método de extensión 'FromCache()'.
Manejo de datos de referencia
Ahora hablemos de cómo se pueden manejar los datos de referencia. Por lo tanto, los datos de referencia son datos que tienen un caso de uso muy intensivo en lectura pero que no se actualizan con tanta frecuencia como los datos transaccionales. Un buen ejemplo de esto sería un catálogo de productos. Entonces, cuando tiene productos en stock o un catálogo de productos, no actualiza ese catálogo con mucha frecuencia. Sus productos cambiarían quizás una o dos veces al mes. Por lo tanto, lo más probable es que simplemente lea esos datos de la base de datos y no los actualice realmente dentro de la base de datos con mucha frecuencia. Por lo tanto, tiene sentido llevar esos datos de la base de datos a una caché agrupada y luego leerlos desde una caché agrupada en memoria de alta velocidad o un almacén de datos en lugar de ir a la base de datos. Y esto proporcionará a su aplicación un alto rendimiento y escalabilidad desde almacenamiento en caché distribuido en memoria.
Entonces, cuando trabaja con datos de referencia, el primer método que usaría es el cargar en caché() método. Ahora, el método de carga en caché simplemente toma los resultados de la consulta que ejecutó en Entity Framework Core y almacena en caché esos resultados en la caché del clúster. Ahora, el método de carga en caché se puede configurar para que se ejecute en un intervalo en el que espera que se actualicen los datos.
Digamos, por ejemplo, el catálogo de productos que tenemos actualizado cada semana. Podemos configurar este método para que se ejecute todas las semanas, de modo que siga actualizando los datos en el caché y siempre tenga datos nuevos presentes en el caché.
Ahora que tiene todo el conjunto de datos dentro del caché, echemos un vistazo al tercer método de extensión, que es el DesdeCacheOnly() método de extensión. Ahora el DesdeCacheOnly() El método de extensión es un método de extensión realmente interesante que permite que solo vaya desde su aplicación al caché agrupado para recuperar sus datos en lugar de ir a la base de datos de fondo. Nunca, jamás irá a la base de datos respaldada cuando esté utilizando el DesdeCacheOnly() método de extensión.
Entonces, cuando usas este método en conjunto con el cargar en caché() Con este método, tiene un conjunto de herramientas realmente poderoso que garantiza que su caché agrupada permanezca actualizada y sincronizada con su base de datos, y que obtenga sus datos solo desde su caché agrupada.
Ahora, echemos un vistazo a cómo usaríamos estos métodos. Entonces, cuando trabaja con estos métodos, lo primero que tenemos que hacer es crear nuestros índices de consulta en estos modelos aquí. Si entramos en el cliente, una forma de hacerlo es agregar el [Consulta indexable] etiqueta encima del 'Cliente' aquí. Entonces, podemos ver esta etiqueta 'QueryIndexable[]' aquí, y esto trae esta biblioteca. Sin embargo, en mi caso, no necesito hacer esto, así que solo voy a comentarlo. La razón es que si voy a mi caché agrupada y a los detalles, nos desplazamos hacia abajo hasta la pestaña de índices de consulta aquí y podrán ver que ya agregué todos mis índices de consulta al caché. Entonces, dado que los agregué, no necesito definirlos dinámicamente.
Ahora que nuestros índices de consulta están listos, tengo este fragmento de código aquí que carga todos mis productos en el caché desde la base de datos. Entonces, continuaré y descomentaré este fragmento de código. ¡Perfecto!
// ------------------------Load ALL Products Into Cache------------------------
...
var products_caching_option = new CachingOptions
{
StoreAs = StoreAs.SeparateEntities
};
products_caching_option.SetAbsoluteExpiration(DateTime.Now.AddDays(10));
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}"));
});
...Y todo lo que hace este código es configurar que quiero poner mis productos en entidades separadas y quiero agregarlos con una caducidad de 10 días. Luego esto cargar en caché() El método es cargar los productos en el caché. Ahora, ejecutemos esto y echemos un vistazo a los resultados que obtiene. ¡Perfecto! Así que ahora, si nos desplazamos hacia arriba aquí, ¡allá vamos! Podemos ver que cargamos todos los productos en el caché, estos 77 productos.
Y luego, si podemos ver estas solicitudes que ingresaron al caché, estas adiciones que se realizaron y este recuento que aumentó por completo. Si abrimos nuestras estadísticas, podemos ver que tenemos 59 elementos en una partición y 41 en la otra.
Ahora, exportemos las claves de caché y observemos los datos que tenemos. ¡Perfecto! Entonces, tenemos 100 claves dentro de nuestro caché y todos los productos se han incorporado al caché. ¡Perfecto! Ahora que tenemos todo nuestro conjunto de datos, no tengo que volver a ejecutar este método. Voy a seguir adelante y comentar esto.
Y ahora vamos a ejecutar el DesdeCacheOnly() método de extensión en la consulta de nuestros productos que hemos estado ejecutando antes. Entonces, solo agrego '. DesdeCacheOnly(). ¡Perfecto! Y ahora, sigamos adelante y ejecutemos la muestra y echemos un vistazo a los resultados de esta búsqueda por nosotros. ¡Perfecto! Entonces, ahí vamos, 26 resultados, los mismos que obtuvimos cuando ejecutamos esta aplicación sin ningún almacenamiento en caché, lo que significa un resultado completo, y podemos ver las recuperaciones que se realizaron y las solicitudes que obtuvimos en el caché.
Específico del núcleo EF NCache API
Y eso resume bastante bien cómo puedes usar el DesdeCacheOnly() con el cargar en caché() método de extensión. Y eso nos lleva al tema específico de EF Core. NCache API que puede utilizar. Entonces, digamos, por ejemplo, que no desea utilizar los métodos de extensión y desea trabajar con entidades independientes donde está creando una entidad, persistiéndola en el contexto y luego insertándola en el caché. Bien, NCache te permite hacer eso con el Específico de EF Core NCache API. Entonces, la forma en que funcionan es que usted obtendrá el contexto de caché del contexto de EF Core dentro de su aplicación. Y luego, una vez que tenga ese contexto de caché, puede usarlo para insertar entidades en el caché o para eliminar entidades del caché.
Ahora bien, esto no debe confundirse con las API que se proporcionan en el NCache SDK. Estos son específicos de Entity Framework Core y se comportan como se supone que deben hacerlo con Entity Framework Core. Entonces, en los datos de inserción, puede ver que vamos a insertar un cliente con una clave de caché de cadena de salida. Y esta es una clave de caché proporcionada por Entity Framework Core API.
Ahora, sigamos adelante y veamos cómo funciona esto, y luego podremos ver cómo los elementos o entidades son persistentes en el caché. Entonces, si nos desplazamos hacia abajo aquí, podemos ver que puedo agregar un cliente al caché usando el identificador de caché. Entonces, voy a descomentar este fragmento de código aquí. ¡Perfecto!
//-------------------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
};
options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));
context.Customers.Add(cust);
context.SaveChanges(true);
cache.Insert(cust, out string cacheKey, options);
Console.WriteLine($"\n\nCustomer ID: {cust.Customerid} -> Added to Cache");Ahora, si puede ver que simplemente obtengo el contexto de la caché, estoy creando este cliente aquí. Digo que quiero almacenarlo como una entidad separada con una caducidad de 10 minutos, por aquí. Simplemente persisto esto dentro de mi contexto, guardo los cambios y luego realizo esta inserción de caché aquí. Y luego, imprimiendo que agregué este cliente al caché.
Ahora, sigamos adelante, ejecutemos el código y echemos un vistazo a cómo funciona. ¡Perfecto! Entonces, podemos ver que el cliente ha sido agregado al caché. Voy a cerrar esto. Podemos ver esta suma por 1 que se realizó y este aumento en nuestro recuento. Entonces, vayamos a las estadísticas. ¡Aquí vamos! Entonces podemos ver 41 y el conteo pasó de 59 a 60.
Ahora, sigamos adelante y exportemos las claves de caché. ¡Perfecto! Entonces, ¡ahí vamos! Podemos ver el cliente que se ha agregado al caché y puede ver que la API ha asignado la clave de caché a este elemento. No tuvimos que especificar una clave para agregarlo. ¡Así que es perfecto!
Ahora, sigamos adelante, déjenme aclarar esto y eliminemos este cliente que hemos puesto en el caché. Así que ahora voy a comentar este fragmento de código una vez más. Solo voy a comentar eso, desplácese hacia abajo y eliminemos al cliente usando el identificador de caché. Entonces, tengo ese código aquí. Entonces, voy a seleccionarlo todo y lo voy a descomentar aquí mismo.
//-------------------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($"\n\nCustomer ID: {customerToRemove.Customerid} -> Removed from Cache");
}
else
{
Console.WriteLine("\n\ncould not find the customer within the cache");
}Y lo que hace este código es obtener el caché del contexto nuevamente y encontrar ese cliente dentro del contexto. Y si realmente se encuentra ese cliente, entonces lo que hará es eliminarlo del contexto, guardar los cambios, luego realizar este cache.Remove() para eliminar al cliente y luego imprimirá que es hecho. De lo contrario, si no puede encontrarlo, simplemente nos dirá que no pudo encontrar al cliente dentro del caché.
Ahora, sigamos adelante, guardemos esto, ejecutemos esta aplicación y echemos un vistazo a lo que sucede. ¡Perfecto! Entonces, encontró al cliente y lo eliminó del caché. ¡Impresionante!
Ahora, cerremos esto y echemos un vistazo al recuento, y vemos que ha bajado de 60 a 59. Las estadísticas también muestran que el recuento ha bajado de 60 a 59. Ahora, exportemos las claves de caché. Deberíamos ver 100 claves ahora. ¡Perfecto! Entonces, no podemos ver que el cliente que agregamos anteriormente en el recuento haya vuelto a 100. Y eso nos lleva al final de esta demostración. Muchas gracias por mirar.
Siguientes Pasos
Descargar NCache
Ahora, como parte de los siguientes pasos, lo que puedes hacer es, si deseas descargar NCache, luego podrá obtener una prueba gratuita de 30 días, que le brindará un producto completamente funcional. Puedes hacerlo dirigiéndote a alachisoft.com aquí y luego vaya al descargar sección desde aquí, y aquí tiene las ofertas que puede descargar según sus requisitos en su versión .NET.
Prueba el patio de recreo
solicite Prueba el NCache Area de juegos por 30 minutos. Esto le brinda una especie de sesión de espacio aislado completa en la que puede jugar con el código y observar cómo se ejecutarían las muestras y tener una idea del producto en general.
Programe una personalizada NCache De demostración
Por último, también puede programar una personalizada NCache manifestación donde le proporcionaremos un volcado de una hora de la NCache Características y lo bien que funciona. También podemos asignar el tipo de caso de uso a sus puntos débiles y ver qué tan bien funcionaría el almacenamiento en caché en su entorno. Entonces, puedes simplemente completar este formulario aquí y presentar la solicitud. Puede estar seguro de que lo recibiremos y programaremos la demostración en consecuencia.
Y eso nos lleva prácticamente al final de esta demostración. Gracias por mirar. Ten un día maravilloso. Adiós.