Utilizando un cache distribuido en nuestro middleware – Parte 2

Continuando con el post inicial acerca de un cache en una arquitectura distribuida, vamos a continuar haciendo un ejemplo utilizando el chache distribuido del AppFabric. En este caso, vamos a crear un ejemplo muy simple utilizando un proyecto del tipo aplicación de consola.

Configurar el AppFabric

Para iniciar, tenemos que configurar el cache del AppFabric, esto se logra utilizando el wizard de configuración de la herramienta ya sea cuando se instala el AppFabric, o cuando el usuario lo requiera. En nuestro caso, vamos a configurar el AppFabric utilizando un archivo XML para guardar la configuración del mismo ya que este simplemente nos va a solicitar un UNC para llevar a cabo la misma; si se quiere utilizar SQL Server vamos a tener que tener la maquina perteneciendo a un dominio de Active Directory. La regla en general es si vas  a utilizar el  cache del AppFabric en un solo servidor, deberías utilizar el proveedor de XML, si lo vas a usar en varios deberías usar el proveedor de SQL Server. La siguiente figura nos muestra el cache del appFabric configurado en un servidor local utilizando el proveedor XML.

Codificar con el Cache del AppFabric

El siguiente paso es codificar pensando en el Cache del AppFabric. Para esto necesitamos agregar una referencia a la librería 

Microsoft.ApplicationServer.Caching;

Luego de esto, tenemos que ingresar el código para manipular los datos que queremos agregar al cache. Para esto empezamos creando un objeto del tipo DataCache, el cual se conectara a nuestro cache configurado en el AppFabric y nos permitirá almacenar datos en el cache para acceso mas rápido. El siguiente código nos muestra como conectarnos al Cache y como obtenemos el objeto para poder interactuar con el AppFabric.

        private static DataCacheFactory _factory;
        private static DataCache _cache;

        public static DataCache GetCache()
        {
            if (_cache != null)
                return _cache;


            var _servers = new List<DataCacheServerEndpoint>(1) {new DataCacheServerEndpoint("drojasmWin8", 22233)};

            var _configuration = new DataCacheFactoryConfiguration
                {
                    Servers = _servers,
                    LocalCacheProperties = new DataCacheLocalCacheProperties()
                };

            DataCacheClientLogManager.ChangeLogLevel(System.Diagnostics.TraceLevel.Off);

            _configuration.ChannelOpenTimeout = TimeSpan.FromMinutes(1);
            _configuration.SecurityProperties = new DataCacheSecurity(DataCacheSecurityMode.None, DataCacheProtectionLevel.None);

            _factory = new DataCacheFactory(_configuration);

            _cache = _factory.GetCache("default");

            return _cache;
        }

Luego de configurado el Objeto DataCache, procedemos a programar la interacción con el mismo. Normalmente esta interacción se da a nivel de servicios o de lógica de negocios, desde la cual procedemos a revisar las variables antes de comunicarnos con la capa que nos va a dar los servicios para obtener estos datos. En el siguiente método, podemos ver como invocamos al método anterior GetCache. Luego de esto en la linea 6 le preguntamos al cache si tiene una variable llamada países almacenada, si existe procedemos a obtener los datos del cache, en caso contrario, creamos la lista ( en este caso iríamos a la base de datos o al repositorio respectivo ) y guardamos los datos en el cache para que queden disponibles para consultas posteriores. Es importante destacar que el cache no funciona a nivel de usuario, si no a nivel de capa media, con lo cual muchos usuarios van a obtener sus datos del cache, aunque los datos sean cacheados por otro usuario.

static void Main()
        {
            var _dataCache = GetCache();
            if (_dataCache == null) throw new ArgumentNullException("Cache no inicializado");
            const string llave = "Paises";
            var _obj = _dataCache[llave];
            if (_obj == null)
            {
                _obj = new List<string> {"China", "Peru", "Ecuador"};
                _dataCache[llave] = _obj;
                Console.WriteLine("No estaba en el cache");
            }
            else
            {
                Console.WriteLine("Si estaba en el cache");
            }
        }

Este escenario es ideal porque nos permite aumentar las escalabilidad – mas que la velocidad – de nuestras aplicaciones, porque nos estamos ahorrando capacidad de procesamiento a la hora de llevar  cabo las consultas. Respecto al tipo de datos que vamos a poner en el cache, normalmente datos que cambian poco, aunque es posible poner datos que son dinámicos, ya que la invocación del cache debería estar supeditada a los servicios y a la lógica de negocios, con lo cual, cuando alguien inserta, modifica o elimina un dato, puede preguntar si el dato esta en el cache y removerlo del mismo, con lo cual mantendríamos siempre los datos actualizados.

Technorati Tags: AppFabric