Subgurim.NET

Hacer un RadioButton dentro de un Repeater

Mon, 05 May 2008 19:10:02 GMT

Estos últimos días me he estado peleando con una cosilla algo rara en Todoexpertos. Y es que a veces ASP.NET tiene algunas cosas que te dan ganas de tirarte de los pelos... o tirarle de los pelos a ScottGu (aunque no tenga muchos).

Mi objetivo era bien sencillo. En lugar de utilizar un control RadioButtonList, lo que yo quería era generar diferentes RadioButtons usando el control Repeater, de modo que cuando seleccionas en cualquier RadioButton, el que estaba seleccionado previamente (si lo había) se deseleccionase, y sólo quedara uno.

Esto es algo bastante típico y muy sencillo de llevar a cabo, sin más que ponerle a todos los RadioButton el mismo "GroupName", que se acaba convirtiendo en el atributo "name" en HTML.

Pero ahora viene el problema, y es que al estar dentro de un Repeater, ASP.NET va generando un prefijo único al name (al igual que hace con el ID), de modo que no es posible que todos tengan el mismo name, por mucho GroupName que especifiques.

Tan sencillo como lo quería, tan sencillo como ASP.NET hacía la puñeta.

Pero bueno, menos mal que javascript y yo somos bastante amigos y pronto Googleé una solución que no tuve más que modificar a mi gusto.

La función javascript que utilicé es el siguiente:

    function SetUniqueRadioButton(nameregex, rid)
    {
       re = new RegExp(nameregex);
       rb = document.getElementById(rid);
       var inputs = document.getElementsByTagName('input');
       for(i = 0; i < inputs.length; i++)
       {
          elm = inputs[i]
          if (elm.type == 'radio')
          {
             if (re.test(elm.name))
             {
                elm.checked = false;
             }
          }
       }

       rb.checked = true;
    }

Y al radiobutton hay que ponerle esto dentro de su atributo "onclick":

onclick="SetUniqueRadioButton('Repeater1.*', '" + RadioButton1.ClientID + "')"

Como vemos, por una parte le estamos pasando una expresión regular, y por otra el Identificador que Javascript sabrá leer.

Lo que hace la función javascript es leer todos los elementos "input" de la página, se asegura de que sean de type "radio" y, de ser así, que cumplan la expresión regular. Siempre se le pone el checked=false, para, posteriormente, poner el checked=true a nuestro RadioButton.

Ya sé la pregunta... ¿qué narices representa la expresión regular? Lo único que representa es el prefijo que el simpático de ASP.NET le va a poner a todo elemento que esté dentro del Repeater1. No tenéis más que poner el identificador del Repeater y ya está

Espero que os sea útil.

iWhere: aplicación para Facebook

Mon, 05 May 2008 18:45:11 GMT

Durante estas semanitas he estado trabajando en mis ratos libres en una aplicación muy chula para Facebook.

Bueno, lo de chula lo digo yo, jeje.

En realidad no se trata de una aplicación para Facebook sólo, sino que mi intención era usar "TodasLasCosasNuevas" que se me ocurrían, como todo tipo de mejoras de ASP.NET 3.5: expresiones lambda, el uso de "var", inicializadores, LINQ para SQL, y demás cosillas que han dejado una respetable cosecha de potenciales artículos para este blog.

En cuanto a programar para Facebook, he usado el Facebook Developer Toolkit, en detrimento del Facebook.NET. Prácticamente ambos hacen lo mismo, y por lo único por lo que me he decidido por el primero es porque tenían más descargas, más visitas y más actualizaciones (aunque eso no significa apenas nada).

Lo único que tengo claro es que programar aplicaciones para Facebook usando el Toolkit es absolutamente sencillo. Apenas un par de cambios con respecto a programar en ASP.NET y ya está.

En cuanto a la aplicación en sí, se trata de dar a conocer a tus amigos de dónde eres, sin más que elegir un punto en el mapa. Cuando has indicado de dónde eres, puedes ver de dónde son tus amigos en un mapa... obviamente un mapa de Google, y así he aprovechado para utilizar mi propio control de GoogleMaps para ASP.NET porque desde ya mismo comienzo con una nueva versión (por cierto, todavía estoy dudando en si sacar una pequeña nueva versión 2.8 o hacer un gran cambio con la versión 3.0).

