Archivo para octubre, 2009

Bienvenido Forerunner-G34

Posted in ASP.NET, Noticias, WPF on octubre 30, 2009 by César Intriago

forerunenrG34

Mi nuevo blog sobre ASP.NET y WPF (and it’s Green):
[ http://forerunnerg34.wordpress.com ]

Anuncios

Forzar comentarios en SVN

Posted in Tutorial on octubre 15, 2009 by César Intriago

Continuando con los temas relacionados a SubVersion, encontré este script para marcar como requeridos los comentarios antes de hacer commit de los cambios en el SVN. Esta es la forma de habilitar esta función usando Visual SVN Server:

Habiendo seleccionado un repositorio, seleccione “Propiedades” del menú contextual (click derecho sobre el repositorio):

image

De la ventana propiedades seleccione la pestaña “Hooks”, luego “Pre-commit hook” y clic en “Edit…”

image

Finalmente copie y pegue el siguiente script y guarde todos los cambios.

@echo off
::
:: Stops commits that have empty log messages.
::
@echo off
setlocal
rem Subversion sends through the path to the repository and transaction id
set REPOS=%1
set TXN=%2
rem check for an empty log message
svnlook log %REPOS% -t %TXN% | findstr . > nul
if %errorlevel% gtr 0 (goto err) else exit 0
:err
echo. 1>&2
echo Su commit ha sido bloqueado porque no ingresó ningún comentario. 1>&2
echo Por favor escriba un comentario describiendo el propósito de sus cambios y 1>&2
echo luego intente realizar nuevamente un commit. — Gracias 1>&2
echo. 1>&2
echo — Si no tienes nada que comentar, entonces probablemente no tienes nada que hacer commit.–  1>&2

exit 1

Ahora cuando se intente guardar cambios o nuevo contenido sin ingresar comentarios, SVN bloqueará el proceso de commit:

image

KDE 4.3 parece Snow Leopard mezclado con Windows 7

Posted in Opinion on octubre 15, 2009 by César Intriago

Esto no tiene nada que ver ni con .Net, ni Apple ni Microsoft, es solo que se me viene a la mente que el nuevo KDE 4.3 y su tema “Plasma” es la fusión de Snow Leopard y Windows 7.

 

kde430-desktop

Usando SVN

Posted in Aplicaciones, Tutorial on octubre 15, 2009 by César Intriago

 

En un post anterior comentaba sobre herramientas para control de código fuente, y entre ellas estaba probando Subversion (SVN) la cuál explicaré ahora un poco mas a detalle:

Herramientas

Subversion (de ahora en adelante SVN) es una herramienta para  el control de código fuente, independiente de la tecnología de desarrollo o IDE. Para la administración del servidor y cliente se usa principalmente la línea de comandos, pero también existe herramientas visuales tanto para el lado del servidor como del cliente que nos facilitan en el trabajo:

  • VisualSVN: Permite configurar y administrar de forma simple y rápida el servidor.
  • TortoiseSVN: Excelente herramienta de cliente para SVN, se integra con el shell de Windows.
  • Desde luego que también necesitamos descargar e instalar Subversion.

Repositorios

SVN permite crear varios repositorios, por ejemplo podemos tener dos:

  • DevTeam”: Donde se almacena la línea principal de desarrollo de nuestras aplicaciones.
  • Sandbox”: Repositorio personal donde puedo subir cosas personales de prueba o de investigación.

Usando VisualSVN también podemos configruar el servidor para que soporte comunicación segura via el protocolo Https, y la autenticación y autorización integrada a un servidor LDAP, por lo que podemos usar nuestras credenciales del red para entrar al servidor.

 

Proyectos y su organización

Los proyectos de desarrollo se crean dentro de los Repositorios, normalmente cada proyecto nuevo tiene la siguiente estructura inicial: branches, tags y trunk, que son simplemente carpetas que nos ayudan a organizar el proyecto y se recomienda que todos tengan esa estructura:

 

Trunk

Dentro de esta carpeta se almacena todo el código del proyecto, el que está constantemente siendo modificado por el equipo de desarrollo.

Branches

Permite tener ramificaciones del proyecto, por ejemplo: si tenemos una primera versión de la aplicación lista para que sea probada crearíamos un branch llamando “Certificacion-1.0” con una copia del contenido del “trunk”. En este punto tendríamos dos líneas de desarrollo: el “trunk” donde se seguirían agregando nuevas funcionalidades y el branch “Certificacion-1.0” donde se daría soporte a la primera versión del producto, como la corrección de bugs. SVN nos permite sincronizar el trunk con cualquier branch y viceversa, de al forma que si se detecta un bug en el branch “Certificacion-1.0”´ el código que lo corrige (llamando ChangeSet) se lo puede fusionar al trunk principal. Una vez que se finalice el proceso de pruebas se puede reintegrar todo el branch al trunk para fusionar los cambios.

TIP: No es bueno esperar al último momento para fusionar las dos ramas ya que se podrían dar grandes conflictos, es mejor hacerlo con anticipación, cada cierto tiempo y por grupos para evitar problemas en el futuro.

Tags

Esta carpeta nos permite representar estados del proyecto que están listos para ser entregados, por ejemplo: “Version-1.0”, “Version-1.1”, “Version-2.0”. Siguiendo el ejemplo anterior: luego de corregir todos los incidentes del branch “Certificacion-1.0” crearíamos un Tag  nuevo llamado “Version-1.0” con el contenido del branch y, posteriormente borraríamos el branch “Certificacion-1.0”.

 

Ignorar archivos y carpetas

SVN puede ser configurado para no incluir en el repositorio los archivos o carpetas que le especifiquemos, para esto se usan propiedades que se configuran en el lado del cliente. Estas propiedades pueden ser exportadas para que otro cliente las aplique.

image

IMPORTANTE: Si un archivo ya fue subido al servidor, y luego se lo agrega en la lista de elementos que se deben ignorar, SVN no hará caso a esa propiedad ya que tienen prioridad los elementos que ya están bajo el control de código fuente, es decir SVN seguirá versionando el archivo.

 

TortoiseSVN

TortoiseSVN es una herramienta muy buena que se integra al shell de Windows y permite interactuar con el repositorio, nos permite entre otras cosas:

  1. Crear proyectos en el repositorio
  2. Importar contenido
  3. Actualizar contenido
  4. Agregar propiedades
  5. Crear branches y tags
  6. Comparar versiones
  7. Resolver conflictos entre archivos
  8. Deshacer cambios

Control de Código Fuente

Posted in Opinion on octubre 15, 2009 by César Intriago

 

El control de código fuente es un tema importante durante el desarrollo de software, ya que nos permite primero que nada respaldar nuestro trabajo en un servidor central, y adicionalmente otros usuarios pueden trabajar sobre dichos archivos. En el caso de un daño grave de la computadora donde trabajamos no perderíamos algo tan valioso como el código que se hemos generado.

Existen algunos herramientas para control de código fuente, probablemente conozcan de Source Safe de Microsoft, que fue descontinuada luego de la versión 2005 para convertirse en Team Foundation. En todo caso esa herramienta está fuertemente ligada al trabajo con el IDE de Visual Studio. En un ambiente multidisciplinario por ejemplo donde se trabajan con mas de un IDE o algunas veces sin ninguno, talvez SourceSafe no cumpla con todos los requerimientos.

Otro punto importante sobre el control de código fuente es la actualización concurrente de archivos, en SourceSafe existe el mecanismo de:

Lock –> Update –> Unlock

Lo que significa que para poder cambiar un archivo, primero se aplica un bloqueo sobre el mismo en el lado del servidor, luego el usuario puede cambiar el archivo, y finalmente cuando lo sube al servidor, este es desbloquedo. Esto tiene la principal característica de que cuando un usuario A está trabajando sobre un archivo F, un usuario B no podrá cambiar ese archivo hasta que el usuario A lo desbloquee. Es decir la edición de archivos es secuencial, en lo personal pienso que este trae mas molestias que ventajas ya que se pierde tiempo esperando que otro usuario desbloquee el archivo para poder seguir trabajando.

Otros tipos de soluciones como SVN (Subversion) siguen un modelo:

Copy–> Update  -> Merge

En SVN cuando un usuario hace un “checkout” de un archivo, éste no queda bloqueado en el servidor, -de tal forma que otro usuario puede hacer lo mismo-, luego de realizar los cambios y querer subirlos al servidor SVN compara la copia local (working copy) con el contenido del servidor, si el contenido original no cambió mientras se modificaba el archivo, éste es copiado al servidor, caso contrario: si mientras estábamos editando el archivo, otro usuario alteró también el contenido, se realiza un proceso de MERGE (fusión) del contenido de ambas versiones, en el caso de que exista algún conflicto que SVN no pueda resolver, se le presenta al usuario las herramientas para comparar ambas versiones y solucionar los conflictos manualmente. Adicionalmente SVN lleva un número de revisón del proyecto, lo que nos permite conocer si tenemos o no la última versión del proyecto en nuestra carpeta local.

SVN es ampliamente usado a nivel mundial, gratuito y existen varios clientes para poder trabajar con este servidor, antes había usado esta herramienta, y actualmente estoy probando la versión oficial de SVN.

Mayor información:

Sitio oficial de SVN: http://subversion.tigris.org/

Un pequeño paraiso llamado Mindo. En Ecuador!!

Posted in Opinion on octubre 14, 2009 by César Intriago

 

Este fin de semana fue excelente, pasamos dos días en Mindo haciendo deportes de aventura. Aquí les dejo unas pocas fotos que tomé de los lugares que visitamos:

P1000505 P1000517 P1000518

P1000508

P1000519 P1000594

P1000577

P1000583

HTML Render de controles ASP.NET

Posted in ASP.NET, Microsoft, Tutorial on octubre 2, 2009 by César Intriago

 

Hace algún tiempo, en una compañía dedicada a consultaría Web en donde trabajaba surgió un requerimiento de “integrar” ASP.NET con un CMS que permite únicamente tener contenido estático HTML, CSS y JavaScript en tiempo de diseño.

El escenario era el siguiente:

  1. Un sitio en ASP.NET con varios User Controls.
  2. Los editores usan el CMS para crear nuevas páginas, y en tiempo de diseño pueden insertar los controles de usuario del proyecto de ASP.NET.
  3. En tiempo de diseño, el CMS no soporta ASP.NET.
  4. Cuando el editor envía a publicar las páginas, estas son copiadas dentro del sitio ASP.NET, donde recién el código ASP.NET podrá ser ejecutado.
  5. En tiempo de diseño del CMS, el editor debe poder ver el preview de los controles de ASP.NET.

Era una tarea bastante interesante, la cual de lo que me comentaron no se había podido realizar antes, por suerte con un poco C# se me ocurrió la siguiente idea:

Crear una página en el proyecto ASP.NET que reciba como parámetros el nombre del UserControl que se debe mostrar y los parámetros para inicializarlo, luego obtener el HTML resultante y devolverlo al cliente como una función JavaScript. De esta forma quien quiera mostrar un control de usuario en sitios no ASP.NET, solo necesita usar un poco de JavaScript (muy poco a decir verdad).

RenderControl.aspx

Esta es la página que recibe como parámetro en el QueryString el nombre del User Control y crea dinámicamente una función JavaScript con el HTML resultante. Adicionalmente el UserControl puede recibir parámetros de entrada como Strings, Booleanos, o números. Haciendo uso de Reflection, esta página se encarga de asignar dinámicamente estas propiedades antes de dibujar el control.

Creando los User Controls

Lo primero que haremos es crear unos 3 controles de usuario de ejemplo:

image AllUsers.ascx: Contiene un ASp.NET GridView con una lista de usuarios obtenida de un archivo XML.

 

 

image MyCalendar.ascx: Contiene un ASP.NET Calendar

 

 

 

 

 

image UserProfile.ascx: Muestra los datos de un usuario especificado, el usuario se asigna usando la propiedad Username, la cual lee de nu archivo XML los datos del usuario.

public string Username
        {
            set
            {
                lblUsername.Text = value;
                LoadProfile();
            }
            get
            {
                return lblUsername.Text;
            }
        }

              private void LoadProfile()
        {
            if (!String.IsNullOrEmpty(lblUsername.Text))
            {
                XDocument userXml = XDocument.Load(Server.MapPath("Data/Users.xml"));

                var userProfile = (from user in userXml.Descendants("user")
                                   where user.Attribute("id").Value == lblUsername.Text
                                   select user).Single();

                lblFirstname.Text = userProfile.Attribute("firstName").Value;
                lblLastname.Text = userProfile.Attribute("lastName").Value;
                lblRole.Text = userProfile.Attribute("role").Value;
            }
        }

image

Estos son User Controls normales, que pueden tener elementos ASP.NET cuyo HTML resultando será mostrado en otro sitio externo.

Crear la función JavaScript

Para que nuestra página RenderContro.aspx sea capaz de dibujar el control y devolver código JavaScript necesitamos sobreescribir dos métodos de la clase Page:

  1. CreateHtmlTextWriter
  2. Render

Si recordamos el ciclo de vida de una página ASP.NET: Init, Load, Render y Unload, nos damos cuenta de que justamente el método Render es el encargado de “dibujar en la página” el contenido:

StringWriter sw = new StringWriter();
HtmlTextWriter pageWriter = null;

protected override HtmlTextWriter CreateHtmlTextWriter(TextWriter tw)
        {
            pageWriter = base.CreateHtmlTextWriter(tw);
            return base.CreateHtmlTextWriter(sw);
        }

        protected override void Render(HtmlTextWriter writer)
        {
            base.Render(writer);
            string html = sw.ToString();
            html = html.Replace(Environment.NewLine, String.Empty);
            html = html.Replace("\"", "’");

            string script = "function render_" + controlName + uniqueId + "() { document.write(\"" + html + "\");}";

            pageWriter.Write(script);
        }

En el método CreateHtmlTextWriter estamos pasando un objeto StringWriter en lugar del predeterminado (TextWriter), es en este objeto donde el método Render insertará el código HTML de los controles. Todo el contenido de la página en forma de HTML, cualqueira que se este, será escrito dentro de nuestro  StringWriter, y posteriormente podremos manipularlo según nuestras necesidades.

En el método Render modificamos el HTML antes de que s dibuje en la página, de tal forma que el resultado sea una función JavaScript con el método document.write.

La función es creada dinámicamente y se forma de la siguiente forma:

  1. El prefijo “render_”
  2. El nombre del control.
  3. Un identificador único para el nombre de la función.
  4. El cuerpo de la función consiste del método document.write y el contenido es el HTML resultando de la página.

NOTA: Es siempre importante remover saltos de línea y comillas que del contenido puedan generar errores en la función JavaScript.

Insertar el control dinámicamente

La última parte de nuestro proyecto es insertar el control dinámicamente en la página para que se cree la función JavaScript. Insertar un control dinámicamente es muy sencillo en ASp.NET:

Control ctrl = LoadControl(@"~\UserControls\" + controlName + ".ascx");
canvas.Controls.Add(ctrl);

La parte interesante está en asginar las propiedades de forma dinámica a cada control. Por ejemplo asignar el valor de la propiedad Username de control UserProfile. Esto lo logré usando Reflection, gracias a esto puedo asignar el valor de cualqueir propiedad cuyo tipo de dato soporte el método Parse:

private void SetProperties(Control ctrl)
        {
            Type controlType = ctrl.GetType();
            List<PropertyInfo> properties =  controlType.GetProperties().ToList<PropertyInfo>();

            foreach (var qs in Request.QueryString)
            {
                if (!qs.ToString().Equals(qsControl, StringComparison.InvariantCultureIgnoreCase)
                    && !qs.ToString().Equals(qsUniqueId, StringComparison.InvariantCultureIgnoreCase))
                {
                    PropertyInfo currentProperty = properties.Find(delegate(PropertyInfo pi)
                    {
                        return pi.Name == qs.ToString();
                    });

                    if (currentProperty != null)
                    {
                        if (currentProperty.PropertyType.Name == "String")
                        {
                            currentProperty.SetValue(ctrl, Request.QueryString[qs.ToString()], null);
                        }
                        if (currentProperty.PropertyType.GetMember("Parse").Length > 0)
                        {
                            Object parsedValue = currentProperty.PropertyType.InvokeMember("Parse", BindingFlags.InvokeMethod, null, ctrl, new object[] { Request.QueryString[qs.ToString()] });
                            currentProperty.SetValue(ctrl, parsedValue, null);
                        }
                    }
                }
            }
        }

Este método recibe como parámetro el Control y lee del QueryString las propiedades que se le deben asignar mediante Reflection. De especial interés es el siguiente bloque de código:

if (currentProperty.PropertyType.GetMember("Parse").Length > 0)
                        {
                            Object parsedValue = currentProperty.PropertyType.InvokeMember("Parse", BindingFlags.InvokeMethod, null, ctrl, new object[] { Request.QueryString[qs.ToString()] });
                            currentProperty.SetValue(ctrl, parsedValue, null);
                        }

Esta sección de código permite transformar el valor de la propiedad que siempre viene como String al tipo de dato que espera la propiedad, por ejemplo Bool o Int. La transformación se la hace invocando dinámicamente el método Parse del tipo de datos de la propiedad.

Finalmente ya podemos incrustar controles ASP.NET en paginas desarrolladas en otras tecnologías, o páginas simples HTML, así:

<head>
    <title></title>
    <script src="RenderControl.aspx?control=UserProfile&Username=cintriago&UpperCase=true"></script>
    <script src="RenderControl.aspx?control=UserProfile&uniqueId=2&Username=jane"></script>
    <script src="RenderControl.aspx?control=UserProfile&uniqueId=3&Username=john"></script>
    <script src="RenderControl.aspx?control=AllUsers"></script>
    <script src="RenderControl.aspx?control=MyCalendar"></script>
</head>
<body>
<script language="javascript" type="text/javascript">        render_AllUsers();</script>
    <script language="javascript" type="text/javascript">        render_UserProfile();</script>
    <script language="javascript" type="text/javascript">        render_UserProfile2();</script>
    <script language="javascript" type="text/javascript">        render_MyCalendar();</script>
    <script language="javascript" type="text/javascript">        render_UserProfile3();</script>
</body>
</html>

Y en el navegador tendremos el siguiente resultado:

image Espero que este artículo les haya pareceido de utilidad en interés. Cualquier duda, comentario o sugerencia es bienvenida. Hasta la próxima!!.

Bajar el proyecto y código fuente