Scott Guthrie, en el anuncio de la publicación en Codeplex de la actualización del código del framework MVC del pasado mes de abril, comentó que uno de los cambios en los que estaban trabajando era en la modificación de las acciones de un controlador, haciendo que éstas pasaran a retornar un objeto del tipo ActionResult.

Como recordaréis, hasta ese momento las acciones no tenían tipo de retorno, pero han replanteado el diseño para hacerlo más flexible, testable y potente. Así, pasamos de definir las acciones de esta forma:

public void Index()
{
  RenderView("Index");
}

 
a esta otra:

public ActionResult Index() 
{
  return RenderView();
}

 
En el código anterior destacan dos aspectos. En primer lugar que la llamada a RenderView() no tiene parámetros; el sistema mostrará la vista cuyo nombre coincida con el de la acción que se está ejecutando (Index, en este caso). En segundo lugar, que la llamada a RenderView() retorna un objeto ActionResult (o más concretamente un descendiente, RenderViewResult), que será el devuelto por la acción.

De la misma forma, existen tipos de ActionResult concretos para retornar el resultado de las acciones más habituales:

• RenderViewResult, retornado cuando se llama desde el controlador a RenderView().
• ActionRedirectResult, retornado al llamar a RedirectToAction()
• HttpRedirectResult, que será la respuesta a un Redirect()
• EmptyResult, que intuyo que será para casos en los que no hay que hacer nada (!), aunque todavía no le he visto mucho el sentido...

Además de las citadas anteriormente, una de las ventajas de retornar estos objetos desde los controladores es que podemos crear nuestra clase, siempre heredando de ActionResult, e implementar comportamientos personalizados.

Esto es lo que ha hecho el genial Phil Haack en dos ejemplos recientemente publicados en su blog.

El primero de ellos, publicado en el post "Writing A Custom File Download Action Result For ASP.NET MVC" muestra una implementación de una acción cuya invocación hace que el cliente descargue, mediante un download, el archivo indicado, en su ejemplo, el archivo CSS de su sitio web:

public ActionResult Download() 
{
  return new DownloadResult 
    { VirtualPath="~/content/site.css", 
      FileDownloadName = "TheSiteCss.css"
    };
}

 
La clase DownloadResult una descendiente de ActionResult, en cuya implementación encontraremos, además de la definición de las propiedades VirtualPath y FileDownloadName, la implementación del método ExecuteResult, que será invocado por el framework al finalizar la ejecución de la acción, y donde realmente se realiza el envío al cliente del archivo, con parámetro content-disposition convenientemente establecido:

public class DownloadResult : ActionResult 
{
  public DownloadResult() 
  {
  }

  public DownloadResult(string virtualPath) 
  {
    this.VirtualPath = virtualPath;
  }

  public string VirtualPath { get; set; }

  public string FileDownloadName { get; set; }

  public override void ExecuteResult(ControllerContext context) 
  {
    if (!String.IsNullOrEmpty(FileDownloadName)) {
      context.HttpContext.Response.AddHeader("content-disposition", 
        "attachment; filename=" + this.FileDownloadName)
    }
    string filePath = context.HttpContext.Server.MapPath(this.VirtualPath);
    context.HttpContext.Response.TransmitFile(filePath);
  }
}

 

El segundo ejemplo, publicado en el post "Delegating Action Result", vuelve a demostrar otro posible uso de los ActionResults creando un nuevo descendiente, DelegatingResult, que puede ser retornado desde las acciones para indicar qué operaciones deben llevarse a cabo por el framework.

El siguiente código muestra cómo retornamos un objeto de este tipo, inicializado con una lambda:

public ActionResult Hello() 
{
  return new DelegatingResult(context => 
  {
    context.HttpContext.Response.AddHeader("something", "something");
    context.HttpContext.Response.Write("Hello World!");
  });
}

 
Como veremos a continuación, el constructor de este nuevo tipo recibe un parámetro de tipo Action<ControllerContext> y lo almacenará de forma local en la propiedad Command, postergando su ejecución hasta más adelante; será la sobreescritura del método ExecuteResult la que ejecutará el comando:

