Diccionario javascript que se puede leer en ASP.NET

Ahora mismo estoy al 100% en la nueva versión de mi control de Google Maps para ASP.NET (la 3.0). Estoy tardando más de lo que tenía pensado (prueba de ello es el "abandono" que tiene este blog), pero es que la cantidad de mejoras es enorme.

Una de las pequeñas cositas que voy a añadir es un diccionario para javascript que puede leerse en ASP.NET. Es una pequeña "clase" javascript que me ha quedado muy chula y aunque en el control de GoogleMaps no se hace trabajo directo con ella, pues es una librería auxiliar, la comparto con vosotros porque puede llegar a ser útil.

El objetivo es que desde javascript podamos crear un sencillo diccionario con su Clave-Valor y su Get-Set, y que al hacer un PostBack tengamos acceso a éste.

Lo único que vamos a necesitar es un input-type-hidden en nuestra página. Por ejemplo:

        <input type="hidden" id="subgurim_Store" name="subgurim_Store" />

Aprovecho para recordar que los input-type-hidden deben tener el atributo "name", si no, desde ASP.NET no se podrá leer con el Request.Form.

Antes de enseñaros la libreria, aquí hay un ejemplo de uso.

Javascript
        var myStore = new Store('subgurim_Store');
        myStore.Set('key1', 'value1');
        myStore.Set('key2', 'value2');
        myStore.Set('key3', 'value3');

        alert(myStore.Get('key2'));
       
        myStore.SaveHidden();

ASP.NET
    protected void Page_Load(object sender, EventArgs e)
    {
        if (IsPostBack)
                string subgurim = Request.Form.Get("subgurim_Store");
    }

De modo que el string subgurim tendrá el valor "key1=value1&key2=value2&key3=value3". A partir de ahí es muy sencillo obtener cada Key-Value. En mi control de GoogleMaps tengo una librería que lo hace sólo, pero eso queda para otro artículo :D

Así que os enseño la sencilla librería. La he testeado poquito, y seguro que es mejorable, pero por lo menos sabemos que por ahí van los tiros. Por cierto, hay algunas cosillas que pueden parecer innecesarias (por ejemplo que algunas funciones sean públicas cuando podrían ser privadas, pero es que está adaptado a mi control de GoogleMaps y ahí sí me hace falta.

    // le pasamos el identificador del input-type-hidden
    function Store(id)
    {
        if (!id) return;
       
        this.id = id;

        // En la variable "s" es donde está la magia. Aquí se guarda todo.
        this.s = {};  
            
        // Referenciamos el objeto hidden para poder usarlo en cualquier lado.
        // Faltaría comprobar que realmente existe, etc.
        this.hidden = document.getElementById(this.id);
       
        // Al inicializar la variable queremos rellenar this.s con lo que ya tiene el hidden
        // De esa forma, aunque hagamos PostBacks, nuestro this.s será persistente
        this.FillFromHidden();

        // Cuando rellenamos this.s queremos borrar el hidden, obligándonos a evitar
        // desincronizaciones innecesarias.
        this.hidden.value = '';
    }
   
    Store.prototype.Get = function(key) { return this.s[key]; } ;
   
    Store.prototype.Set = function (key, value) { this.s[key] = value; } ;
   
    // Recoge los valores de this.s y los guarda en el hidden.
    // Hay que llamar a este método siempre que terminemos de trabajar con el objeto Store.
    Store.prototype.SaveHidden = function ()
        {
            var hiddenValue = '';
            for (key in this.s)
            {               
                var value = this.s[key];              
            
                if (key && value)
                    hiddenValue += key + '=' + value + '&';
            }
           
            hiddenValue = hiddenValue.substring(0, hiddenValue.length - 1);
            this.hidden.value = hiddenValue;
        } ;
       
    // Recoge el valor del Hidden y lo mete en this.s
    Store.prototype.FillFromHidden = function ()
        {
            var hiddenValue = this.hidden.value;           
            var keyValueArray = hiddenValue.split('&');
           
            for (var i=0; i<keyValueArray.length; i++)
            {
                var keyValue = keyValueArray[i].split('=');
                var key = keyValue[0];
                var value = keyValue[1];
                this.s[key] = value;      
            }
        } ;