Por cierto... no he dicho la url de la aplicación, ¿no? Podéis accederla desde http://apps.facebook.com/iwheere/

Sí, tiene repetida la letra "e" porque Facebook requiere que la url de sus aplicaciones tenga más de 6 letras. Además es case sensitive... manda narices... en PHP tenía que estar hecho el Facebook ese, jaja.

Si queréis me podéis añadir como amigo (buscad a Subgurim)

Validar varios RadioButton

Thu, 17 Apr 2008 18:56:39 GMT

Seguro que hay alguna forma de hacerlo más fácil, pero yo no la he encontrado... así que me puse manos a la obra y lo he hecho yo mismo... he de confesar que me gusta demasiado hacer las cosas por mí mismo, aunque ya esté hecho, simplemente por el hecho de aprender, por tener un control 100% de lo que sucede... y por haberlo hecho yo, jeje

El caso es el siguiente: tenemos varios RadioButton diferentes, todos ellos pertenecientes al mismo GroupName, de modo que hacer click sobre uno de ellos implica que se desmarque el previamente elegido.

Por ejemplo eso lo tenemos en Todoexpertos.com, cuando un usuario finaliza y puntúa la pregunta al experto puede darle una puntuación de 0 a 5 y para eso usamos 6 RadioButton's, y no queremos hacerlo usando el RadioButtonList.

Hasta ahora marcábamos por defecto una puntuación de 3 sobre 5... pero decidimos obligar al usuario a elegir una puntuación. Para ello requeríamos verificar, al hacer click sobre un Button, que se hubiera elegido una de las opciones.

Lo primero que se viene a la cabeza es usar un RequiredFieldValidator, pero yo no encontré la forma de hacerlo para RadioButton's separados... así que me puse manos a la obra con un pequeño Javascript.

Os muestro el Javascript que lo utiliza, comentándolo sobre la marcha.

    <script type="text/javascript">

    // Valida que alguno de los elementos del mismo "groupname" haya sido elegido
    function validateRadioButtonList(groupname, message)
    {
        // Recogemos todos los elementos "input" de nuestra página
        var inputs = document.getElementsByTagName("input");
        var hasItems = false;

        // Recorremos cada uno de los elementos,
        for (var i = 0; i < inputs.length; i++)
        {
            // y seleccionamos si hay alguno de tipo "radio"
            if (inputs[i].type == 'radio')
            {
                // Verificamos que ese RadioButton pertenece al groupname especificado
                var name = inputs[i].name;
                var isFromGroup = (name.lastIndexOf(groupname) + groupname.length ) == name.length;

                // En de encontrar un RadioButton con el groupname...
                if (isFromGroup)
                {
                    // Marcamos que lo hemos encontrado
                    hasItems = true;

                    // Si hay alguno checkeado, devolver true
                    if (inputs[i].checked)
                    {
                        return true;
                    }
                }
            }
        }


        if (hasItems)
        {
            // Si llegamos aquí es que hemos encontrado
            // RadioButton's con el groupname, pero ninguno checkeado
            if (!message) message = 'Debes elegir una opción';
            alert(message);
            return false;
        }
        else
        {
            // Si llegamos aquí es que no hemos encontrado
            // ningún RadioButton con el groupname buscado
            return true;
        }
    }

    </script>

Eso en cuanto al javascript. Un ejemplo que lo use:

RadioButton.aspx

    <div>
        <div>
            <asp:RadioButton ID="RadioButton1" runat="server" GroupName="SubgurimTest" Text="RadioButton1" />
        </div>
        <div>
            <asp:RadioButton ID="RadioButton2" runat="server" GroupName="SubgurimTest" Text="RadioButton2" />
        </div>
        <div>
            <asp:RadioButton ID="RadioButton3" runat="server" GroupName="SubgurimTest" Text="RadioButton3" />
        </div>
        <div>
            <asp:Button ID="Button1" runat="server" Text="Button" OnClientClick="if (!validateRadioButtonList('SubgurimTest')) return false;"
                OnClick="Button1_Click" />
        </div>
        <div>
            <asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>
        </div>
    </div>

