Saltar al contenido

Artículos, tutoriales, trucos, curiosidades, reflexiones y links sobre programación web ASP.NET Core, MVC, Blazor, SignalR, Entity Framework, C#, Azure, Javascript... y lo que venga ;)

17 años online

el blog de José M. Aguilar

Inicio El autor Contactar

Artículos, tutoriales, trucos, curiosidades, reflexiones y links sobre programación web
ASP.NET Core, MVC, Blazor, SignalR, Entity Framework, C#, Azure, Javascript...

 ¡Microsoft MVP!

Enlaces interesantes 8

domingo, 6 de junio de 2010
Estos son los enlaces publicados en Variable not found en Facebook desde el lunes, 24 de mayo de 2010 hasta el domingo, 06 de junio de 2010. Espero que os resulten interesantes :-)
Y no olvides que, si te interesa, puedes seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.
Publicado en: Variable not found

Publicado por José M. Aguilar a las 11:57 p. m.

Nadie ha comentado la entrada, ¿quieres ser el primero?
 

Etiquetas:

Parámetros opcionales: úsense con precaución

lunes, 31 de mayo de 2010
.NET Los parámetros opcionales son una interesante ayuda que hace tiempo que está presente en otros lenguajes como Visual Basic .NET, y ha sido introducida en la versión 4.0 de C#, para alegría de muchos.

A grandes rasgos, esta característica nos permite especificar valores por defecto para los parámetros de nuestros métodos, ahorrándonos tiempo de codificación:

class Program
{
    public static void Main(string[] args)
    {
        Muestra();            // Imprime 1,1
        Muestra(8);           // Imprime 8,1
        Muestra(3,4);         // Imprime 3,4
        Console.ReadKey();
    }
 
    static void Muestra(int a=1, int b=1)
    {
        Console.WriteLine(a + "," + b);
    }
}

Desde siempre, ignorante de mí, había pensado que esto no era más que una triquiñuela del compilador, un azucarillo sintáctico destinado a facilitarnos la creación de sobrecargas de forma rápida, pero, ahora que lo he estudiado algo más a fondo, resulta que no es así. De hecho, los parámetros opcionales están soportados a nivel de plataforma, y funcionan de forma algo extraña (o al menos diferente a lo que podía esperarse), por lo que es conveniente conocerlos bien para no cometer determinados errores.

En primer lugar, me ha llamado la atención que la detección de la ausencia de parámetros en la llamada y la asignación de los valores por defecto no la realiza el método en el que se han definido. Es decir, sobre el ejemplo anterior, no es el método Muestra() el que comprueba si se han suministrado valores para los parámetros a y b, ni el que le asigna los valores por defecto en caso contrario. Esta "comprobación" se realiza en tiempo de compilación (!).

Esto lo demostramos muy fácilmente si descompilamos esta misma aplicación con ayuda del imprescindible Reflector, que nos mostrará el siguiente código:

class Program
{
    public static void Main(string[] args)
    {
        Muestra(1, 1);
        Muestra(8, 1);
        Muestra(3, 4);
        Console.ReadKey();
    }
 
    public static void Muestra([Optional, DefaultParameterValue(1)] int a, 
     [Optional, DefaultParameterValue(1)] int b)
    {
        Console.WriteLine(a + ", " + b);
    }
}

Como se puede observar, se ha generado un método Muestra() cuyos parámetros incluyen atributos que indican su opcionalidad y el valor por defecto en cada caso.

Pero lo curioso está en el método Main(), desde donde se hacen las llamadas, el que podemos observar que las invocaciones a Muestra() incluyen valores para todos los parámetros, como si se tratara de constantes especificadas directamente por el desarrollador.

Por tanto, no hay nada mágico en los métodos con parámetros opcionales, ni sobrecargas, ni código de comprobación o asignación insertado de forma automática. Es el propio compilador el que, en el momento de generar el código IL, extrae los valores por defecto de los parámetros no especificados en la llamada examinando los atributos presentes en la signatura y los introduce en la invocación.

Y es aquí justo donde hay que tener cuidado al utilizar los parámetros opcionales. Dado que el valor de los parámetros se determina en tiempo de compilación y se incluyen como constantes en el código IL generado, pueden producirse efectos no deseados si trabajamos con distintos ensamblados.

Veámoslo con un ejemplo, que, aunque poco real, creo que ilustrará un escenario donde los parámetros opcionales podrían jugarnos una mala pasada.

