Tengo publicados dos artículos sobre cómo empezar a trabajar con NHibernate y ASP.NET MVC, puede leerlos desde el sitio de ForerunnerG34:

•  Using ASP.NET MVC and NHibernate (Part 1)
• Using ASP.NET MVC and NHibernate (Part 2)

Espero les sirva de ayuda para las personas que recién están empezando con NHibernate"!

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

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):

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

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:

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.

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.

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

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/

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:

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:

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

MyCalendar.ascx: Contiene un ASP.NET Calendar

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;
            }
        }

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:

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

Ya está disponible hace unos momentos el Preview 2 de ASP.NET MVC 2 el cual pueden descargar desde aquí. Desde luego existe para toda la comundiad videos y documentación para conocer las nuevas características de este framework, entre las cuales destacan:

1. ModelMetadata and ModelMetadataProvider Classes: Proveen mecanismos para obtener metadados del modelo de una vista.
2. Model Validator Providers: Mecanismos para obtener la lógica de validación del modelo.
3. Client-Side Validation: Incluye la librería de validación de jQuery 2 y también para el lado del cliente.
4. RequireHttpsAttribute Action Filter: Nuevo atributo que puede ser aplicado a acciones y controladores. De forma predeterminada las peticiones no-SSL se redirigen a la llamada SSL equivalente (en el caso de estar disponible).
5. Soporte para Single-Project Areas.

Les recomiendo que visiten el Roadmap de ASP.NET MVC para ver es lo nuevo que se viene!.

Windows Communication Foundation nos permite desarrollar servicios en .Net  de una manera rápida y sencilla, permitiendo soportar varios endpoints y esquemas de configuración. También ofrece un gran nivel de personalización, uno de ellos es poder escribir OperationBehaviors personalizados para nuestro servicio.

Un OperationBehavior nos permite cambiar y controlar el modo en que WCF ejecuta un método, por ejemplo podemos ejecutar código automáticamente antes de que se llame a una operación o después. Este es el caso que veremos en el siguiente ejemplo:

Creación del Servicio

Ok manos a la obra, lo primero es crear un nuevo proyecto WCF, el cual llamaremos “CalculatorService”

Luego agregamos dos operaciones a nuestro servicio, tanto en la interfaz como en la implementación: Add y Substract, como se ve en la siguiente figura:

Estas dos funciones lo que hacen es agregar y restar un valor de la variable de instancia _currentValue.

Ejecutamos el proyecto, y Visual Studio abrirá un cliente básico para poder probar nuestro servicio:

Behaviors

Ahora haremos algo interesante: Cada vez que se llame al método Add o Substract invocaremos de forma automática a un tercer método llamado “Audit”, esto lo hacemos usando OperationBehviors que nos permitirá tener acceso a personalizar la invocación de nuestros métodos.

En el proyecto de nuestro servicio WCF creamos una nueva carpeta llamada Behaviors ya agregamos una nueva clase llamada “MyOperationBehavior.cs” con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;

namespace CalculatorService.Behaviors
{
    public class MyOperationBehavior : Attribute, IOperationBehavior
    {

        #region IOperationBehavior Members

        public void AddBindingParameters(OperationDescription operationDescription, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
        {
        }

        public void ApplyClientBehavior(OperationDescription operationDescription, System.ServiceModel.Dispatcher.ClientOperation clientOperation)
        {
        }

        public void ApplyDispatchBehavior(OperationDescription operationDescription, System.ServiceModel.Dispatcher.DispatchOperation dispatchOperation)
        {

// Decorator pattern.
            dispatchOperation.Invoker = new MyOperationInvoker(dispatchOperation);
        }

        public void Validate(OperationDescription operationDescription)
        {
        }

        #endregion
    }

    class MyOperationInvoker : IOperationInvoker
    {
        private readonly IOperationInvoker _invoker;
        private readonly System.ServiceModel.Dispatcher.DispatchOperation _dispatchOperation;

        public MyOperationInvoker(System.ServiceModel.Dispatcher.DispatchOperation dispatchOperation)
        {
            this._invoker = dispatchOperation.Invoker;
            this._dispatchOperation = dispatchOperation;
        }

        private void HandleOperationRequest(object instance, object[] inputs)
        {
            Service1 srv = (Service1)instance;
            srv.Audit(_dispatchOperation.Name, inputs);
        }

        #region IOperationInvoker Members

        public object[] AllocateInputs()
        {
            return _invoker.AllocateInputs();
        }

        public object Invoke(object instance, object[] inputs, out object[] outputs)
        {
            HandleOperationRequest(instance, inputs);
            return _invoker.Invoke(instance, inputs, out outputs);
        }

        public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
        {
            HandleOperationRequest(instance, inputs);
            return _invoker.InvokeBegin(instance, inputs, callback, state);
        }

        public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)
        {
            return _invoker.InvokeEnd(instance, out outputs, result);
        }

        public bool IsSynchronous
        {
            get { return _invoker.IsSynchronous; }
        }

        #endregion
    }
}

Ahora decoramos nuestros métodos Add y Substract con el atributo anterior y creamos el método “Audit”:

Lo que hemos hecho hasta el momento es crear una clase MyOperationBehavior que se encarga de conectar el MyOperationInvoker al servicio. Al aplicar el atributo  [MyOperationBehavior] en cada operación hacemos que WCF use nuestro Operation Invoker para llamar a las respectivas funciones.

Dentro de MyOperationInvoker estamos llamando primero al método Audit para imprimir en pantalla la operación que el usuario está a punto de ejecutar.

Esto nos da el control de poder ejecutar código adicional antes de que se ejecute el método que invocó el cliente (o incluso desués). Si volvemos a ejecutar el servicio podemos ver los resultados en la ventana “Output” de Visual Studio 2010.

Nota: Este mismo resultado se pudo obtener llamando desde los métodos Add y Substract al método Audit. Pero gracias a los OperationBehaviors podemos remover esta lógica de cada posible método que tengamos y ponerla en un solo lugar.