RadioButton.aspx.cs

        protected void Button1_Click(object sender, EventArgs e)
        {
            string message = string.Empty;

            if (RadioButton1.Checked)
                message = "RadioButton1";
            if (RadioButton2.Checked)
                message = "RadioButton2";
            if (RadioButton3.Checked)
                message = "RadioButton3";

            Label1.Text = message;
        }

Vemos que tenemos tres RadioButton's cuyo GroupName es "SubgurimTest". Posteriormente tenemos un Button que maneja un evento OnClick cualquiera, y un OnClientClick así:

        if (!validateRadioButtonList('SubgurimTest')) return false;

De forma que vemos claramente que si no se valida el Grupo de RadioButton's, no se debe seguir con el Post.

Espero que os sea de utilidad, incluso si sabéis una forma mucho más sencilla de hacerlo

Google vs el RewritePath de ASP.NET

Fri, 04 Apr 2008 19:51:16 GMT

ASP.NET no es perfecto. Y punto.

Uno de los peores errores que se pueden tener, son aquellos que no ves. Aquellos que no te enteras si quiera de que están sucediendo. Aquellos que cuando te enteres que están sucediendo, no entiendas qué está pasando ni por qué.

Esto es lo que sucede cuando GoogleBot (y muchos otros rastreadores como Yahoo Slurp) visitan algunas de tus páginas ASP.NET a las que has aplicado el RewritePath. Por ejemplo, si usas este famoso Url Rewriter es casi seguro que te está afectando el problema (yo siempre aconsejo el UrlRewritingNET).

Lo que sucede es que ASP.NET, según quién le esté visitando, devuelve una cosa y otra. En el caso de que le visiten algunos de los crawlers buscadores más importantes cuando usamos el RewritePath, ASP.NET puede devolver "paths" que apuntan "muy hacia abajo". Por ejemplo, puede darse el caso de que estemos en www.subgurim.net/default.aspx, y ASP.NET devuelva enlaces con "../../", con lo que salta un feo error.

Tras darle muchas vueltas y conseguir soluciones feas, y dado que los buscadores no tienen la culpa y ASP.NET no tiene pinta de querer solucionar el error, la mejor solución que he encontrado es usar el directorio App_Browsers, añadiéndole los archivos que tenéis más abajo de forma que "engañamos" a ASP.NET para que nos devuelva un código bueno.

ASí que la solución es fácil, añades esos archivos al directorio web.config y todo solucionado.

Descargar App_Browsers

Averiguar el valor del "compilation debug"

Fri, 04 Apr 2008 19:15:35 GMT

Ya hemos hablado de la importancia del gente a la que no le hace mucha gracia ni jugar con el machine.config ni con el deploymente retail. De hecho, es bastante habitual no tener acceso al machine.config (sobre todo en servidores compartidos).

De forma que lo que queremos es asegurarnos de que siempre que no no nos encontremos en desarrollo (es decir que estemos en localhost) nuestro debug sea false.

Pues ahí va el código autoexplicativo:

    /// <summary>
    /// Define si se puede tener activado el debug
    /// </summary>
    protected bool CanDebug()
    {
        if (!Request.Url.DnsSafeHost.Equals("localhost"))
        {
            // Si no estoy en localhost...

            // Cogemos el elemento system/compiltation, donde se encuentra el atributo "debug"
            System.Configuration.ConfigurationSection section =
                System.Configuration.ConfigurationManager.GetSection("system.web/compilation") as
                System.Configuration.ConfigurationSection;

            if (section == null)
            {
                // En caso de no existir, el valor por defecto es debug = false
                return true;
            }
            else
            {
                // En caso de existir la sección y su atributo "debug", debemos asegurarnos de que sea false
                return !Convert.ToBoolean(section.ElementInformation.Properties["debug"].Value);
            }
        }
        else
        {
            // Si estoy en localhost puedo tener el debug como quiera.
            return true;
        }
    }