En el siguiente código, perteneciente al ensamblado LogicaNegocio.dll, vemos un método CalculaImporteconIva(), que retorna un importe aplicándole el impuesto (IVA) correspondiente:

public class LogicaNegocio
{
    public double CalculaImporteConIva(double importe, double iva = 0.16)
    {
        return importe + importe*iva;
    }
}

Así, podemos tener un ensamblado externo, pongamos ERP.exe, que haga uso de este método de la siguiente forma:

public void muestraDesglose(double importe)
{
    double importeTotal = logica.CalculaImporteConIVA(importe)
    // Mostrarlo...
}

En el momento de compilación de ERP.exe, la llamada anterior quedará en el ensamblado resultante igual que si hubiéramos hecho esta llamada:
 
    double importeTotal = logica.CalculaImporteConIVA(importe, 0.16)

Si ahora se produce una subida de IVA (como lamentablemente va a ocurrir en breve), acudiríamos a modificar el valor por defecto del parámetro iva en el método CalculaImporteConIva() y recompilaríamos LogicaNegocio.dll:

public class LogicaNegocio
{
    public double CalculaImporteConIva(double importe, double iva = 0.18)
    {
        return importe + importe*iva;
    }
}

Sin embargo, si no recompilamos ERP.EXE desde éste seguiríamos enviándole el valor anterior (0.16, recordad que este valor aparece como constante en el ensamblado), lo que podía provocar algún problema. Es decir, si queremos mantener la coherencia del sistema, nos veríamos obligados a recompilar todos los ensamblados que referencien LogicaNegocio.dll.

Conclusión: en métodos públicos, y especialmente en aquellos que serán consumidos desde ensamblados externos, es conveniente utilizar parámetros opcionales sólo cuando los valores constantes sean “verdades universales”, como las constantes matemáticas o datos que con toda seguridad no van a cambiar.  No es buena idea utilizarlos para reflejar valores variables o constantes de lógica de negocio, con posibilidades de cambio aunque sean remotas.

Por último, comentar que aunque este post está centrado en C#, todas estas precauciones son igualmente válidas para Visual Basic .NET.

Publicado en: Variable not found

Publicado por José M. Aguilar a las 11:42 p. m.

Hay 5 comentarios, ¡participa tú también!
 

Etiquetas: , , ,

Cómo ejecutar paso a paso ASP.NET MVC framework

jueves, 27 de mayo de 2010
ASP.NET MVC La mejor forma de entender y conocer los entresijos de cualquier código es ver sus interioridades en funcionamiento: poder introducir puntos de ruptura, ejecutar paso a paso, ver los valores de parámetros, de retornos… incluso retocarlo para ver lo que ocurre.

En sistemas relativamente complejos como el framework MVC, puede sernos de mucha utilidad además para entender qué está pasando en determinadas circunstancias, y ayudarnos a decidir la solución óptima a un problema.

Una posibilidad es configurar Visual Studio para utilizar los servidores de símbolos de Microsoft (aquí hay un buen artículo que explica paso a paso cómo conseguirlo). Esto nos permitirá realizar el seguimiento sobre todo el framework ASP.NET, MVC incluido.

Sin embargo, dado que el código fuente de ASP.NET MVC está disponible en Codeplex, es realmente sencillo estudiar su funcionamiento de esta forma. Sólo seguir estos pasos:
  • en primer lugar, descargamos el código fuente desde Codeplex y descomprimimos el archivo en cualquier carpeta,
  • abrimos la solución con Visual Studio y la compilamos en modo depuración,
  • abrimos (o creamos) con Visual Studio un proyecto MVC,
  • eliminamos en éste las referencias que introducen las plantillas por defecto hacia el ensamblado System.Web.Mvc (del GAC),
  • añadimos la referencia hacia el ensamblado System.Web.Mvc que encontraremos en el directorio bin de la carpeta del código fuente del framework.
Y con estas sencillas operaciones, ya podemos comenzar a disfrutar de inolvidables sesiones de depuración y experimentación ;-)

Punto de ruptura en ASP.NET MVC

Publicado en: Variable not found
Hey, ¡estoy en twitter!

Publicado por José M. Aguilar a las 1:43 p. m.

Nadie ha comentado la entrada, ¿quieres ser el primero?
 

Etiquetas: , , , , , ,

¿Bug (sin importancia) en la plantilla de edición de MVC 2 con DateTime, decimal y double?