public class DelegatingResult : ActionResult 
{
  public Action<ControllerContext> Command { get; private set; }
    
  public DelegatingResult(Action<ControllerContext> command) 
  {
    this.Command = command;
  }

  public override void ExecuteResult(ControllerContext context) 
  {
    if (context == null)
      throw new ArgumentNullException("context");
        
    Command(context);
  }
}

 
Puedes ver el código completo de ambos ejemplos, así como descargar proyectos de prueba en los artículos originales de Phil Haack:

• "Writing A Custom File Download Action Result For ASP.NET MVC"
• "Delegating Action Result"

Por último, recordar que todos estos detalles son relativos a la última actualización de la preview de esta tecnología y podrían variar en futuras revisiones.

Publicado en: www.variablenotfound.com.

Desde siempre me han fascinado los motores de física en tiempo real, probablemente debido a mi absoluta ignorancia en el tema. De hecho, cada vez que me topo con alguna demostración de uno de ellos, no puedo evitar pasar un buen rato jugando y observando los efectos que de forma tan asombrosa simulan la realidad.

Fisix, por ejemplo, es un motor de física en 2 dimensiones desarrollado en ActionScript 3.0 para desarrolladores de juegos o simuladores en Flash. Aunque en su web podéis encontrar más demos, incrusto una aquí para que os hagáis a la idea de lo que puede llegar a conseguirse con esta librería (podéis probar a arrastrar la muñeca por la pantalla o interactuar con los objetos).

Actualmente se encuentra en su versión alfa 0.5, y puede ser utilizado sin coste exclusivamente en proyectos no comerciales; para otros usos hay que contactar con el autor. En cualquier caso, por el tiempo que ha pasado desde su última actualización, parece que no está muy al día.

Publicado en: www.variablenotfound.com.

Me he encontrado en el blog de Fresh Logic Studios con un post donde describen una técnica interesante para obtener descripciones textuales de los elementos de una enumeración. De hecho, ya la había visto hace tiempo en I know the answer como una aplicación de los métodos de extensión para mejorar una solución que aportaba en un post anterior.

Como sabemos, si desde una aplicación queremos obtener una descripción comprensible de un elemento de una enumeración, normalmente no podemos realizar una conversión directa (elemento.ToString()) del mismo, pues obtenemos los nombres de los identificadores usados a nivel de código. La solución habitual, hasta la llegada de C# 3.0 consistía en incluir dentro de alguna clase de utilidad un conversor estático que recibiera como parámetro en elemento de la enumeración y retornara un string, algo así como:

        
  public static string EstadoProyecto2String(EstadoProyecto e)
  {
    switch (e)
    {
      case EstadoProyecto.PendienteDeAceptacion:
        return "Pendiente de aceptación";
      case EstadoProyecto.EnRealizacion:
        return "En realización";
      case EstadoProyecto.Finalizado:
        return "Finalizado";
      default:
        throw 
          new ArgumentOutOfRangeException("Error: " + e);
    }
  }

 
Este método, sin embargo, presenta algunos inconvenientes. En primer lugar, dado el tipado fuerte del parámetro de entrada del método, es necesario crear una función similar para cada enumeración sobre la que queramos realizar la operación.

También puede resultar peligroso separar la definición de la enumeración del método que transforma sus elementos a cadena de caracteres, puesto que puede perderse la sincronización entre ambos cuando, por ejemplo, se introduzca un nuevo elemento en ella y no se actualice el método con la descripción asociada.

La solución, que como he comentado me pareció muy interesante, consiste en decorar cada elemento de la enumeración con un atributo que describa al mismo, e implementar un método de extensión sobre la clase base System.Enum para obtener estos valores. Veamos cómo.

Ah, una cosa más. Aunque los ejemplos están escritos en C#, se puede conseguir exactamente el mismo resultado en VB.NET simplemente realizando las correspondientes adaptaciones sintácticas. Podrás encontrarlo al final del post.

1. Declaración de la enumeración