De este modo averiguaremos si nuestro valor de "debug" es el correcto, tanto si estamos en localhost como si no.

El modo de esar esta información queda a gusto de cada uno, pero una opción "bestia" sería la de poner este código en algún lugar que seguro vayamos a visitar:

        if (!CanDebug())
            throw new Exception("No se puede tener activado el debug");

HttpModule: AntiSpamModule

Fri, 04 Apr 2008 17:25:04 GMT

Nunca me gustan las definiciones de conceptos tan técnicos como es el caso del HttpModule. Primero porque no sé definir bien las cosas, y segundo porque aunque lo supiera definir bien, lo que más aclara sigue siendo un buen ejemplo.

Para que nos hagamos a una idea, con los HttpModule's vamos a poder manejar eventos que suceden antes que el Pre_Init de la página. Esperando que no se me olvide ninguno, y sin entrar a comentar qué sucede en cada uno de ellos, este es el orden en que se ejecutan dicho eventos:

BeginRequest
AuthenticateRequest
PostAuthenticateRequest
PostAuthorizeRequest
ResolveRequestCache
PostResolveRequestCache
PostMapRequestHandler
AcquireRequestState
PostAcquireRequestState
PreRequestHandlerExecute

Bien utilizados los HttpModules son muy útiles.

Todo muy bonito y todo muy bien... pero hasta el momento he dicho todo pero no he dicho nada. Vamos con un ejemplo, pero además un ejemplo muy útil: el AntiSpammer.

Desde hace tiempo vengo teniendo problemas en los foros de algunas de mis Webs. Algunos robots Spammers escribían diariamente "basura". Analizándolo a grandes rasgos, lo que hacen estos robots es hacer peticiones POST a una url definida con unos campos definidos. Hasta ahora había probado varios métodos, como cambiar el nombre de los Textbox (y por tanto cambiaba el identificador de los campos o cambiar el nombre de la página (con lo que el robot ya no lo enviaba al sitio correcto).

Ninguno de esos métodos me funcionaba, pues los robots eran inteligentes... o simplemente cogían los "Id" de todos los "input type text" y mandaban la basura con su nombre. Bueno, no lo sé, cuando algún día decida hacerme spammer lo analizaré mejor .

La cuestión es que lo único que realmente me ha funcionado ha sido o poner un Captcha (los odio) o permitir únicamente la inserción a usuarios registrados... pero ninguna de las dos soluciones me gusta.

Así que con la "inspiración" de resolver ese problema, he hecho este HttpModule.

Hacer un HttpModule es mucho más sencillo de lo que se piensa. Lo primero es crear una clase con la Interfaz "IHttpModule", la cual te obliga a tener dos métodos: "Init" y "Dispose".

En el método "Init" se recoge un parámetro del tipo "HttpApplication", desde el cual se tiene acceso a todas las variables típicas que se tienen desde una Página .aspx cualquiera. En nuesgtro ejemplo nos va a interesar recoger el Request, el Response.

Vayamos con el código, y pasamos a explicar qué vamos a hacer para tratar de evitar el Spam:

AntiSpamModule.cs
using System;
using System.Web;

namespace Subgurim.Tools
{
    public class AntiSpamModule : IHttpModule
    {
        public void Init(HttpApplication app)
        {
            app.BeginRequest += new EventHandler(AntiSpamFilter);
        }

        private void AntiSpamFilter(object sender, EventArgs e)
        {
            HttpResponse response = ((HttpApplication)sender).Response;
            HttpRequest request = ((HttpApplication)sender).Request;

            // 1.- Me me están mandando datos mediante POST
            // 2.- La llamada no proviene de ninguna otra página
            // 3.- La llamada proviene de otra página, pero que no está dentro de mi dominio
            if ((request.Form.Count > 0) &&
                    ((request.UrlReferrer == null) ||
                    (!request.UrlReferrer.Authority.Equals(request.Url.Authority, StringComparison.InvariantCultureIgnoreCase))))
            {
                try
                {
                    response.End();
                }
                catch (System.Threading.ThreadAbortException ex)
                {
                    // No hacer nada
                }
            }
        }

        public void Dispose()
        {
        }
    }
}

En el método Init vamos a indicar que cuando se lance el evento "BeginRequest" (el primero de todos) se llame al método AntiSpamFilter.

Dentro del AntiSpamFilter recogemos (vemos que es muy sencillo) el Response y el Request, y aquí es donde trataremos de localizar a los robots Spammers con tres sencillas reglas:

Me me están mandando datos mediante POST
La llamada no proviene de ninguna otra página
La llamada proviene de otra página, pero que no está dentro de mi dominio

En caso de ser así, haremos, sin contemplaciones un Response.End(), con lo que paramos el ciclo de vida, y de ahí no pasa nadie. Nos sólo evitamos que nos Spammeen, sino que le estamos ahorrando a nuestro servidor un montón de cosas.

Ponemos un try - catch para manejar el ThreadAbortException, que se lanza siempre que se hace un Response.End.

En lugar de un Response.End, podría ser buena idea lanzar una HttpException 404, engañando al robot haciéndole creer que la página no existe.

Ya tenemos programado nuestro HttpModule... como véis es muy sencillo y no tiene otra historia que un clase implementando una interfaz.

Ahora nos queda configurar nuestra aplicación para que, en cada llamada, ejecute ese HttpModule. Como siempre, lo haremos desde nuestro web.config. Dentro del elemento System.Web debemos poner el elemento httpModules:

    <system.web>
        <httpModules>
            <add name="AntiSpamModule" type="Subgurim.Tools.AntiSpamModule"/>
        </httpModules>
    </system.web>

Con "name" con el nombre de la clase y type con el namespace (si está dentro del directorio App_Code) o el nombre del assembly si lo tienes en otro proyecto.

OJO: esas tres reglas básicas no han sido testeadas al 100%. Debería funcionar sin problemas, pero no sé, por ejemplo, si los robots de los buscadores (como GoogleBot o YahooSlurp) utilizan o utilizarán llamadas POST con parámetros para indexar mejor los contenidos... vamos, que me lavo las manos de lo malo que pueda ocurriros (aunque repito que a mí me ha funcionado sin problemas).

Introducción a la conexión a bases de datos

Wed, 20 Feb 2008 00:00:58 GMT

En este videotutorial hago una introducción a la conexión a bases de datos en ASP.NET.

Su nivel es muy básico, por lo que está dirigido a los programadores que se están iniciando.

En el videotutorial se creará una base de datos con SQLServer Express con una sencilla tabla de sólo dos registros. Además se crean 2 procedimientos almacenados, uno de inserción y otro de selección.

Posteriormente se configurará un SqlDataSource con ambos procedimientos almacenados, con un Detailsview para la inserción de datos y un Gridview para mostrarlos.

Ajax UrlTester

Wed, 23 Jan 2008 18:16:38 GMT

DESCARGAR CÓDIGO

Todo webmaster que se precie debe seguir una regla de oro básica: cuando realizas un cambio en la Web, debes visitar las páginas donde se han hecho los cambios para comprobar que todo va correcto.

Esto, aparentemente tan lógico y trivial, no es tan sencillo como parece. Si estamos hablando de una o dos páginas no hay problema, pero hay ocasiones en que los cambios realizados son complejos y pueden implicar 20, 30 o 40 páginas.

Con esta idea en mente, y sin buscar antes en Google por si había ya algo parecido (de hecho aún no lo he mirado y no sé si lo haré), se me ocurrió hacer un script que visitara las páginas y me diera, al menos, una mínima información sobre el estado de las páginas que yo quiera.

Hay muchas opciones posibles. Por ejemplo podríamos usar un spider. Pero como ya escribí un artículo muy similar y me apetecía usar Ajax y Javascript, decidí utilizar el XMLHttpRequest.

Básicamente, la funcionalidad del script consiste en visitar las páginas que yo le configuro usando el XMLHttpRequest, y éste me dará el Status y el StatusCode de cada una de esas páginas.

Como ya sabréis, si la página funciona correctamente, devolverá un StatusCode "200" y un Status "OK". Si no existe la página devolverá un "404 - Page Not Found" y si hay un error devolverá "500 - Internal Server Error". Es poca información, pero nos viene perfecto para dar un repaso rápido a una gran cantidad de páginas.

Además de esta funcionalidad básica, el script "maquilla" los resultados devueltos, indicando, por ejemplo, cuando comienza y termina un test, o coloreando en rojo todo aquello que no sea un "200 - OK".

Lo he metido todo en un .ASCX en lugar de un .dll, porque a mí me suele ser más cómodo, sobretodo en cosas de administración tan pequeñitas.

Ahora vayamos al grano, mostrando un poquito del código básico:

El .ascx.cs tiene dos métodos centrales el "AddJavascriptCore" y el "AddJavascriptTest". Veamos el primero de ellos:

    private void AddJavascriptCore()
    {
        string js = string.Format(
            @"

       // Simplemente devuelve una variable "XMLHttpRequest" válida para IE y FF
       // It simply returns an XMLHttpRequest variable, valid for IE and FF
        function CreateXmlHttp()
        {{
            try
            {{
                xmlHttp = new ActiveXObject('Msxml2.XMLHTTP');
            }}
            catch(e)
            {{
                try
                {{
                    xmlHttp = new ActiveXObject('Microsoft.XMLHTTP');
                }}
                catch(oc)
                {{
                    xmlHttp = null;
                }}
            }}
            if(!xmlHttp && typeof XMLHttpRequest != 'undefined')
            {{
                xmlHttp = new XMLHttpRequest();
            }}
            return xmlHttp;
        }}

       // Se llama al empezar el test, y muestra el mensaje de inicio
       // It's called at the beginning of the test and returns a start message
        function BeginTest()
        {{
            var panel = document.getElementById('{0}');
            panel.appendChild(document.createTextNode('BEGIN TEST'));
            panel.appendChild(document.createElement('br'));
        }}

       // Controlamos cuándo se ha llamado a todas las páginas
       // We control when are tested all the pages
        function SubstractCount()
        {{
            i--;
            if (i==0)
            {{
                var panel = document.getElementById('{0}');
                panel.appendChild(document.createTextNode('END TEST'));

            }}
        }}

       // Recoge la variable XMLHttpRequest y maneja la función que se ejecutará cuando la llamada termine.
       // Get the XMLHttpRequestVariable and hands the function that is going to execute when the call ends.
        function SendTest(ajaxRequest)
        {{
            var xmlHttp = CreateXmlHttp();
            xmlHttp.onreadystatechange = function() {{Test(ajaxRequest, xmlHttp)}};
            xmlHttp.open('GET', ajaxRequest, true);
            xmlHttp.send('');
        }}


       // Cuando termine la llamada, se crean los elementos DOM y se muestra el resultado
       // When the call ends, the DOM elements are created and the results are shown
        function Test(ajaxRequest, xmlHttp)
        {{
            if(xmlHttp.readyState == 4)
            {{
                var panel = document.getElementById('{0}');

                var item = document.createElement('div');

                var ajaxUrlRequest =document.createElement('a');
                ajaxUrlRequest.href= ajaxRequest;
                ajaxUrlRequest.target= '_blank';
                ajaxUrlRequest.appendChild(document.createTextNode(ajaxRequest));

                item.appendChild(ajaxUrlRequest);
                item.appendChild(document.createTextNode(': ' + xmlHttp.status + ' - ' + xmlHttp.statusText));

                var color = 'blue';

                if (xmlHttp.status != '200') color = 'red';
                    item.setAttribute('style', 'color:' + color);

                panel.appendChild(item);

                SubstractCount();
            }}
        }}
", pnlTesterResults.ClientID);

       // Registra el script. Se usa ASP.NET AJAX, pero en lugar de ésta puedes usar el ClientManager.
       // Registers the script. Here is used ASP.NET AJAX, but you can use the ClientManager instead
        ScriptManager.RegisterClientScriptBlock(this, this.GetType(), "Subgurim_AjaxPageTester_AddJavascriptCore", js, true);
    }


En cuanto al método "AddJavascriptTest", es mucho más sencillo, pues sólo se encarga de inicializar variables y llamar al método para cada una de las páginas.

    private System.Collections.Specialized.StringCollection urlList = new System.Collections.Specialized.StringCollection();
    public System.Collections.Specialized.StringCollection UrlList
    {
        get { return urlList; }
        set { urlList = value; }
    }

    private void AddJavascriptTest()
    {
        StringBuilder sb = new StringBuilder();

        if (null != UrlList)
        {
            sb.AppendFormat("var i = {0};", UrlList.Count);
            sb.Append("BeginTest();");
            foreach (string url in UrlList)
            {
                sb.AppendFormat("SendTest('{0}');", url);
            }
        }

        ScriptManager.RegisterStartupScript(this, this.GetType(), "Subgurim_AjaxPageTester_AddJavascriptTest", sb.ToString(), true);
    }

Así pues, tras registrar el control en cualquier página .aspx, lo utilizaremos del siguiente modo:

        // Añade las url que quieras comprobar. Deben estar en el mismo dominio que esta página.
        // Add the URL that you want to test. They should be in the same domain that this page.
        AjaxPageTester1.UrlList.Add("/default.aspx");
        AjaxPageTester1.UrlList.Add("/login.aspx");

DESCARGAR CÓDIGO

Añadir una cookie fácilmente con Javascript

Fri, 14 Dec 2007 19:06:32 GMT

(Ve aquí si lo que te interesa son las cookies en ASP.NET)

Hay muchas formas de escribir una cookie usando javascript. Yo he utilizado funciones que realmente consiguen lo que quieres, pero feas y complejas de leer.

El otro día me tope con una función extremadamente simple que cumple el objetivo que queremos el 95% de veces: una cookie con una clave, un valor y una fecha de caducidad.

function writeLightCookie(n, v, d)
{
document.cookie = n + "=" + v + ";expires=" + d;
}

Donde "n" es el nombre o clave de la cookie, "v" es su valor, y "d" su fecha de caducidad.

Usarlo es también muy sencillo. Por ejemplo vamos a añadir una cookie que expire en un día:

var exp = new Date();
var expDays = 1;
exp.setTime(exp.getTime() + (expDays*24*60*60*1000));
writeLightCookie('nombreDeLaCookie', 'ValorDeLaCookie' , exp);

Regex Evaluator: un iGadget para expresiones regulares

Thu, 13 Dec 2007 18:21:28 GMT

Hace tiempo, las expresiones regulares me parecían infernales: ¡no había por donde cogerlas!

Como siempre suele pasarme en estos casos, no entenderlas hería mi honor , así que me puse manos a la obra... ¡ahora no puedo vivir sin ellas! Se han convertido en parte imprescindible, y las uso bastante, allá donde un "indexOf" o un "Replace" de un string normal se queda corto.

Ya he escrito sobre expresiones regulares en un par de artículos (introducción a expresiones regulares y Cómo trabajar las expresiones regulares en ASP.NET), además, uno de mis proyectos OpenSource (Improvement Kit), está basado justamente en su uso.

El asunto es que cuando trabajas con expresiones regulares, es bastante común tener que comprobar su correcto funcionamiento, porque a partir de cierta complejidad es prácticamente imposible que aciertes a la primera .

Hasta ahora yo trabajaba con el programa que indico en el artículo ya mencionado introducción a expresiones regulares (llamado Expresso). Es un programa muy potente y sencillo de usar, pero no es gratuito... además tampoco es un programa Web, algo hacia lo que tiende prácticamente todo.

Por tanto, dado que me estoy aficionando a hacer iGadgets por doquier, decidí hacer un iGadget de expresiones regulares. Para los que no sepáis lo que es un iGadget, se trata de los Gadgets que te puedes instalar en la página principal de Google... para los que no sepáis que es un Gadget (¡¡deberíais saberlo!!), son pequeñas aplicaciones que ofrecen pequeñas funcionalidad muy sencillas de usar.

Puedes instalártelo en tu página principal de Google desde aquí.