lunes, 24 de mayo de 2010
¿Habéis observado que al generar una vista de edición tipada sobre una entidad que contiene propiedades decimales o de fecha, Visual Studio os genera una llamada extraña al helper TextBoxFor()?

Vamos a verlo en detalle. Partimos de una entidad del Modelo como la siguiente:

Entidad del Modelo
Generamos ahora el andamiaje con Visual Studio, utilizando la opción correspondiente del menú contextual, indicando que se trata de una vista de edición, sobre la entidad Persona:

Añadiendo una vista tipada de edición
El código generado por el entorno será el habitual. Sin embargo, si nos fijamos en el control de edición que Visual Studio ha generado para la propiedad FechaNacimiento, podremos ver que contiene un parámetro extraño:

TextBoxFor con propiedades de tipo fecha

Durante mucho tiempo no me ha llamado la atención probablemente por la costumbre de verlo en llamadas al helper TextBox(), donde el segundo parámetro se utilizaba para especificar el valor por defecto del <input>. Además, dado que la edición de fechas suele realizarse de forma algo más seria (en breve hablaremos de eso por aquí) y el código generado suele eliminarse, tampoco me había fijado demasiado.

Sin embargo, en cuanto observas un poco las distintas sobrecargas de TextBoxFor(), es fácil darse cuenta de que esta llamada no es correcta. De hecho, si observamos la porción del código fuente HTML generado relativa a la edición de esta propiedad, nos encontraremos con esto:

Etiqueta input mal generada
¿Ein? ¿Length=”15”? ¿Te suena esto a algo? Seguro que sí ;-)

Efectivamente, el atributo extraño de la etiqueta <input> no es más que la propiedad Length de la cadena que estamos pasando a TextBoxFor en su segundo parámetro, reservado en la  sobrecarga de TextBoxFor que encaja con la llamada para especificar los atributos HTML personalizados:

public static MvcHtmlString TextBoxFor<TModel, TProperty>(
    this HtmlHelper<TModel> htmlHelper,
    Expression<Func<TModel, TProperty>> expression,
    Object htmlAttributes
)

Curiosamente, el TextBoxFor() sólo es generado así en las vistas de edición (Edit), y sobre propiedades de tipo DateTime, decimal y double; en las vistas de creación (Create) no ocurre este problema, ni con otros tipos de datos.

Pero bueno, ya que tenemos el destornillador en la mano, cuesta muy poco trabajo dejar las cosas en su sitio ;-). Como vimos en otra ocasión, el código de las vistas que genera Visual Studio está basado en plantillas T4, y es realmente sencillo modificarlo, así que vamos a ello.

En primer lugar, acudimos a la carpeta del IDE donde se almacenan estas plantillas:
  • (IDE)\Common7\IDE\ItemTemplates\CSharp\Web\MVC 2\CodeTemplates\AddView
Siendo (IDE) el directorio raíz de Visual Studio, normalmente dentro de \Archivos de programa.

A continuación hacemos una copia de seguridad de la plantilla llamada Edit.tt (que más vale prevenir…), la abrimos con cualquier editor de texto y buscamos en su la cadena “TextBoxFor”, que encontraremos en una porción de código como la siguiente:

Porción de Edit.tt original
Ahora lo único que tenemos que hacer es eliminar la porción <#= property.Value #>, que es la que se encarga de emitir los atributos incorrectos. De hecho, sería simplemente dejar la línea tal y como ésta aparece en la plantilla de creación (Create.tt):

Porción de edit.tt modificada
Hecho esto, al generar de nuevo vistas de edición, ya las fechas y decimales aparecerán como deben:

Edición de una fecha con TextBoxFor, corregida
En fin, se trata de un pequeño detalle en las plantillas de edición que hacen que se genere un código incorrecto al cliente. Nada importante, pero sin duda una buena excusa para profundizar en los mecanismos de andamiaje del framework.

Publicado en: Variable not found.

Publicado por José M. Aguilar a las 11:38 p. m.

Hay 2 comentarios, ¡participa tú también!
 

Etiquetas: , , , ,

Enlaces interesantes 7

domingo, 23 de mayo de 2010
Estos son los enlaces publicados en Variable not found en Facebook desde el domingo, 18 de abril de 2010 hasta el domingo, 23 de mayo de 2010. Espero que os resulten interesantes :-)
Y no olvides que, si te interesa, puedes seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.
Publicado en: Variable not found

Publicado por José M. Aguilar a las 11:46 p. m.

Nadie ha comentado la entrada, ¿quieres ser el primero?
 

Etiquetas: