Las estructuras de datos nativos ofrecen un método convencional de almacenamiento y recuperación de datos. A través de su implementación, brindan simultaneidad a sus aplicaciones independientes, lo cual es excelente, excepto que solo se limitan a los subprocesos dentro de un proceso de aplicación. Y con las aplicaciones escalables ejecutándose en más de un servidor, surge la necesidad de compartir el estado de las estructuras de datos entre las aplicaciones.
Aquí es donde intervienen las estructuras de datos distribuidos. Si bien ofrecen la funcionalidad de las estructuras de datos convencionales, las estructuras de datos distribuidos permiten que múltiples procesos e instancias de aplicaciones agreguen, obtengan y eliminen datos simultáneamente sin comprometer la consistencia de los datos. Estas estructuras de datos resuelven el problema que las estructuras de datos convencionales no podían resolver; estos permiten el cálculo paralelo.
Donde hace NCache encajar?
NCache, al ser una solución de almacenamiento en memoria caché, mejora todas las funcionalidades que proporcionan las estructuras de datos distribuidos. Usando NCache ya que un caché distribuido permite acceder a sus datos estructurados desde subprocesos fuera del proceso.
Puede agregar sus datos a una estructura de datos distribuidos, almacenarlos en caché en cualquiera de los servidores y maravillarse de cómo los datos ahora son accesibles para todas las aplicaciones, procesos e instancias que forman parte de su sistema, independientemente del servidor que almacenó esos datos.
Para acabar, NCache proporciona alta disponibilidad en forma de topología de réplica con particiones. Es comprensible que los datos que guarda en los servidores de caché sean importantes para usted. La pérdida de estos datos debido a una falla del servidor no es aceptable en ningún caso. Esto es exactamente por qué NCache le permite mantener réplicas de sus datos en el servidor de almacenamiento en caché para que, si uno de los nodos falla, siempre quede un conjunto replicado de exactamente los mismos datos que se pueden usar en tales escenarios. De esta manera, nunca tendrá pérdida de datos en su aplicación .NET. Además de todo esto, tendrá la autoridad para agregar nodos de servidor de almacenamiento en caché en tiempo de ejecución de acuerdo con sus requisitos.
NCache proporciona la funcionalidad de replicación, partición y escalado de datos encapsulados dentro de las estructuras de datos. Por lo tanto, los desarrolladores que utilizan estas estructuras de datos no tienen que preocuparse por la lógica de distribución dentro de sus aplicaciones .NET.
NCache Detalles Estructuras de datos en NCache
Estructuras de datos distribuidos en NCache
NCache proporciona varias estructuras de datos para lograr escalabilidad, concurrencia y precisión en su aplicación .NET. Veamos estas estructuras de datos que mejoran el rendimiento general de su aplicación.
Lista distribuida
NCache proporciona un Lista distribuida esa es una implementación nativa de .NET de la interfaz IList. NCache ser una solución de almacenamiento en caché nativa de .NET en sí misma lo beneficia cuando su aplicación también está basada únicamente en .NET. Qué mejor cosa para su aplicación .NET que todo nativo y hospitalario.
Los siguientes fragmentos de código muestran cómo crear, completar y despoblar una lista distribuida en NCache.
Una aplicación que crea y completa una lista:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Specify unique cache key for list string key = "ExpensiveProducts"; DataTypeAttributes dataTypeAttributes = new DataTypeAttributes(); dataTypeAttributes.Expiration = new Expiration(ExpirationType.Sliding, new TimeSpan(0, 2, 0)); // Create list of Product type IDistributedList<Product> list = cache.DataTypeManager.CreateList<Product>(key, dataTypeAttributes); // Get products to add to list Product[] products = FetchProductsFromDB(); foreach (var product in products) { // Add products to list list.Add(product); } |
Otra aplicación que obtiene y elimina productos descontinuados de la lista
1 2 3 4 5 6 |
// Get list of Product type IDistributedList<Product> list = IDistributedList <Customer> list = cache.DataTypeManager.GetList<Product>("ExpensiveProducts"); // Get range of discontinued products to be removed List<Product> itemsToRemove = FetchDiscontinuedProducts(); list.RemoveRange(itemsToRemove); |
Incorporar una lista distribuida en aplicaciones cotidianas es muy sencillo. A continuación se proporcionan algunos de los escenarios que representan aplicaciones que necesitan una implementación de lista distribuida.
Caso de uso: carrito de compras
Supongamos que su aplicación .NET es una plataforma de comercio electrónico. En esta aplicación, los clientes pueden agregar y eliminar artículos del carrito de compras. Para permitir que estas solicitudes se procesen en consecuencia, debe guardar los datos de cada cliente que contienen la identidad del cliente y los elementos que se agregan o eliminan de esa identificación. La forma mejor y más organizada de hacerlo es usando una lista distribuida.
Una lista distribuida, en un entorno multiservidor, guarda los datos de su cliente y los pone a disposición en todos los servidores. Puede hacer que esta lista realice un seguimiento de todos los artículos que un cliente compró, mostró interés o incluso los que eligió ignorar. Esto no solo mejora el valor general de su aplicación al mantener un registro sofisticado, sino que también hace que los datos estén altamente disponibles para usted.
Caso de uso: tabla de clasificación
Para las personas interesadas en los juegos, la tabla de clasificación actúa como una fuente vital de información, ya sea que se trate de juegos en línea o partidos mundiales. Estas personas siempre están interesadas en saber qué equipo lidera y quién se queda atrás. Información como esta se puede incorporar en una aplicación que utiliza una estructura de datos de lista para almacenar los datos requeridos y transmitirlos a todos los usuarios interesados.
NCache Detalles Listas en NCache
Cola distribuida
NCache proporciona una implementación First-in First-out conocida como Cola distribuida. Las colas se utilizan en tiempo de ejecución para almacenar información valiosa debido a su comportamiento FIFO.
IDistributedQueue es una estructura de datos fácil de entender e implementar proporcionada por NCache. Mire el código a continuación para familiarizarse con las operaciones básicas en una cola, como crear una cola, agregar y eliminar datos de ella.
Una aplicación que crea y completa la cola
1 2 3 4 5 6 7 8 9 |
string key = "CandidateQueue"; // Create Queue of Candidate type IDistributedQueue<Candidate> queue = cache.DataTypeManager.CreateQueue<Candidate>(key); foreach(var candidate in candidates) { // Add candidates to queue queue.Enqueue(candidate); } |
Otra aplicación que obtiene la cola de la memoria caché distribuida y retira el primer elemento
1 2 3 4 |
IDistributedQueue<Candidate> queue = cache.DataTypeManager.GetQueue<Candidate>("CandidateQueue"); // Remove first item of queue var firstCandidate = queue.Dequeue(); |
A continuación se mencionan algunos de los casos de uso de una cola distribuida para darle una idea aproximada de dónde puede usar una cola y qué beneficios obtendrá de ella.
Caso de uso: cola de mensajes
Su aplicación .NET alojada en múltiples servidores que entretienen a múltiples clientes a la vez necesita enviar mensajes a uno de los clientes que están usando su aplicación. ¿Que haces aqui? En un entorno distribuido, no controla la conexión entre sus servidores y los clientes, lo que significa que no sabe qué servidor recibe a qué cliente.
En tal escenario, necesita una cola distribuida para realizar un seguimiento de todos los mensajes que deben entregarse a los clientes. Esta lista se distribuye entre todos los servidores de caché para asegurarse de que todos los clientes que están conectados a su aplicación tengan acceso a los mismos datos en todo momento. NCache se encarga de la replicación de los datos distribuidos por usted. Por lo tanto, al utilizar una cola distribuida en una memoria caché distribuida, puede lograr la concurrencia de datos y una alta disponibilidad.
Caso de uso: Análisis de sentimiento
Una aplicación utilizada por una agencia de inteligencia para filtrar tweets amenazantes o confidenciales podría beneficiarse totalmente de una cola distribuida proporcionada por NCache. Supongamos que hay varios nodos que ejecutan su aplicación web. Lo que desea es procesar estos tweets en un entorno distribuido con tal precisión que un tweet no se procese más de una vez. La forma de lograr esto es si esa aplicación usa una cola distribuida para almacenar todos los tweets entrantes en ella. Esto asegurará que ningún tweet se procese dos veces y, por lo tanto, mejorará el rendimiento general y la precisión de su aplicación.
NCache Detalles Colas en NCache
HashSet distribuido
NCache proporciona una implementación extremadamente rápida y escalable de conjuntos llamados DistributedHashSetDistributedHashSet. HashSet es un tipo de datos desordenado cuyos valores son únicos y distintivos.
Veamos el código a continuación para comprender cómo puede crear y completar un HashSet.
Primera aplicación que completa un hashset
1 2 3 4 5 6 7 8 9 10 |
// Create unique keys for hashSets string mondayUsersKey = "UsersLoggedInOnMonday"; // Create hashSets of object type IDistributedHashSet<string> userSetMonday = cache.DataTypeManager.CreateHashSet<string>(mondayUsersIds); // Add user IDs for Monday userSetMonday.Add("john_smith"); userSetMonday.Add("mike_cohn"); userSetMonday.Add("mike_ross"); |
Segunda aplicación obteniendo hashset y modificándolo
1 2 3 4 5 6 |
// Getting hashset from cache IDistributedHashSet<string> userSetMonday = cache.DataTypeManager.GetHashSet<string>("UsersLoggedInOnMonday"); // Remove user with given ID from the set userSetMonday.Remove("mike_cohn"); userSetMonday.RemoveRandom(); |
Puede usar HashSets distribuidos donde su aplicación necesita realizar operaciones en datos que son únicos en su naturaleza. Estos son algunos de los escenarios de aplicaciones cuyo rendimiento se mejora con la implementación de DistributedHashSet.
Caso de uso: seguimiento de direcciones IP
Como los hashsets no contienen valores duplicados, puede usar NCacheLa implementación de HashSets distribuidos para realizar un seguimiento de todos los usuarios y visitantes del sitio web. Por ejemplo, si tiene una tienda de libros en línea, HashSets puede ayudarlo a identificar, con bastante facilidad, qué usuario está interesado en qué libros y ha comprado cuántos libros y demás.
Caso de uso: análisis de ventas de comercio electrónico
Puede guardar toda la información que necesita dentro de un HashSet. Todo lo que necesita un HashSet es un valor único para asignarle múltiples valores. Por ejemplo, desea realizar un seguimiento de todos los usuarios que han comprado algo fuera de su aplicación de tienda en línea. Quiere sus ID y, contra cada ID, quiere mantener una lista de los artículos que el cliente ha comprado, los artículos que se pusieron en la lista de deseos, los artículos que se eliminaron de la lista de deseos. Ahora que tiene toda esa información en un conjunto refinado, puede realizar múltiples operaciones con la mayor facilidad.
NCache Detalles HashSets en NCache
Diccionario distribuido
Diccionario Distribuido proporcionada por NCache es un par clave-valor que es una implementación nativa de .NET de la interfaz IDictionary. Un diccionario tiene un valor contra una determinada clave y si ese valor debe cambiarse, debe anularlo.
Puede usar IDistributedDictionary en NCache llevar un registro de productos. Puede crear y agregar/eliminar información de productos hacia y desde un diccionario de las siguientes maneras.
Primera aplicación que crea y completa un diccionario
1 2 3 4 5 6 7 8 9 10 11 12 |
string key = "ExpensiveProducts"; // Create dictionary of Product type IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key); // Adding products to dictionary Product[] products = FetchProducts(); foreach(var product in products) { string productKey = $"Product:{product.ProductID}"; dictionary.Add(productKey, product); } |
Segunda aplicación que obtiene y modifica el diccionario
1 2 3 4 5 6 7 8 9 10 11 |
// Fetch dictionary of Product type from cache IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.GetDictionary<string, Product>("ExpensiveProducts"); // Create list of keys to remove List<string> keysToRemove = FetchDiscontinuedProducts(); // Get values from dictionary against the given keys ICollection<Product> values = dictionary.Get(keysToRemove); // Remove items from dictionary with given keys int itemsRemoved = dictionary.Remove(keysToRemove); |
Un diccionario distribuido se puede utilizar en múltiples casos, demostrando ser extremadamente útil y eficiente en cada uno de ellos. A continuación se proporcionan ejemplos de tales casos.
Caso de uso: almacenamiento de valores cifrados en la memoria caché
Una de las muchas ventajas de usar un diccionario en un entorno distribuido es cuando necesita almacenar claves criptográficas. Estas claves deben estar disponibles para todos los servidores que forman parte de ese sistema distribuido. Almacena datos cifrados en uno de los servidores de caché como un valor de Diccionario junto con su clave de descifrado. Hacer tal cosa permite que todos los servidores que puedan necesitar esos datos en el futuro tengan acceso compartido no solo a los datos sino también a su clave de descifrado.
Caso de uso: almacenamiento de credenciales de inicio de sesión
Un diccionario distribuido es la forma más eficiente de almacenar y acceder a la ID de inicio de sesión y la contraseña de un usuario. Supongamos que hay una aplicación que se ejecuta en varios servidores que requiere que sus usuarios proporcionen credenciales de seguridad para que tengan acceso a datos confidenciales. Para asegurarse de que todos los servidores que atienden a su aplicación tengan acceso a esta información importante, puede almacenar en caché estos valores como pares clave-valor de diccionario. Esto asegura que si un servidor agrega un nuevo par clave-valor al diccionario, cualquier otro servidor puede buscar fácilmente en el diccionario los datos requeridos.
NCache Detalles Diccionario en NCache
contador distribuido
NCache proporciona un Contador estructura de datos que se utiliza para incrementar y decrementar el valor con facilidad. Para hacer tu vida mucho mejor, NCache le permite bloquear los datos colocados dentro de un contador para mantener la coherencia de los datos.
Para su aplicación .NET, el siguiente código lo ayuda a comprender cómo crear una instancia de ICounter, llenarla con datos y cómo incrementar/disminuir ese valor.
Primera aplicación creando el contador con un valor inicial
1 2 3 4 5 6 7 8 |
string key = "SubscriptionCounter"; long initialValue = 15; // Create counter ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue); // Set the initial value of counter to 100 counter.SetValue(100); |
Segunda aplicación recuperando y modificando el contador.
1 2 3 4 5 6 7 8 |
// Create counter ICounter counter = cache.DataTypeManager.GetCounter("SubscriptionCounter"); // Increment value of counter counter.Increment(); // Decrement value of counter counter.Decrement(); |
Puede usar contadores en innumerables escenarios, solo necesita mirar a su alrededor y casi todos los problemas que encuentre se pueden resolver mediante el uso de contadores distribuidos en un entorno de almacenamiento en caché. Algunos de estos escenarios son los siguientes.
Caso de uso: Recuento de páginas vistas
Para ver cuántas visitas recibe una página web por hora o por día, según lo que desee, podría implementarse fácilmente utilizando contadores distribuidos en NCache. En cada nueva vista, el contador en el servidor de caché se incrementará en consecuencia. Este valor, junto con todos los valores presentes en todos los servidores de almacenamiento en caché, se actualizará en la base de datos después de un cierto período de tiempo. Al hacer esto, evita muchos viajes innecesarios a la base de datos y, por lo tanto, mejora el rendimiento general de su aplicación .NET.
Caso de uso: análisis de tweets
Supongamos que tiene una aplicación que lleva la cuenta de todos los tweets importantes de políticos y celebridades. También realiza un seguimiento de la cantidad de Me gusta y No me gusta, comentarios y cosas que reciben sus tweets. Ahora digamos que una persona A los tweets y los me gusta en su tweet pasan de 0 a un millón en menos de media hora. Este es el tipo de datos que no son transitorios pero que aún necesita conservarlos. Pero la velocidad a la que debe persistir es mucho más lenta que la velocidad a la que se actualizan los datos.
Para registrar un cambio que es tan abrupto y frecuente, definitivamente necesita un componente secundario que no permita que su base de datos se ahogue con la frecuencia de los datos. Y aquí es donde necesitas NCache. Ser un caché en memoria es útil cuando necesita almacenar información temporalmente y luego escribirlo todo en la base de datos después de un intervalo. Aquí, si comienza a almacenar en caché el recuento de Me gusta en Como tweets en lugar de modificar directamente el valor en la base de datos, evitará un montón de llamadas de red innecesarias.
NCache Detalles Contadores en NCache
resumiendo todo
Cuando tiene una arquitectura de un solo nivel, no necesita estructuras de datos distribuidos en absoluto. Puede mantener e implementar cualquier estructura de datos que necesite dentro de su aplicación. Pero, cuando cambia a varios servidores y comienza a manejar datos transitorios que no necesitan conservarse, o datos cuya modificación es extremadamente costosa, su base de datos se bloquea y el rendimiento se ve comprometido. Para evitar que su aplicación sufra una tragedia de este tipo, necesita estructuras de datos distribuidas. Y cuando hablas de distribución, siempre debes tener NCache en el fondo de tu mente.
NCache es extremadamente escalable y el hecho de que sea una solución en memoria la convierte en la mejor solución posible para todos sus problemas de almacenamiento en caché de datos.