Del pasado 15 al 17 de Marzo se llevó a cabo la conferencia MIX10, que es una serie de conferencias de diseño y desarrollo web organizada por Microsoft, con platicas impartidas por la gente que está causando más impacto en la comunidad de desarrollo online (las sesiones son escogidas en base a votos, durante meses anteriores al evento).

Las platicas de este año se ve que estuvieron muy interesantes…así que aquí les dejo las ligas a los videos de las pláticas y también a una muy buena sección de recursos que armaron en el site de MIX10, con ligas a guías de desarrollo para Windows 7 Phone Series, Silverlight 4, WCF RIA y otros tantos temas que son lo relevante de hoy en día.

Algunas de las pláticas fueron:

• Overview of the Windows Phone 7 Series Application Platform
• 10 Ways to Attack a Design Problem and Come Out Winning
• Stepping Outside the Browser with Microsoft Silverlight 4
• Total Experience Design
• Understanding the Model-View-ViewModel Pattern
• Beyond File | New Company: From Cheesy Sample to Social Platform
• The Microsoft Silverlight Analytics Framework

Ligas:

MIX10 – The Next Web Now

MIX10 – Resources Page (Windows 7 Phone Series, Silverlight 4, etc)

La semana pasada descubrí AutoMapper, que es un proyecto de .NET gratis y open-source de Jimmy Bogard.

Un desarrollador de la oficina me preguntó si había una manera integrada en el framework de transformar las clases generadas por LINQ-To-SQL en clases sencillas (DTOs). No creí que lo hubiera…pero le comenté que seguramente lo podía hacer por Reflection. Yo ya habia hecho eso antes, pero supuse que debía haber alguna mejor manera. Después de buscar un poco en StackOverflow.com, alguna de las respuestas linkeaba a AutoMapper y descubrí que era exactamente lo que aquel desarrollador estaba buscando.

AutoMapper es descrito en su página principal de la siguiente manera:

AutoMapper uses a fluent configuration API to define an object-object mapping strategy. AutoMapper uses a convention-based matching algorithm to match up source to destination values. Currently, AutoMapper is geared towards model projection scenarios to flatten complex object models to DTOs and other simple objects, whose design is better suited for serialization, communication, messaging, or simply an anti-corruption layer between the domain and application layer.

Excelente…no solo utiliza interfaces fluidas, sino que también se basa en Convention Over Configuration. Es decir…solo tenemos que (y podemos!) configurar las situaciones excepcionales. Las ventajas que le veo a utilizar AutoMapper (a pesar de estar incorporando una referencia más a nuestros proyectos) es que es un proyecto público (de open source) y que además tiene a un muy buen desarrollador respaldándolo, que por ser su proyecto, se enfoca en mejorarlo y perfeccionarlo con nuevas funcionalidades, haciéndolo más eficiente, etc. Además, debido a que ya tiene una considerable base de usuarios (3,702 downloads), la mayoría de los bugs que pudiéramos toparnos, ya han sido resueltos.

Un ejemplo exagerádamente básico del uso de AutoMapper:

public class Class1
 {
   public string FullName { get; set; }
   public int Age { get; set; }
   public char Gender { get; set; }
   public void DoIt()
   {
     Console.WriteLine("Test");
   }

   public List<string> Addresses { get; set; }

   public Class1()
   {
     Addresses = new List<string>();
   }
 }

 public class Class2
 {
   public string FullName { get; set; }
   public int Age { get; set; }
   public char Gender { get; set; }
 }

private void Form1_Load(object sender, EventArgs e)
{
   Mapper.CreateMap<Class1, Class2>();

   var c2 = Mapper.Map<Class1, Class2>(c1);
   MessageBox.Show(c2.FullName);
}

Ok, de este ejemplo podemos ver:

• Class1 es poco más compleja que Class2, ya que tiene una List<string> y un método definido (DoIt())
• Class2 es una versión simple de Class1, con el objetivo de funcionar como un Data Transfer Object.

Como pueden ver, con la instrucción:

Mapper.CreateMap<Class1, Class2>();

estamos indicándole a AutoMapper que la Class1 y Class2 están relacionadas (mappeadas). Y la siguiente línea de código:

var c2 = Mapper.Map<Class1, Class2>(c1);</pre>

está creando una instancia de tipo Class2, basada en la instancia de c1 que ya teníamos, inicializada y asignando dinámicamente los valores de dicha instancia (c1) a la nueva instancia c2.

Class1, en este caso, sería un ejemplo de una clase de LINQ-To-SQL, mientras que Class2 sería la clase que queremos usar como DTO.

