Los problemas modernos requieren soluciones modernas. Y la necesidad de un rendimiento rápido siempre ha sido un problema. NCache es una solución rápida para sus problemas críticos, como el rendimiento y la escalabilidad. Funciona de manera eficiente y cubre todas las áreas problemáticas de su aplicación, aunque el almacenamiento en caché tiene su propósito principal para aplicaciones de lectura más intensiva. Este blog explica detalladamente cómo NCache es la mejor opción para sus aplicaciones de lectura intensiva.
NCache Detalles Escalabilidad en NCache NCache Rendimiento
La necesidad del almacenamiento en caché
Empecemos por el principio y veamos por qué es necesario el almacenamiento en caché. Su respuesta simple es el tiempo de respuesta de las bases de datos. Es un hecho que el almacenamiento principal (su base de datos) que contiene todos los datos en un solo lugar puede ahogarse debido a una tasa de respuesta más alta. ¿Qué lo soluciona? Almacenamiento en caché, ya que proporciona almacenamiento en memoria y un tiempo de respuesta más rápido.
En segundo lugar, a diferencia de una base de datos, un caché que se distribuye en la naturaleza no tiene un único punto de falla. La carga se divide y, por lo tanto, hay menos posibilidades de que las solicitudes hagan que los servidores se ahoguen.
Teniendo en cuenta los hechos anteriores que acabamos de analizar, hemos establecido que el almacenamiento en caché es la mejor opción para situaciones en las que la intensidad de escritura no es muy alta, pero la intensidad de lectura es relativamente mayor.
Consideremos un sitio web que contiene información sobre el sistema de transporte. Las tarifas de los autobuses y los horarios suelen ser estáticos, lo que significa que no cambian con frecuencia. Estas aplicaciones con datos de lectura más intensiva tienen un amplio conjunto de funciones proporcionadas por NCache para realizar operaciones de lectura más rápidas.
NCache Detalles NCache Para el almacenamiento en caché de datos Alta disponibilidad
NCache como almacén de caché de lectura intensiva
Las aplicaciones con una naturaleza de lectura intensiva, tienen NCache para realizar todas las operaciones de lectura lo más rápido posible. NCache tiene un amplio conjunto de funciones que se adaptan a todo tipo de operaciones de lectura, como obtener elementos individuales o masivos. Una vez que la memoria caché recibe datos de la base de datos, todas las operaciones de obtención van directamente a la memoria caché para lograr un mayor rendimiento y escalabilidad.
NCache Detalles Operaciones CRUD Escalabilidad en NCache
Obtener operaciones en NCache
NCache proporciona varias sobrecargas del Obtener() método para obtener datos de la memoria caché contra una clave específica. Estas operaciones son de naturaleza síncrona y devuelven un objeto de tipo emitido de acuerdo con su lógica personalizada. En caso de que no exista ningún elemento en el caché, devuelve nulo.
Mire el código a continuación donde un cliente quiere ver los detalles de la dirección para asegurarse de que sean correctos usando el normal Obtener() método:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// Pre-condition: Cache is already running // Items are already present in the cache // Initialize Cache ICache cache = CacheManager.GetCache("demoCache"); string customerKey = "Customer:ALFKI"; // Retrieve the Customer object Customer customer = cache.Get<Customer>(customerKey); if (customer != null) { Console.WriteLine($"Customer: {customer.ContactName}, Address : {customer.Address}"); } |
NCache también permite al usuario Añada, Actualizary Eliminar datos de la caché.
NCache Detalles obtener operación Operaciones atómicas
Obtener elementos masivos de caché
Del mismo modo, también puede obtener elementos a granel del caché usando el Obtener a granel() método. Con esto, puede obtener numerosos elementos del caché con una sola llamada.
El siguiente ejemplo muestra cómo se obtienen varios clientes de la memoria caché mediante una sola operación.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Pre-condition: Items are already present in the cache // Create an array of all keys to fetch String[] keys = new String[] { "Customer:ALFKI", "Customer:ANATR", "Customer:ANTON", "Customer:AROUT", "Customer:BERGS" }; // Get items from cache IDictionary<string, Customer> retrievedItems = cache.GetBulk<Customer>(keys); // Retrieve customers and their addresses from dictionary foreach (KeyValuePair<string, Customer> retrievedItem in retrievedItems) { Console.WriteLine($"Customer: {retrievedItem.Value.ContactName}, Address : { retrievedItem.Value.Address}"); } |
Además, NCache proporciona al usuario a Añada, recuadroy Eliminar datos masivos en una sola llamada.
NCache Detalles Operaciones CRUD Operación a granel
Obtener artículos usando palabras clave
También puede buscar elementos usando palabras clave adjuntas para una búsqueda efectiva. Marca sus datos con ciertas palabras clave basadas en cadenas y recupera los elementos con la ayuda de estas palabras clave. Por ejemplo, desea agrupar determinados clientes según la región a la que pertenecen, como Costa Este o Costa Oeste. El cierto conjunto de características proporcionadas por NCache para este fin es:
Etiquetas con nombre | Etiquetas | Grupos |
---|---|---|
Proporcionado en forma de diccionario. | Proporcionado en forma de una matriz de etiquetas | Proporcionado en forma de cadena |
Puede ser de cualquier tipo de datos primitivo | Solo basado en cadenas | Solo basado en cadenas |
En el ejemplo que se muestra a continuación, el usuario desea ver los detalles de todos los clientes que tienen un 12 % de descuento en la membresía VIP mediante una consulta SQL.
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 |
// Pre-conditions: Items are already present in the cache with named tags // Custom class is query indexed through NCache Web Manager or config.ncconf // Create SQL Query with the specified criteria // Make sure to use the Fully Qualified Name for custom class string query = "SELECT CustomerID, ContactName FROM Alachisoft.NCache.Samples.Data.Customer WHERE VIP_Membership_Discount = 0.12"; // Use QueryCommand for query execution var queryCommand = new QueryCommand(query); // Executing Query ICacheReader reader = cache.SearchService.ExecuteReader(queryCommand); // Read results if result set is not empty if (reader.FieldCount > 0) { while (reader.Read()) { // Get the value of the result set string customerID = reader.GetValue<string>("CustomerID"); string customerName = reader.GetValue<string>("ContactName"); Console.WriteLine($"Customer '{customerName}' with ID '{customerID}' has VIP membership discount."); } } else { Console.WriteLine($"No VIP members found"); } |
Para otras operaciones que utilizan etiquetas con nombre, consulte NCache Docs.
NCache Detalles Lector de ICache Buscar datos de caché con etiquetas con nombre
Caché de búsqueda usando SQL
Para obtener elementos de una base de datos en particular, las consultas son una forma efectiva de buscar con ciertos criterios. NCache entiende completamente la necesidad de consultas, lo que le permite obtener elementos del caché usando similar a SQL consultas Además, necesita índice el elemento particular en el caché, ya que no crea índices por sí solo, a diferencia de la base de datos. Pero está listo para usar la consulta SQL una vez que se indexan los datos.
Proporciona API compatibles con ADO.NET como Ejecutar Lector, Ejecutar Escalary ExecuteNonQueryExecuteNonQuery para buscar (SELECCIONAR) y eliminar (ELIMINAR) datos del caché.
Las siguientes son las cosas admitidas en NCache consultas:
- Operadores de consulta básicos (=, ==, !=. LIKE, NOT LIKE)
- Operadores lógicos (Y, O, NO)
- Funciones agregadas (SUM, COUNT, AVG, MIN, MAX)
- Observaciones
Mire el código a continuación para ver cómo las consultas similares a SQL buscan a través del caché. El siguiente ejemplo muestra a un usuario que ha aplicado el filtro para mostrar solo aquellos productos que tienen un precio unitario inferior a 100.
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 |
//Pre-condition: Items are already present in the cache // Use the Fully Qualified Name (FQN) of your own custom class string query = "SELECT * FROM Alachisoft.NCache.Samples.Data.Product WHERE UnitPrice < ?"; // Use QueryCommand for query execution var queryCommand = new QueryCommand(query); // Providing parameters for query queryCommand.Parameters.Add("UnitPrice", 100.0); // Executing QueryCommand through ICacheReader ICacheReader reader = cache.SearchService.ExecuteReader(queryCommand); // Read results if result set is not empty if (reader.FieldCount > 0) { while (reader.Read()) { // Get key of product item in cache string productKey = reader.GetValue<string>("$KEY$"); // Get product attributes string productName = reader.GetValue<string>("ProductName"); double unitPrice = reader.GetValue<double>("UnitPrice"); Console.WriteLine($"Product '{productName}' with key '{productKey}' has UnitPrice {unitPrice}"); } } else { Console.WriteLine($"No product found with price less than 100"); } |
NCache Detalles Operaciones compatibles con SQL consulta SQL
Caché de búsqueda usando LINQ
como sql, NCache proporciona soporte para escribir consultas en LINQ para buscar en el caché. NCache Conversiones del proveedor LINQ Consultas relacionadas con LINQ dentro NCachede SQL extendido y devuelve los resultados correspondientes después de transformarlo en formato LINQ. Hay dos tipos de sintaxis para escribir consultas LINQ:
- Expresión Lambda
- Expresión de consulta LINQ simple
Sin embargo, al igual que SQL, debe definir índices para los datos de caché que se pueden buscar para que su consulta se ejecute sin problemas.
Mire el ejemplo de código a continuación para ver cómo la consulta LINQ obtiene un objeto del caché. El usuario ha aplicado el filtro para mostrar Bebidas o Productos lácteos con al menos 10 unidades en stock.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// Pre-condition: Items are already present in the cache // Create custom class LINQ object IQueryable<Product> products = new NCacheQuery<Product>(cache); // LINQ query to search cache IQueryable<Product> result = from prod in products where (prod.Category == "Beverages" || prod.Category == "Dairy") && prod.UnitsInStock > 10 select prod; if (result != null) { foreach (Product product in result) { Console.WriteLine($"Product '{product.ProductName}' in Category '{product.Category}' has stock of '{product.UnitsInStock}' units"); } } else { Console.WriteLine($"No product found"); } |
NCache Detalles Consulta LINQ Operadores básicos de LINQ
Concluyendo el Blog
NCache en realidad es una potente solución de almacenamiento en caché para aumentar el rendimiento de las aplicaciones de lectura intensiva. Aumenta la velocidad y mejora el rendimiento, la escalabilidad y la confiabilidad con un amplio conjunto de funciones. Por favor, echa un vistazo a otros NCache Características desde nuestro sitio web.