Vamos a usar el atributo System.ComponentModel.DescriptionAttribute, aunque podríamos usar cualquier otro que nos interese, o incluso crear nuestro propio atributo personalizado. El código de definición de la enumeración sería así:

  using System.ComponentModel;

  public enum EstadoProyecto
  {
    [Description("Pendiente de aceptación")] PendienteDeAceptacion,
    [Description("En realización")]          EnRealizacion,
    [Description("Finalizado")]              Finalizado,
    [Description("Facturado y cerrado")]     FacturadoYCerrado
  }

 

2. Implementación del método de extensión

Ahora vamos a crear el método de extensión (¿qué son los métodos de extensión?) que se aplicará a todas las enumeraciones.

Fijaos que el parámetro de entrada del método está precedido por la palabra reservada this y el tipo es System.Enum, por lo que será aplicable a cualquier enumeración.

using System;
using System.ComponentModel;
using System.Reflection;

public static class Utils
{
  public static string GetDescription(this Enum e)
  {
    FieldInfo field = e.GetType().GetField(e.ToString());
    if (field != null)
    {
      object[] attribs = 
        field.GetCustomAttributes(typeof(DescriptionAttribute), false);

      if (attribs.Length > 0)
        return (attribs[0] as DescriptionAttribute).Description;
    }
    return e.ToString();
  }
}

 

Y voila! A partir de este momento tendremos a nuestra disposición el método GetDescription(), que nos devolverá el texto asociado al elemento de la enumeración; si éste no existe, es decir, si no se ha decorado el elemento con el atributo apropiado, nos devolverá el identificador utilizado.

De esta forma eliminamos de un plumazo los dos inconvenientes citados anteriormente: la separación entre la definición de la enumeración y los textos descriptivos, y la necesidad de crear un conversor a texto por cada enumeración que usemos en nuestra aplicación.

Y por cierto, el equivalente en VB.NET completo sería:

Imports System.ComponentModel
Imports System.Reflection
Imports System.Runtime.CompilerServices

Module Module1
    Public Enum EstadoProyecto
        <Description("Pendiente de aceptación")> PendienteDeAceptacion
        <Description("En realización")> EnRealizacion
        <Description("Finalizado")> Finalizado
        <Description("Facturado y cerrado")> FacturadoYCerrado
    End Enum

    <Extension()> _
    Public Function GetDescription(ByVal e As System.Enum) As String
        Dim field As FieldInfo = e.GetType().GetField(e.ToString())
        If Not (field Is Nothing) Then
            Dim attribs() As Object = _
                field.GetCustomAttributes(GetType(DescriptionAttribute), False)
            If attribs.Length > 0 Then
                Return CType(attribs(0), DescriptionAttribute).Description
            End If
        End If
        Return e.ToString()
    End Function
End Module

 


Publicado en: www.variablenotfound.com.

De nuevo en ASP.NET Resources encuentro una magnífica recopilación, en forma de chuletas de consulta rápida, de las librerías javascript disponibles en cliente usando ASP.NET Ajax. Puedes descargar el archivo pulsando sobre la imagen:



El archivo distribuido, un zip, contiene siete chuletas en formato PDF:

• Extensiones a los tipos String y Object
• Extensiones a los tipos Number y Error
• Referencia del tipo DomEvent
• Extensiones al tipo DomElement
• Extensiones a los tipos Date y Boolean
• Eventos del ciclo de vida en cliente
• Extensiones al tipo Array

ScottGu ya le dio difusión a través de su blog hace más de un año, así que probablemente no sea nada nuevo para muchos, pero para mí ha sido todo un descubrimiento.

Publicado en: www.variablenotfound.com.

Días atrás hablaba de las formas de inicialización de objetos que nos proporcionaban las últimas versiones de C# y VB.Net, que permitían asignar valores a miembros de instancia de forma muy compacta, legible y cómoda.

C# 3.0 nos trae otra sorpresa, también relacionada con el establecimiento de valores iniciales de elementos: los inicializadores de colecciones. Aunque esta característica también estaba prevista para VB.Net 9.0, al final fue desplazada a futuras versiones por problemas de tiempo.