Esta funcionalidad es sólamente la más básica de AutoMapper (flattening). También soporta proyecciones (utilizar ciertas propiedades o sub-sets de un valor para mapear a otra propiedad), Listas y Arrays, etc. Para más información, visisten la documentación de AutoMapper.

Y sobre el buen artículo de diseño…para mi sorpresa lo encontré 2 dias después de haber descubierto AutoMapper, y el artículo lo escribió Jimmy Bogard.

El artículo se llama originalmente “Strengthening your domain: Encapsulated collections“. Jimmy habla de como debemos de diseñar nuestras clases para no exponer inadvertidamente funcionalidad de más (extra, innecesaria) que podría permitir operaciones no lógicas sobre nuestras entidades, y enfocarnos en soportar exclusiva y claramente sólo las operaciones que el dominio de negocio debe permitir sobre las entidades de nuestro proyecto. El artículo también me hizo pensar que los accesors son algo que mucha gente no considera a la hora de exponer sus propiedades. Léanlo y si gustan dejar sus comentarios…adelante.

.NET

Tantas opciones que hay para formatear strings en.NET, que es difícil memorizar todas.

Hoy tuve que formatear una cifra numérica que en la base de datos está como decimal, pero en el UI no quería desplegar ninguno de los decimales. Casi todo el mundo ha utilizado el string.Format(“{0:C”), el cual formatearía como si la cantidad fuera una cifra monetaria, pero eso implica tener decimales.

Algua persona podría pensar en realizar esto desde el stored procedure o el query que trae la información, pero personalmente creo que eso es un error, ya que los datos deben estar siempre  intactos y lo unico que debemos modificar es el formato en el que los queremos desplegar. Además, eso implicaría tener que estar controlando también el formato del símbolo separador de miles. Esto es algo que simplemente no se debe hacer en base de datos.

Googleando, encontré en los forums de ASP.NET la siguiente manera de hacerlo, pero tampoco es la más correcta:

System.Globalization.NumberFormatInfo nfi = new System.Globalization.NumberFormatInfo();
nfi.CurrencyDecimalDigits = 0;
nfi.CurrencySymbol ="$";
myLabel.Text =string.Format(nfi,"{0:C}", ad.Price);

Ya que estoy utilizando esto en un control Repeater, tendría que crear un método con las primeras 3 líneas de texto anteriores, y eso implicaría estar generando varias instancias de NumberFormatInfo.

Para ya no hacer más largo este post, les dejo la solución correcta.

string.Format("0:C0", ad.Price);

Así de sencillo…y no lo especifican en ningun lugar de MSDN…lo vine a encontrar aqui: .NET Format String 101. Obvio decirlo, basta cambiar el C0 por C1, C2, C3 o Cx para determinar el número de decimales que queremos desplegar. Esto también hace mucho más facil poner ese format string en el archivo de configuración y poder reutilizarlo en varias pantallas sin tener que estar cambiando código.

Les dejo también otra buena referencia de string.Format: String Formatting in C#

.NET

Esto es algo que descubrí hoy referente a formateo de números en .NET y que por más simple que parezca, tiene mucha utilidad, ya que puede reducir un bloque de 3 o 6 líneas de código, a una sola línea.

En lugar de necesitar varios if’s para evaluar el valor del número que vamos a formatear y poder determinar el formato que se va a aplicar (desplegar el número entre paréntesis si es negativo, desplegar la palabra Cero si el número es 0, etc), se puede hacer todo el una sola línea, ya que el metodo ToString() permite formatos condicionales de 2 o 3 condiciones…es decir, podemos hacer esto:

const string formato = "000;(##);Cero";

 Console.WriteLine(7.ToString(formato)); // va a desplegar "007"
 Console.WriteLine((-5).ToString(formato)); // va a desplegar "(5)"
 Console.WriteLine(0.ToString(formato)); // va a desplegar "Cero"

Formatos condicionales en .NET usando ToString()

El formato entonces es:  “positivo;negativo;cero”.

También es posible especificar solo el formato positivo y negativo.

Espero les sirva.

.NET

Todos los días se aprende algo…

Desde hace mucho tenemos disponible el operador ternario (o condicional) en C#, también conocido como el operador “?“.

El operador ternario sirve para regresar/usar uno de dos posibles valores, dependiendo de una condición boleana.

La estructura es:

condicion-boleana ? valor-si-se-cumple : valor-si-no-se-cumple

Es decir, permite reducir de esto:

int? myVar; //variable int nullable

if(string.IsNullOrEmpty(textbox1.Text))

{ myVar = null; }

else

{ myVar = Convert.ToInt32(textbox1.Text); }

a esto:

myVar =string.IsNullOrEmpty(textbox1.Text) ? null : Convert.ToInt32(textbox1.Text);

Y uno esperaría que el código del segundo bloque compile, pero no es así. En lugar de que funcione, el compilador nos marca el siguiente error:

Type of conditional expression cannot be determined because there is no implicit conversion between ‘<null>’ and ‘int’

Yo llevaba años usando el operador ternario y siempre me pareció ilógico que no se permitiera esto. Y probablemente fue más ilógico el hecho de nunca haber googleado como solucionar esto..ya que la solución es simple.

myVar =string.IsNullOrEmpty(textbox1.Text) ? (int?)null : Convert.ToInt32(textbox1.Text);

o

myVar =string.IsNullOrEmpty(textbox1.Text) ? null : (int?)Convert.ToInt32(textbox1.Text);

Simple…el compilador tenía razon. No hay una conversión implícita entre null e int, pero sí entre null y Nullable<int> (a.k.a. int?). Casteando cualquiera de los lados de la expresión, va a compilar sin problemas.

Espero les sirva.

Visual Studio 2008 Logo

Ya hace meses que no configuraba Subsonic desde cero en un proyecto, y por lo visto la última vez que lo hice, fue Subsonic 3.0 para un proyecto de Windows Forms.

Hago este post porque no está señalado en letras grandes en la pagina de Subsonic (supongo que esperan que todo mundo lo sepa de antemano), pero los archivos .tt que hay que arrastrar como parte del setup de SubSonic, simplemente no funcionan en proyectos de tipo Website.

Es decir, si queremos utilizar SubSonic 3.0 en un proyecto de tipo Website, la solucion es agregar un proyecto de tipo Class Library, arrastrar los archivos .tt a ese proyecto, y luego hacer referencia a la Class Library desde el proyecto tipo Website.

Hay otra solucion que es utilizar la Command-Line Tool  for Text Templates (de Microsoft), y en el siguiente artículo explican como usarla en Website projects: Visual Studio Website Projects: Add context menu for T4 files. El unico problema con esta alternativa es que el context menu que se agrega, se muestra para todos los tipos de archivos en Visual Studio, no solo los archivos T4.

Como referencia al problema, les dejo una liga a una pregunta en StackOverflow.com, en la que mencionan algunos de los principales problemas con los que se topa la gente al estar configurando Subsonic. De hecho, uno de los comentarios que hacen es precisamente que deberían de especificar esto de los .tt’s en Website projects desde el inicio.

Post: SubSonic 3 Installation doesn’t work?

.NET Logo

Estoy trabajando en adaptar un diseño HTML/CSS a una aplicación existente de ASP.NET, en Webforms.

Ya estando casi todo lo visual adaptado, y viendose bien, me faltaba transformar una forma de log-in a mark-up de XML, para poder hacer el código de Login.

Como el usuario debía poder loggearse desde cualquier ASPX de la parte pública, decidi transformar los controles de log-in originales en un ASP.NET User Control (ASCX), para poder tener la logica de todo el log-in en un solo lugar, y poder reutilizar el User Control en todas las paginas publicas.

Cree el puro ASCX con el Markup, y abri la pagina en IE. Todo bien.

Convertí el <input type=”button”> a un <asp:ImageButton>.  Error, tengo que agregar la etiqueta de <form runat=server>.

Agregué la etiqueta, View in Browser, no mas error, pero todo el contenido del panel derecho se desplazó hacia abajo.

Despues de batallar como 1 hora con el problema, e intentar googlear, me topé con un artículo que tenía como título “Multiple forms causing strange CSS problem“. Pero yo no tengo multiples formas (eso creí), así que lo ignoré.

Despues de media hora de moverle…recordé que todo el problema empezó cuando agregué la etiqueta de <form runat=server> al ASPX. Regreso al mark-up del User Control (ASCX) y ahi estaba…no había borrado la etiqueta de <form> original al momento de pasar el HTML de la forma de log-in.

Borre la etiqueta de <form> del User Control, y listo…el diseño se ve bien otra vez.

Así que como moraleja….Tener mas de una etiqueta <form> en una ASP.NET Webform te genera problemas raros de CSS.

Channel 9 Logo

La gente de Channel 9, uno de los mejores sites para aprender de desarrollo y especificamente de .NET, acaba de abrir una sección nueva llamada Channel 9 Learning Center.

Para inaugurar la sección, publicaron dos cursos iniciales:

• Visual Studio 2010 and .NET Framework 4.0
• Windows 7 Online Training

Visual Studio 2010 Logo

La calidad del contenido que este site genera es buenísima. Los videos siempre son interesantes, y las personas que conducen y son entrevistadas en los videos siempre es gente importante y muy conocedora de la industria.

Algunos de los temas del curso de Visual Studio 2010 son:

• ASP.NET 4.0
• Data Platform
• Application Lifecycle Management
• Windows Communication Foundation and Workflow
• Managed Languages

Así que si no se quieren quedar obsoletos…vayan a aprovechar este material. Las mejoras en el .NET Framework 4.0 son muchas, y esta version implica cambio de CLR…así que hay mucho que aprender.

La medición del tiempo se hace usando una instancia de la clase StopWatch, que se encuentra en el namespace de System.Diagnostics. La clase StopWatch provee un conjunto de métodos y propiedades que pueden ser usados para medir con alta precisión el tiempo transcurrido entre intervalos.

Los métodos disponibles sobre esta instancia serían:

• Start() - inicia el contador a partir del último lapso. La cuenta es acumulativa, es decir, si se verifica la propiedad ElapsedMilliseconds después de 4 llamadas a los métodos de Start y Stop, el tiempo desplegado será el acumulado de los 4 intervalos.
• Stop() - detiene momentaneamente el timer.
• Reset() - reinicia los valores almacenados del timer

Las propiedades disponibles, que usaríamos para desplegar el tiempo que tomó alguna rutina, serían:

• Elapsed - Regresa una instancia de tipo TimeSpan que determina el tiempo que ha transcurrido desde que se llamó al método Start() por primera vez.
• ElapsedMilliseconds – Regresa un valor de tipo long que indica los milisegundos transcurridos desde la primera vez que se llamó al método Start().
• ElapsedTicks - Regresa un valor de tipo long, que indica los Ticks que han pasado desde la primera vez que se llamó al método Start(). Nota importante respecto a esta propiedad: Los ticks de un StopWatch no son iguales a los ticks de un DateTime. En DateTime, cada tick representa un intervalo de 100 nanosegundos. En StopWatch, un tick representa un intervalo de tiempo equivalente a 1 segundo dividido entre la propiedad Frequency del StopWatch.
• IsRunning - determina si el timer está activo y contando Ticks.

Las propiedades IsHighResolution y Frequency no son propias de una instancia StopWatch, sino de la clase StopWatch.

IsHighResolution indica si el timer utilizado está basado en un contador de performance de alta resolución. Esto depende del procesador/arquitectura de la computadora en la que está corriendo el código

Frequency representa el numero de StopWatch ticks por segundo.

Ahora, un poco de código de ejemplo:

Console.WriteLine(string.Format("IsHighResolution: {0}", Stopwatch.IsHighResolution ? "Yes" : "No"));
Console.WriteLine(string.Format("Frequency: {0}", Stopwatch.Frequency));
Console.WriteLine("----------------------");

var dos = "2";
var suma = 0;

//Medir int.Parse
var timer = Stopwatch.StartNew();

for (var i = 1; i <= 1000; i++)
{
suma += int.Parse(dos) * i;
}

timer.Stop();
Console.WriteLine(string.Format("Suma: {0}", suma));
Console.WriteLine(string.Format("Elapsed para int.Parse: {0}", timer.Elapsed));
Console.WriteLine(string.Format("ElapsedMilliseconds para int.Parse: {0}", timer.ElapsedMilliseconds));
Console.WriteLine(string.Format("ElapsedTicks para int.Parse: {0}", timer.ElapsedTicks));
Console.WriteLine("----------------------");

suma = 0;

//Medir Convert.ToInt32()
timer = Stopwatch.StartNew();

for (var i = 1; i <= 1000; i++)
{
suma += Convert.ToInt32(dos) * i;
}

timer.Stop();
Console.WriteLine(string.Format("Suma: {0}", suma));
Console.WriteLine(string.Format("Elapsed para Convert.ToInt32: {0}", timer.Elapsed));
Console.WriteLine(string.Format("ElapsedMilliseconds para Convert.ToInt32: {0}", timer.ElapsedMilliseconds));
Console.WriteLine(string.Format("ElapsedTicks para Convert.ToInt32: {0}", timer.ElapsedTicks));

da el siguiente resultado:

Midiendo intervalos de tiempo con la clase StopWatch

Como se puede apreciar, int.Parse es ligeramente más rapido que Convert.ToInt32().

De manera simplemente informativa…hay otra manera de medir intervalos de tiempo que mucha gente usa, y NO es correcto ni recomendable. Lo hacen asignando el valor de DateTime.Now a una variable de tipo DateTime y luego lo resta al valor de DateTime.Now en el momento que quieren dejar de medir.

Hay todavía otra manera similar al uso de DateTimes, que es usando la propiedad Environment.TickCount.Esto es incorrecto por tres razones:

1. Si existe una clase especializada para hacer esto en el framework, digase StopWatch, hay que usarla.
2. Environment.TickCount es signed (puede representar valores negativos también) lo cual implica que después de 25 dias, se va a entrar al rango negativo y se tendría que eliminar el bit del símbolo para poder hacer calculos correctos. Después de 50 dias, se llenarían todos los bits de la variable y la cuenta se reiniciaría. Ver discusión en StackOverflow.com donde se menciona esto.
3. En palabras del mismo Scott Hanselman, y mencionado en el mismo link de la razon #2: As an unrelated aside, if you DO use DateTime for Date-related math calculations, always use DateTime.UtcNow as DateTime.Now is susceptible to Daylight Savings Time…your calculations could be off by a hour, or worse, negative numbers.

Es decir, es muy facil que a la gente se le olvide que si va a cronometrar de esta manera, usar DateTimes para medir intervalos puede ser susceptible a los conocidos “horarios de verano”, que desfazan por temporadas el reloj por +- 1 hora. Cualquiera de las dos alternativas a StopWatch (DateTime o Environment.Ticks) es relativamente riesgosa para ser útil.

Links de Referencia:

Clase StopWatch @ MSDN

Decidí escribir este post para recomendar estos tres libros, que creo que son los primeros que leí sobre .NET y que considero me dieron ventaja sobre otros candidatos al presentarme a alguna entrevista de trabajo. Estos libros son relativamente baratos y definitivamente pueden cambiar tu carrera. Si apenas vas empezando a aprender .NET o si simplemente quieres volverte un mejor programador, te recomiendo estos libros. Puede que sea una inversion al principio, pero los reviews de estos libros hablan por sí solos, y creo que el costo de estos se regresa inmediatamente al conseguir un trabajo gracias a lo aprendido por ellos.

Sams Teach Yourself ASP.NET 3.5 in 24 Hours

El primer libro se llama Sams Teach Yourself ASP.NET 3.5 in 24 Hours. Lo que me gustó es que como el titulo del libro lo indica, dividen el contenido en lecciones cortas pero completas que puedes aprender en un dia.  Trata principalmente los conceptos básicos de .NET y ASP.NET. El autor es Scott Mitchell, tambien relacionado con el sitio 4GuysFromRolla.com que fue de los primeros en proporcionar articulos muy completos sobre .NET. El libro cuesta $23 USD en Amazon.

ASP.NET 2.0 Website Programming: Problem - Design - Solution (Programmer to Programmer)

El segundo libro es ASP.NET 2.0 Website Programming: Problem – Design – Solution (Programmer to Programmer). Este libro enseña a diseñar sites de ASP.NET de principio a fin, desde la arquitectura general hasta las features más especificas de interfaz de usuario, y explica cada decision que se toma. Se tratan y explicas temas como el Provider Model, ASP.NET Membership, ASP.NET Health Monitoring, MasterPages,  Webparts, databound controls, etc. El proyecto/sitio que se desarrolla con las lecciones de este libro se llama The BeerHouse, una combinacion de CMS (Content Management System)  e E-Comerce, y es una solución tan bien diseñada que posteriormente se convirtió en un Starter Kit de ASP.NET, promocionado en el mismo site de ASP.NET de Microsoft. Muchos desarrolladores junior simplemente adoptan el estilo de desarrollo de la empresa para la cual trabajan, sin cuestionar o aprender la base sobre el por qué se hacen las cosas de esa manera, y este libro explica la razon de decisiones sobre aspectos como arquitectura de la aplicación, clases base, estrategias de Caching, etc. Definitivamente lean este libro, escrito excelentemente por Marco Bellinaso. Cuesta $26 dolares en Amazon.

ASP.NET 3.5 Unleashed

ASP.NET 3.5 Unleashed es el último libro, y es como la biblia (1920 páginas) de ASP.NET. Siempre que necesitaba hacer algo muy específico en ASP.NET y no sabía como, en este libro lo encontraba. Este libro cuesta un poco mas, $40 dolares, pero como dije al principio, los reviews hablan por si solos.