Para inicializar una colección, hasta ahora era necesario en primer lugar crear la clase correspondiente para, a continuación, realizar sucesivas invocaciones al método Add() con cada uno de los elementos a añadir:

 List<string> ls = new List<string>();
 ls.Add("Uno");
 ls.Add("Dos");
 ls.Add("Tres");

 
C# 3.0 permite una alternativa mucho más elegante y rápida de codificar, simplemente se introducen los elementos a añadir a la colección entre llaves (como se hacía con los inicializadores de arrays o los nuevos inicializadores de objetos), separados por comas, como en el siguiente ejemplo:

 List<string> ls = 
     new List<string>() { "Uno", "Dos", "Tres" };

 
Si desensamblamos el ejecutable resultante, podremos ver que es el compilador el que ha añadido por nosotros los Add() de cada uno de los elementos después de instanciar la colección:

 newobj   instance void class 
          [mscorlib]System.Collections.Generic.List`1<string>::.ctor()
 stloc.s  '<>g__initLocal0'
 ldloc.s  '<>g__initLocal0'
 ldstr    "Uno"
 callvirt instance void class 
          [mscorlib]System.Collections.Generic.List`1<string>::Add(!0)
 nop
 ldloc.s  '<>g__initLocal0'
 ldstr    "Dos"
 callvirt instance void class 
          [mscorlib]System.Collections.Generic.List`1<string>::Add(!0)
 nop
 ldloc.s  '<>g__initLocal0'
 ldstr    "Tres"
 callvirt instance void class 
          [mscorlib]System.Collections.Generic.List`1<string>::Add(!0)
 nop

 
Uniendo esto ahora con los inicializadores de objetos que ya tratamos un post anterior, fijaos en la potencia del resultado:

 List<Persona> lp = new List<Persona>
 {
   new Persona { Nombre="Juan", Edad=34 },
   new Persona { Nombre="Luis", Edad=53 },
   new Persona { Nombre="José", Edad=23 }
 };

 
Efectivamente, cada elemento es una nueva instancia de la clase Persona, con las propiedades que nos interesan inicializadas de forma directa. De hacerlo con los métodos tradicionales, para conseguir el mismo resultado deberíamos utilizar muuuchas más líneas de código.

Otro ejemplo que demuestra aún más la potencia de esta característica:

 var nums = new SortedList
 {
   { 34, "Treinta y cuatro" },
   { 12, "Doce" },
   { 3, "Tres" }
 };
 foreach (var e in nums)
   Console.WriteLine(e.Key + " " + e.Value);

 
En el código anterior podemos ver, primero, el uso de variables locales de tipo implícito, para ahorrarnos tener que escribir más de la cuenta. En segundo lugar, se muestra cómo se inicializa una colección cuyo método Add() requiere dos parámetros. En el caso de un SortedList<TKey, TValue>, su método Add() requiere la clave de ordenación y el valor del elemento.

(Obviamente, el resultado de la ejecución del código anterior será la lista ordenada por su valor numérico (Key))

En conclusión, se trata de otra de las innumerables ventajas que nos ofrece la nueva versión de C# destinadas a evitarnos pulsaciones innecesarias, y a la que seguro le daremos uso.

Publicado en: www.variablenotfound.com.

Buscando información sobre los operadores estándar de consulta de Linq, me he topado en ASP.NET Resources con una chuleta (cheat sheet) que nos puede valer para tener siempre a mano una referencia rápida de los mismos, y de paso, adornar alguna pared que tengamos vacía ;-).

Puedes descargarla pulsando sobre la imagen:



Si quieres leer más sobre estos operadores, puedes probar también en la referencia oficial, The .Net Standard Query Operators [ING], a leer este artículo traducido por el maestro Octavio Hernández, profundizar en MSDN, o en otros de los muchos sitios con información relacionada, como la referencia de Hooked On Linq [ING].

Publicado en: http://www.variablenotfound.com/.