Gustavo Azcona

Entity Framework: Code First

2011-07-05T11:53:00.001-03:00

Finalizando la serie de posts sobre los enfoques de Entity Framework, ahora intentaré explicar el enfoque Code First.

Puedes leer mis posts anteriores sobre Database First y Model First.

Este post es más bien conceptual, puede contener algunos detalles prácticos, pero no pretende mostrar ejemplos ni guías paso a paso. En futuros post intentaré dar ejemplos prácticos sobre cada uno de estos enfoques.

Code First

Este enfoque está disponible a partir de la versión ADO.NET Entity Framework 4.1 y nos permite crear un modelo de clases POCO (Plain Old CLR Object) a partir del cual podemos generar una base de datos y/o mapear esas clases a una base de datos existente.

Aquí no existe un archivo edmx con las definiciones XML del modelo conceptual, el modelo de datos y el mapeo entre ambos.

El modelo conceptual está definido por el conjunto de clases que hemos creado para representar a las entidades de nuestro modelo de dominio. La idea es que nuestras clases POCO sean mapeadas directamente a la base de datos.

La ventaja de usar clases POCO es que el modelo de clases es más limpio y las clases no tienen dependencia con EntityFramework (como sucede cuando las entidades heredan de EntityObject, implementan ciertas interfaces y contienen atributos).

¿Cómo se mapean las clases POCO a la base de datos?

De forma predeterminada, se utiliza un mapeo por convención en lugar de configuración. Es decir, si no especificamos el mapeo, se utilizan los nombres de las clases y sus propiedades para generar los nombres de las tablas y sus campos.

Este mapeo por convención puede ser suficiente en nuevos proyectos, donde estamos definiendo y diseñando el modelo conceptual y la base de datos desde cero.

¿Qué pasa si ya tengo una base de datos heredada?

Si el esquema de la base de datos heredada coincide con el modelo conceptual, entonces el mapeo por convención seguirá siendo suficiente y aplicable y todos felices! (Probabilidad: 0.0000001%)

La experiencia indica que si ya tenemos una base de datos heredada, es altamente probable que haya diferencias con el modelo conceptual utilizado en la aplicación. Entonces:

¿Qué hacemos cuando el esquema de base de datos es diferente al modelo conceptual?
¿Qué tal si quiero especificar restricciones, tipos de datos o validaciones a los campos?

Bien, podemos resolver estas cuestiones y otras tantas a través de:

Data Annotations
Mapping Fluent API

Data Annotations

Estas clases están disponibles en el namespace System.ComponentModel.DataAnnotations y permiten especificar restricciones o validaciones, especificar nombres de tablas o campos, etc.

Hay dos artículos interesantes sobre Data Annotations que recomiendo (en inglés):

Mapping Fluent API

La segunda alternativa que Code First ofrece para definir el mapeo entre el modelo conceptual y la base de datos es mediante Fluent API. Esta API permite especificar la configuración de mapeo y otras configuraciones mediante código.

Los siguientes enlaces contienen un artículo interesante con ejemplos sobre Code First Fluent API y un video paso a paso:

Fluent API Samples
Code First: Mapping Fluent API (Video)

¿Y el contexto de datos de Code First?

De forma predeterminada, con el enfoque Database First y Model First disponemos de una clase ObjectContext del cual hereda el contexto de datos de nuestra aplicación.

Con el enfoque Code First tenemos un nuevo contexto llamado DbContext del cual debe heredar el contexto de datos de nuestra aplicación.

En el contexto de datos, básicamente estamos definiendo cuáles son los conjuntos de entidades que serán mapeados a la base de datos.

Adicionalmente, podemos usar inicializadores de bases de datos, especificar configuraciones de mapeo o interceptar las operaciones de SaveChanges (entre otras).

DbContext no es más que una versión simplificada de ObjectContext, y también puede ser usando con los enfoques Database First y Model First.

¿Cómo o cuando se genera la base de datos?

Cuando se crea una instancia de DbContext, de forma predeterminada, se utiliza una estrategia de inicialización que crea a base de datos si no existe, opcionalmente se puede agregar código para insertar registros después de la creación.

Estas operaciones de inicialización pueden ser implementadas usando el método Database.SetInitializer. Éste método toma como parámetro una estrategia de inicialización de base de datos.

Entity Framework Code First incluye 3 inicializadores:

CreateDatabaseIfNotExist
DropCreateDatabaseAlways
DropCreateDatabaseIfModelChanges

Podemos utilizar estos inicializadores de base de datos, cuando la aplicación se inicia. Por ejemplo, en una aplicación web podríamos usarlo en el evento Application_Start del archivo global.asax, en una aplicación de consola podríamos incluirlo en el método Main del programa principal.

Adicionalmente, podemos crear una clase que hereda de alguno de estos inicializadores y sobreescribir el método Seed para insertar registros después que la base de datos es creada.

Luego, usamos esta clase al iniciar la aplicación:

¿Cómo sería la inicialización de base de datos en un entorno de producción?

Bueno, es claro que en el entorno de desarrollo o pruebas, la inicialización de base de datos puede ser muy útil. Pero en un entorno de producción podría ser un problema.

Simplemente podemos “apagar” la inicialización de base de datos, pasando null como parámetro del método SetInitializer:

Conclusión

Code First es el nuevo enfoque soportado por Entity Framework. Permite mapear nuestras clases POCO directamente a la base de datos.
De forma predeterminada, el mapeo es por convención en lugar de configuración.
Configuración adicional de mapeo puede especificarse mediante Data Annotations o Fluent API.
DbContext API nos permite realizar las operaciones de acceso a datos.

Espero que esta serie de posts haya aclarado un poco más sobre las alternativas de trabajo con Entity Framework.

Dedicaré nuevos posts con ejemplos más prácticos de cada uno de estos enfoques, ventajas, desventajas, limitaciones, etc.

Saludos
~Gus

Entity Framework: Model First

2011-07-01T19:56:00.001-03:00

Continuando con la serie de posts sobre los enfoques de Entity Framework, ahora intentaré explicar el enfoque Model First.

Puedes leer sobre el enfoque Database First en mi post anterior.

Model First

La idea aquí es crear primero el modelo conceptual y a partir de este generar la base de datos.

Usando Visual Studio podemos arrancar creando un archivo .edmx vacío y utilizamos el diseñador visual para crear nuestras entidades con sus propiedades y relaciones con otras entidades.

Cuando tenemos nuestro modelo conceptual completo, podemos generar los scripts de SQL para crear el esquema de base de datos.

¿Qué pasa si la base de datos cambia?

En realidad, la base de datos debe cambiar como consecuencia de un cambio en el modelo conceptual.

Ok ¿Qué pasa si el modelo conceptual cambia?

Habrá que actualizar el modelo conceptual de EntityFramework y generar los scripts SQL de creación de la base de datos.

Desafortunadamente, los scripts SQL generados a partir del modelo conceptual son solo scripts de creación. Es decir, no son scripts de cambios o actualización de nuestro esquema de base de datos. En consecuencia, deberíamos borrar la base de datos y volver a crearla. Obviamente, esto no será factible en un entorno de producción y deberemos elegir otras alternativas. Por ejemplo:

Actualizar el esquema de datos a través de scripts escritos a manos o generados mediante una herramienta de comparación de esquema de datos. También podríamos alterar el esquema usando el Administrador de base de datos
Luego deberíamos, actualizar el modelo conceptual de Entity Framework (edmx) y asegurarnos que el mapeo hacia la base de datos es correcto.
Finalmente, actualizar el código existente en la aplicación.

Ojalá que en un futuro, el equipo de EF pueda incorporar un comparador de esquemas y generar scripts de actualización.

Ya tengo mi modelo conceptual creado, como sigo?

Bueno, a partir de ahora no difiere del enfoque Database First. Podemos escribir querys contra el modelo conceptual y realizar las operaciones de persistencia necesarias.

¿Las clases de entidades generadas con Model First son POCO?

De forma predeterminada NO. Las clases contienen metadata y heredan de clases dependientes de EntityFramework. Al igual que con Database First, disponemos de una clase que hereda de ObjectContext que nos permite interactuar con el modelo.

Sin embargo, es posible tener clases POCO agregando un ítem de generación de código llamado: ADO.NET POCO Entity Generator.

Esto elimina todo el código generado en el archivo .edmx.designer.cs y crea clases POCO basadas en plantillas T4.

Otra alternativa para generar clases POCO es eliminar la herramienta de generación de código EntityModelCodeGenerator asociada al archivo .edmx y generar las clases a mano.

Para finalizar este post, es interesante saber que estas técnicas para generar clases POCO, también son aplicables al enfoque Database First.

Conclusión

El enfoque Model First nos permite crear primero un modelo conceptual y generar luego el esquema de base de datos.
Al igual que Database First se basa en un archivo edmx para almacenar las definiciones XML del modelo conceptual, modelo de datos y mapeo entre ambos.
Las clases generadas automáticamente no son POCO, pero podemos generar clases POCO usando otras herramientas de generación de código.

El próximo post estará dedicado al enfoque más reciente soportado por Entity Framework: Code First.

Espero que sirva.
~Gus

Entity Framework: Database First

2011-06-30T11:21:00.001-03:00

En esta serie de post intentaré resumir los enfoques que hoy permite Entity Framework para crear nuestro modelo conceptual y resolver nuestras necesidades de persistencia.

Introducción

Actualmente con Entity Framework podemos elegir entre 3 enfoques diferentes para crear el modelo conceptual:

Database First: El modelo conceptual se crea a partir de una base de datos existente.
Model First: se crea el modelo conceptual y se genera la base de datos.
Code First: nuevo a partir de EF 4.1. Un enfoque simplificado que permite mapear nuestras clases POCO a la base de datos usando convención, Data Annotations o Fluent API.

Este post estará dedicado al primer enfoque: Database First.

Database First

Este enfoque permite inferir un modelo de clases a partir del esquema de una base de datos existente.

Usando Visual Studio, podemos agregar un ítem de proyecto llamado Entity Data Model e iniciar un asistente para conectarnos a una base de datos, seleccionar los objetos que queremos incluir en el modelo (tablas, vistas, stored procedures) y generar un archivo .edmx que contiene una representación XML de:

El modelo conceptual (CSDL – Conceptual Schema Definition Language)
el modelo de datos (SSDL – Store Schema Definition Language)
y el mapeo entre ambos modelos (MSL – Mapping Specification Language)

El siguiente gráfico muestra un ejemplo del contenido XML de un archivo .edmx:

Es importante entender que el modelo conceptual (CSDL) no debe ser necesariamente igual al modelo de datos (SSDL), y por ello existe el modelo de mapeo (MSL).

A partir de ese archivo .edmx, se genera automáticamente (usando plantillas T4) un archivo .edmx.designer.cs (.vb en el caso de VB.NET) que contiene las clases que representan a las entidades del modelo conceptual.

Puede observarse que estas clases heredan de EntityObject y tienen varios atributos y propiedades dependientes de EntityFramework.

Típicamente, se crea una clase (entidad) por cada tabla de la base de datos, incluyendo propiedades que se mapean a campos y las relaciones entre las tablas son representadas mediante propiedades de navegación.

Además de las clases de entidades se genera también una clase que hereda de ObjectContext y representa el contexto de base de datos. A través de esta clase tendremos acceso a las entidades y colecciones del modelo y podremos realizar todas las operaciones de lectura y escritura de datos desde y hacia la base de datos subyacente.

En el siguiente ejemplo, BookstoreEntities es la clase generada por EF que hereda de ObjectContext:

Luego podemos usarla para acceder al modelo:

¿Puedo modificar o extender las clases de entidades generadas por EF?

Las clases generadas en el archivo .designer son re-generadas cada vez que se actualiza el modelo en el archivo .edmx. En consecuencia, no podemos modificar o agregar código a esas clases. La buena noticia es que son clases parciales y podemos extenderlas en otro archivo o bien podemos usar herencia.

¿Qué pasa si la base de datos cambia?

Habrá que actualizar el modelo conceptual. Esto puede lograrse fácilmente a través del designer del edmx:

Se inicia el asistente de actualización en el cual podemos agregar nuevas tablas, vistas o stored procedures, refrescar las tablas existentes o eliminar otras.

Una vez finalizado el asistente, el archivo edmx se actualiza y se re-generan las clases de entidades. Luego habrá que actualizar el código que hace referencia a las entidades modificadas (si corresponde).

Conclusión

El enfoque Database First nos permite generar rápidamente nuestro modelo de clases y mantenerlo sincronizado cuando el modelo de datos cambia.
El archivo edmx contiene una definición XML del modelo conceptual (CSDL), el modelo de datos (SSDL) y el mapeo entre ambos.
Las clases generadas heredan de EntityObject y se utiliza una clase que hereda de ObjectContext para administrar el modelo y realizar las operaciones de persistencia.

En los próximos post continuaré con los otros dos enfoques de Entity Framework (Model First y Code First), y hablaremos sobre las opciones de generación de entidades POCO, etc.

Espero que sirva, saludos.
~Gus

Imperdible el Barcamp NEA 2011!!!

2011-06-07T20:42:00.001-03:00

Ya está confirmada la fecha para el Barcamp NEA 2011. Será el sábado 25 de Junio en las instalaciones de la UTN Resistencia.

Si querés saber de qué se trata todo esto y seguir las novedades ingresá a www.barcampnea.com.ar y registrate!

También podés leer el post de Luis que explica todo lo que necesitás saber para participar, colaborar, difundir y asistir a este importante evento.

Aún faltan muchas cosas para el evento, así que toda colaboración será bienvenida.

Aprovecho en este post para sumarme a la iniciativa de Facundo y agregar un par de diseños de remeras, uno con el diseño clásico y otro más… nosé…

(Clic para agrandar)

Bueno, quizás estas remeras puedan estar disponibles ese día.

Seguí todas las novedades del evento en Twitter @barcampnea o Facebook.

Sigan difundiendo, nos veremos allá.
~Gus

Tutorial de MVC3

2011-03-25T20:13:00.001-03:00

Como sabrán hace poco tiempo fue liberada la versión 3 de ASP MVC, y ya se pueden encontrar muchos recursos, tutoriales, videos, etc. acerca de las bondades de MVC3. Un tutorial muy recomendado es el de Scott Hanselman: Getting started with MVC3.

Si bien este tutorial se encuentra online y disponible para toda la comunidad he decidido compilar el tutorial completo en un documento PDF imprimible y publicarlo para su descarga:

Pueden descargar este tutorial desde: http://www.avanic.com.ar/downloads/docs/getting_started_with_mvc3_cs.pdf

Espero lo disfruten!
Gus

Twitter is over capacity…again!

2010-11-12T13:06:00.001-03:00

Hoy Viernes 12 de Noviembre de 2010 a las 12:59hs, Twitter está caído. Es la segunda vez que lo veo personalmente. Como esto no es tan frecuente, uno hasta lo mira con aprecio a la pantalla.

Hubiera pensado que a estas alturas ya estaban montados sobre alguna plataforma más escalable del estilo PAAS o IAAS, pero parece que no.

¿Alguien sabe de la infraestructura actual de Twitter?

Nos seguimos, Gus

IsNullOrWhiteSpace, that’s the question!

2010-11-08T14:19:00.001-03:00

Seguramente muchos ya lo han observado en C# 4.0. Existe una nueva función aplicable al tipo String: IsNullOrWhiteSpace()

A la vieja y conocida función IsNullOrEmpty() le faltaba chequear los espacios en blancos o otros caracteres no visibles.

Esta nueva función agrega justamente eso. Es decir, no solo verifica lo que indica su nombre, sino también cadenas vacías y otros caracteres no visibles que son irrelevantes en muchos procesos.

Si antes, para considerar los espacios en blanco, teníamos que escribir lo siguiente:

if (string.IsNullOrEmpty(value) || value.Trim() == string.Empty)

ahora es suficiente y más eficiente escribir:

if (string.IsNullOrWhiteSpace(value))

Hace algún tiempo había escrito un extension method que hacía más o menos esto. Pero ahora esta nueva función integrada, es bienvenida y tendré que jubilar mi extension method (o usar la nueva función internamente).

Debo reconocer que al principio me guié solo por el nombre y pensé que no consideraba las cadenas vacías. Quizás esperaba un nombre como:

IsNullOrEmptyOrWhiteSpaceOrAnotherInvisibleChar()

Pero creo que es mejor el nombre actual. A propósito, esto me hace recordar un viejo método disponible desde las primeras versiones del framework:

FormsAuthentication.HashPasswordForStoreInConfigFile()

Lo he usado muchas veces, pero nunca para guardarlo en un archivo de configuración ;-)

Me pregunto: que habrán estado pensando cuando bautizaron a este método?

Espero que sirva.
Gus

Cuidado! Un copo de nieve

2010-10-21T14:36:00.001-03:00

Así como un simple copo de nieve puede convertirse en una bola de nieve incontrolable, a menudo en los sistemas ocurren situaciones similares.

Algo aparentemente tan inofensivo como no cambiar a tiempo el nombre de una tabla/campo de la base de datos o no renombrar una clase o método de la aplicación para que sea más representativo y coherente, puede originar una serie de pequeños inconvenientes y confusiones hasta convertirse en poco tiempo en un problema grave de mantenimiento.

Muchas veces me he encontrado con pequeñas y medianas empresas y organismos públicos que vienen trabajando con una o más soluciones de software desde hace varios años y han llegado a un punto donde el mantenimiento se ha vuelto tan costoso que dan ganas de tirar todo y empezar de nuevo, lo cual generalmente es inaceptable (aunque muchas veces no quedan muchas alternativas).

En estos sistemas, tareas habituales como solucionar un bug, agregar una nueva feature o una simple mejora pueden volverse tan complejas que muchas veces se prefiere no hacerlas o (lo que es peor) tratar de resolverlas con alguna artimaña rebuscada, con algún truco o parche. Lo que redunda una vez más en una mayor complejidad aumentando los costos de mantenimiento del sistema.

Todo es difícil

En estos sistemas todo se ha vuelto difícil.

La estimación de tareas es difícil. Una tarea que debería ser simple y fácil, se convierte en compleja y difícil y lleva mucho más tiempo del estimado.

No hay tiempo para análisis. Se necesita tiempo para analizar el impacto de agregar o cambiar cierta funcionalidad, pero no hay mucho tiempo porque estamos atrasados. Entonces, programemos y listo.

La programación diaria es frustrante. Lidiar todos los días con código difícil de leer, seguir y depurar se convierte en una tarea frustrante.

No hay tiempo para testing. Apenas alcanza el tiempo para desarrollar. Con suerte, el desarrollador alcanza a realizar un testeo superficial, una prueba de humo (Smoke Test) y el producto está listo para producción (Menos mal que no fabricamos autos o aviones).

La reutilización de componentes es un chiste. La complejidad de todo el sistema hace muy difícil crear funciones o componentes reutilizables. Recordemos que tampoco hay mucho tiempo para analizar. Como resultado se crean piezas de software muy similares una y otra vez, extendiendo los tiempos de desarrollo y aumentando aún más la complejidad.

La incorporación de nuevos desarrolladores es costosa. La productividad de los nuevos desarrolladores es muy reducida durante un largo tiempo, pues necesitan mucho más tiempo para entender el código pre-existente y poder hacer algo útil. Un desarrollador Senior se convierte en Junior. Y un desarrollador Junior cambia su color de pelo y religión.

Un salvador por aquí

En medio de todo el caos, aparece el desarrollador imprescindible. El más experimentado de los desarrolladores suele convertirse en el salvador de la empresa o del producto. Es el único capaz de entender la solución actual. Él sabe que se puede “tocar” y que no, cuándo tocar y cuando no. Él entiende el porqué de las cosas (no siempre). Sin saberlo, esto le genera una alta presión y exigencia, que se transforma en Stress y cuando Él se enferma, la empresa se “enferma”. Si Él se va de vacaciones, la empresa se “sufre”. Y si Él renuncia, la empresa empieza a “agonizar”. Esta situación es muy perjudicial para una empresa.

¿Cómo se llega a esta situación?

Como lo decía Pablo en la TV: “Una seguidilla de hechos bochornosos”. Generalmente, el problema principal suele ser una carencia total de arquitectura empresarial. Por diferentes motivos se ha subestimado el valor de construir sistemas basados en una arquitectura sólida. A esto se le suma una serie interminable de vicios: desde el simple desconocimiento de mejores prácticas de programación, al código heredado de diferentes programadores o equipos de programación, y también se puede sumar tecnologías y lenguajes de programación obsoletos.

Incluso una arquitectura sobredimensionada o exceso de patrones de arquitectura (patronitis aguda) pueden terminar con una solución inmanejable. Aunque esta última “enfermedad” no es muy común, lo más habitual es encontrar “antipatronitis crónica”.

¿Qué se puede hacer?

Cuando se llega a esta situación, el costo de intentar arreglar la solución actual puede ser más costosa que empezar de nuevo. Y cuando la tecnología en la cual está basada el sistema ha quedado obsoleta, ya no tiene mucho sentido arreglarlo.

Asumiendo que la tecnología del sistema no es obsoleta, hay que analizar cada caso en forma particular para determinar si todavía existen chances de cambiar la situación actual (cuando no se trata de una situación irreversible).

Alguien podrá decir: “Los sistemas siempre se pueden corregir”. Si, es verdad, el punto es que en ciertas situaciones el costo de “corregir” puede superar ampliamente el valor del sistema. En estos casos se opta por seguir lidiando con los problemas o empezar de nuevo.

¿Se puede evitar esta situación?

Absolutamente. Solo es cuestión de tener algunas cosas básicas:

Un equipo de trabajo
Una metodología de trabajo
Una arquitectura de software clara y consistente.
Un diseño de base de datos coherente
Mejores prácticas de desarrollo

Pero por sobre todas las cosas hay una que quizás es la más importante: Ganas de mejorar desde el primer día. Esto no incluye solo al equipo de sistemas, sino a toda la empresa.

Saludos, Gus

Todo el problema no está en la programación

2010-10-21T13:00:00.001-03:00

Trabajando en muchos proyectos para organismos privados y públicos he visto una y otra vez cómo los sistemas llegan a un punto extremo donde los problemas abundan y las soluciones escasean.

Desafortunadamente, muchos piensan que el problema de los sistemas inestables y costosos de mantener es solo un tema de programación.

La realidad es que el problema casi siempre viene originado por una mala arquitectura, malas prácticas de programación y malos diseños de bases de datos.

Enfocándome en el diseño de bases de datos, un mal diseño complejiza enormemente todo el sistema. No soy experto en bases de datos, pero como desarrollador de sistemas empresariales, el diseño de bases de datos relacionales debe ser un conocimiento básico y fundamental.

Me sorprende encontrar continuamente bases de datos con graves problemas de normalización, graves problemas de inconsistencia de datos, nombres de tablas y columnas incomprensibles o totalmente confusas, etc. Ni hablar del mal uso de los tipos de datos o la ausencia de los índices mínimos para acelerar las principales búsquedas. Posiblemente tampoco exista un plan de backup y mucho menos un plan de restauración testeado. ¿Y la seguridad? Nosé, hay un guardia en la entrada del edificio.

Una situación común es que se crea una tabla o campo con cierto nombre, luego se utiliza en diferentes partes del código. Pasa el tiempo y se le agregan nuevos campos para cubrir nuevos requerimientos. Tiempo después, el equipo se da cuenta que el nombre ya no es representativo. La tabla que se llamaba Ventas, ahora también almacena las Compras, y se prevé que posiblemente también almacene otros comprobantes como Remitos, Notas de crédito, etc.

Un nombre más representativo debería ser Comprobantes, incluyendo un campo discriminador que determine el Tipo de comprobante. Pero el equipo se resiste a cambiar de nombre o crear una nueva tabla, argumentando que también debería actualizar el código de la aplicación, las vistas y los procedimientos almacenados dependientes, y eso es una tarea muy compleja.

Es cierto, es una tarea compleja. Es un cambio que puede “romper” muchas cosas. Pero es un cambio importante para mantener la salud del sistema. Si no lo hacemos, estamos ampliando los problemas futuros de mantenimiento. Empezamos a complicar las cosas. Creamos la primer bola de nieve que irá creciendo.

Alguien preguntará:

“¿Qué hago con los sistemas externos que dependen de esa base de datos?”

En primer lugar no debería tener sistemas externos que dependen directamente del esquema de la base de datos. ¿Donde quedaron los web services y la interoperabilidad? Si este es el caso, quizás las vistas o sinónimos de bases de datos puedan ayudar a disminuir el alto acoplamiento.

Conclusión:

Se necesita coraje y una visión de sistema saludable a largo plazo para saber que ciertos cambios son posibles y necesarios en el momento oportuno y si no se atienden, se convierten en una enfermedad que nosotros mismos creamos.

También hay que saber que existe mucha bibliografía, documentación, blogs y varias herramientas para refactoring de bases de datos. Es cuestión de conocerlas y saber usarlas cuando se necesitan.

Incluyo aquí algunos links interesantes sobre refactoring y deployment de bases de datos:

The Process of Database Refactoring: Strategies for Improving Database Quality
http://www.agiledata.org/essays/databaseRefactoring.html
Refactoring Databases: Evolutionary Database Design
http://www.ambysoft.com/books/refactoringDatabases.html
First Experience with Visual Studio 2008 Database Edition
http://peterkellner.net/2009/01/17/visual-studio-database-edition-review-sqlserver2008/

En futuros posts intentaré dedicar tiempo a los proyectos de bases de datos para Visual Studio.

Saludos, Gus.

Microsoft Sync Framework: 'min_active_rowversion' no es un nombre de función integrada reconocido

2010-10-18T18:08:00.001-03:00

Me he encontrado con este mensaje de error al intentar sincronizar 2 bases de datos: SQL Server 2005 y SQL Server 2005 Express en una virtual PC con Windows XP.

Al buscar un poco en la red, encuentro que la función min_active_rowversion está disponible con el Service Pack 2 de SQL Server 2005.

Inmediatamente verifico si lo tengo instalado ejecutando el comando:

select @@version

Microsoft SQL Server 2005 - 9.00.1399.06 (Intel X86) Oct 14 2005 00:33:37 Copyright (c) 1988-2005 Microsoft Corporation Standard Edition on Windows NT 5.1 (Build 2600: Service Pack 3)

Una rápida lectura permite ver que tengo instalado el Service Pack 3. Entonces intento ejecutar el comando:

select min_active_rowversion()

y obtengo el mismo mensaje de error inicial.

Vuelvo a buscar en la documentacion oficial, los foros, blogs, etc. y encuentro una y otra vez que tal función está disponible con el SP2 de SQL Server 2005.

Empiezo a pensar que el SP3 que tengo instalado no incluye al SP2, lo cual me parece raro porque el SP3 es generalmente acumulativo. Empiezo a generar diferentes especulaciones y dudas, sigo buscando en la red, hasta que se me ocurre volver a leer el mensaje de select @@version:

Microsoft SQL Server 2005 - 9.00.1399.06 (Intel X86) Oct 14 2005 00:33:37 Copyright (c) 1988-2005 Microsoft Corporation Standard Edition on Windows NT 5.1 (Build 2600: Service Pack 3)

Bingo! El service pack 3 que tengo instalado no es de SQL Server sino de Windows XP.

Así que decido descargar e instalar el SP3 de SQLServer 2005 y también el SP3 de SQL Server 2005 Express.

Después de instalar el SP3 (tarda un rato) vuelvo a ejecutar el comando select @@version obtengo el siguiente mensaje:

Microsoft SQL Server 2005 - 9.00.4035.00 (Intel X86) Nov 24 2008 13:01:59 Copyright (c) 1988-2005 Microsoft Corporation Standard Edition on Windows NT 5.1 (Build 2600: Service Pack 3)

Ahora veo que tengo una versión mayor y el comando select min_active_rowversion() ya no muestra un error.

Finalmente, pruebo mi aplicación de sincronización y todo funciona correctamente. Los registros de base de datos se sincronizan sin problemas.

Conclusión:

Yo debo leer mas detenidamente los mensajes. Pero el equipo de SQL Server podría reconocer que es un poco confuso agregar el service pack instalado de Windows al consultar la versión de SQL Server.

Espero que sirva.
~Gus

Próximamente: IIS Express

2010-10-18T14:14:00.001-03:00

Nuevamente Scott Guthrie nos comenta en su blog sobre esta novedad interesante para los desarrolladores de ASP.NET que proximamente estará disponible en forma gratuita.

Pueden ver el post original o su traducción al español por Juan María Ramos.

Enjoy it!
~Gus

SQL Server CE embebido en ASP.NET

2010-10-15T12:09:00.001-03:00

Estas últimas semanas estoy bastante atareado aprendiendo y creando soluciones con VSTO (Visual Studio Tools for Office). Ya tengo agendado media docena de posts sobre este tema para compartir.

Pero ahora quiero compartir otra novedad que me parece muy interesante y útil para muchos. Hace pocas semanas Scott Guthrie anunciaba que proximamente estará disponible una beta de SQL Server CE 4 (Compact Edition).

Pueden leer el post original de Scott o la traducción al español del bueno de Julian Ramos.

Actualmente pueden descargar el CTP 1 (Community Technology Preview) de SQL CE 4 desde el siguiente link: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=0d2357ea-324f-46fd-88fc-7364c80e4fdb&displaylang=en

Con SQL CE 4 podremos disponer de un motor de base de datos liviano en nuestros sitios web que no requiere la instalación ni configuración de ningún servidor de base de datos.

Solo hay que copiar los ensamblados de SQL CE 4 en nuestro directorio /bin y ya tenemos un motor de base de datos disponible en nuestra aplicación. Sin permisos especiales, sin cuentas administrativas, sin instalación, sin configuración. SQL CE 4 creará archivos de datos con extensión sdf que podemos alojarlos en nuestra carpeta /App_Data.

Una buena noticia es que este motor de SQL CE 4 será compatible con nuestras tecnologías de Acceso a datos como ADO.NET u ORMs como Entity Framework o NHibernate. Adicionalente, podremos escalar nuestra base de datos a motores más avanzados como SQL Express, SQL Server o SQL Azure simplemente cambiando nuestra cadena de conexión.

Un punto a saber es que esta versión de SQL CE no soportará procedimientos almacenados, un feature bastante común en muchos desarrollos, pero muy prescindible para quienes trabajan con ORMs.

Bueno, espero que sirva.
Saludos, Gus

La familia crece: Nuevo Visual Studio LightSwitch

2010-09-03T21:52:00.001-03:00

Dicen que con esta nueva tool podremos crear rápidamente aplicaciones de negocio de calidad profesional sin tener que escribir mucho código. Podremos crear aplicaciones de escritorio o en la nube en muy poco tiempo. Podemos elegir C# o VB.NET, SQL Server, SQL Azure o SharePoint. También podemos crear aplicaciones SilverLight dentro o fuera del browser y exportar datos a Excel programando casi nada. Y cuando la aplicación crezca podemos personalizarla en Visual Studio Profesional o Standard o el que sea.

Estas cosas ya las escuché muchas veces, pero no dejan de llamar la atención. Hay que probarlo: http://www.microsoft.com/visualstudio/en-us/lightswitch

Mas adelante les cuento mi experiencia.

Nos vemos!
~Gus

¿Cómo manejar el ciclo de vida del DataContext/ObjectContext en ASP.NET?

2009-12-15T01:34:00.001-03:00

Si estás trabajando en ASP.NET y LINQ2SQL o ADO.NET EF, te habrás preguntado cual es la mejor estrategia o solución para manejar el DataContext o el ObjectContext. Intentaré responder esta pregunta planteando varias alternativas que he conocido, pero verás que cada una tiene sus ventajas y desventajas, y la elección dependerá del escenario donde necesites aplicarlo.

Por cuestiones de simplicidad, a continuación hago referencia al ObjectContext de ADO.NET EF, pero la problemática es la misma con el DataContext de LINQ to SQL.

1. Un contexto por Session

A más de uno se le habrá ocurrido implementar alguna especie de Singleton y almacenar el ObjectContext en el objeto Session de ASP.NET.

Ventajas

Existe un único contexto para toda la sesión del usuario
Todas las operaciones se realizan usando ese único contexto por usuario.
No deberían aparecer los problemas de que no se puede actualizar una entidad porque está asociada a otro contexto.

Desventajas

Las opciones como ObjectTrackingEnabled o DeferredLoadingEnabled se aplicarían para todas las operaciones.
El contexto puede crecer mucho y afectar la escalabilidad de la aplicación.

2. Un contexto por Request

La idea aquí es similar a la anterior, pero en lugar de almacenar el contexto en el objeto Session, lo guardamos en la colección HttpContext.Items. Esta colección se crea para cada Request y solo existe durante la ejecución de la solicitud.

Ventajas

El contexto solo vive durante el hilo de ejecución de cada Request.
Las operaciones de diferentes clases de acceso a datos pueden compartir el mismo contexto.
La escalabilidad de la aplicación no debería verse afectada, pues el contexto se destruye al finalizar el Request.

Desventajas

Las opciones como ObjectTrackingEnabled o DeferredLoadingEnabled siguen afectando a todas las operaciones.
Existe una sobrecarga de crear el contexto con cada Request. Aunque esa sobrecarga suele ser despreciable.

3. Un contexto por instancia de acceso a datos

En lugar de guardar el contexto en la sesión o en el Thread del Request, lo creamos al instanciar la clase de acceso a datos. Por ejemplo, en el método constructor de la clase.

Ventajas

El contexto tiene el mismo ciclo de vida que la clase de acceso datos.
Las operaciones de la misma clase de acceso a datos pueden compartir el contexto.
La escalabilidad de la aplicación no debería verse afectada, el contexto se destruye cuando se destruye la clase.

Desventajas

Las opciones como ObjectTrackingEnabled o DeferredLoadingEnabled siguen afectando a todas las operaciones en la misma clase.
Otras clases de acceso a datos no pueden compartir el mismo contexto.
Existe una sobrecarga de crear el contexto con cada instancia. Esta sobrecarga puede afectar la performance si muchas instancias de acceso a datos se crean con cada request.

4. Un contexto por operación de acceso a datos

Esta sería la forma más atómica de manejar el contexto. Cada operación de acceso a datos crea el contexto, lo usa y lo libera.

Ventajas

El contexto tiene un ciclo de vida mínimo.
La escalabilidad de la aplicación no debería verse afectada, el contexto se destruye cuando finaliza el método.
Las opciones como ObjectTrackingEnabled o DeferredLoadingEnabled solo afectan a todas las operaciones encerradas por el método.

Desventajas

Otros métodos o clases de acceso a datos no pueden compartir el mismo contexto.

Estoy seguro que podemos encontrar otras alternativas o variantes. Aunque no he encontrado ninguna 100% beneficiosa.

De todas las variantes enumeradas aquí, en mis proyectos suelo utilizar la variante 2 (Un contexto por request) o la 3 (Un contexto por instancia de acceso a datos). Y hasta el momento no he tenido problemas significativos.

Si tienes una estrategia mejor o más recomendable para manejar el contexto de datos de LINQ2SQL o ADO.NET EF, no dudes en compartirla.

En un futuro post, intentaré poner algunos ejemplos de código sobre cómo gestiono el contexto de datos en mis proyectos.

Espero que sirva.
Saludos, Gus

Mejores enlaces en ASP.NET

2009-09-23T10:18:00.001-03:00

Durante mucho tiempo a la hora de incluir un enlace en mis aplicaciones ASP.NET simplemente utilizaba un control Hyperlink y en su propiedad NavigateUrl escribía la dirección URL. Por ejemplo:

<asp:Hyperlink ID=”ContactLink” runat=”server” NavigateUrl=”~/contact.aspx” Text=”Contacto” />

Este enlace se crea en el navegador como un elemento HTML anchor similar al siguiente:

<a id="ctl00_MainContainer_ContactLink" href="../contact.aspx">Contacto</a>

Este enlace no está tan mal, pero su atributo id es un poco extraño y en este caso particular, como se trata da una URL estática, es innecesario; en consecuencia podríamos evitarlo en pos de lograr un HTML más limpio.

Alguien podría decir: ¿por qué no podemos usar simplemente un elemento HTML anchor en lugar de un control Hyperlink?. Bien, un simple anchor podría estar bien en muchas situaciones:

<a href="/contact.aspx">Contacto</a>

Este enlace funcionaría bien en muchos sitios web, pero trae algunos problemas con los subdominios o subcarpetas. Por ejemplo: si nuestra aplicación ASP.NET está alojada en www.example.com/miapp, el enlace anterior apuntaría incorrectamente a www.example.com/contact.aspx en lugar de www.example.com/miapp/contact.aspx. Es por ello que preferimos usar Hyperlinks y usar el carácter de tilde “~” que nos asegura una URL correcta desde la raíz de nuestra aplicación.

Desafortunadamente no podemos usar la tilde “~” con un simple elemento HTML, pues la tilde se procesa y resuelve en el lado servidor. Un enlace como el siguiente no funcionaría:

<a href="~/contact.aspx">Contacto</a>

Escribiendo enlaces correctos y limpios

Una alternativa para resolver el problema usando el elemento anchor, es usar el método ResolveUrl de la siguiente forma:

<a href=’<%= ResolveUrl(“~/contact.aspx”)’ %>Contacto</a>

Este tipo de enlaces dá como resultado un HTML anchor sin el atributo ID, y funciona correctamente en cualquier sitio con subdominios y es independiente de la estructura de carpetas de nuestro sitio. El enlace siempre será correcto!. En el navegador se vería como:

<a href="../contact.aspx">Contacto</a>

Mejorando la escritura de los enlaces

Durante un buen tiempo empecé a escribir este tipo de enlaces, pero luego no me sentí muy conforme con la forma de hacerlo. No me parecía muy natural. Otras personas que están aprendiendo ASP.NET les suena complicado o confuso.

Entonces encontré otra forma de lograr el mismo resultado (HTML más limpio y claro), pero de una forma más intuitiva y elegante. El truco consiste en agregar el atributo runat=”server” al elemento HTML anchor y entonces podemos usar el caracter de tilde “~” en el href.

<a href="~/contact.aspx" runat=”server”>Contacto</a>

Esto dá como resultado un enlace HTML limpio y correcto:

<a href="../contact.aspx">Contacto</a>

La buena noticia es que esto podemos aplicarlo también con las imágenes e incluso con los elementos <link> que usamos para referenciar archivos CSS o Javascript en el <head> de nuestras páginas.

Espero les sirva!
Saludos, Gus

UPDATE:

Es una costumbre en ASP.NET que al usar controles de servidor proporcionemos un atributo ID al control. Sin embargo, no es obligatorio. Podríamos declarar controles de servidor SIN el atributo ID, como el siguiente:

<asp.HyperLink runat=”server” NavigateUrl=”~/contact.aspx” Text=”Contacto” />

Esto genera en el lado cliente un elemento anchor limpio sin el atributo ID:

<a href="../contact.aspx">Contacto</a>

Microsoft Web Platform Installer

2009-04-30T15:59:00.001-03:00

Desde principios de año ya está disponible la versión 1.0 y desde mediados de Marzo la versión 2.0 beta de esta excelente y práctica plataforma que simplifica la descarga e instalación de todo el software que necesitamos en nuestro entorno de desarrollo, pruebas y producción.

En esta tool podemos encontrar:

	.NET Framework Instala la última versión del .NET Framework. Esto incluye todo lo que necesitas para trabajar con ASP.NET
	IIS y Extensiones Instala la última versión de IIS, incluyendo las últimas extensiones de IIS como el IIS Media Services.
	SQL Server Instala la última versión de SQL Server 2008 Express. Incluye tanto la base de datos como las herramientas.
	Visual Web Developer Instala la última versión del Visual Web Developer Express, nuestra herramienta completa gratuita para desarrollar sitios web.
	Aplicaciones web populares Instala las aplicaciones web gratuitas más populares como DotNetNuke y WordPress, Drupal BlogEngine.NET, etc.
	Extras Incluye la última versión de PHP para Windows!

Pueden descargar la última versión en:
http://www.microsoft.com/web/downloads/platform.aspx

Enjoy it!

Software Libre vs Software Propietario

2009-03-17T10:52:00.001-03:00

No acostumbro a escribir sobre estos temas, mis posts generalmente son más técnicos. Sin embargo, desde hace tiempo que a veces me preguntan y muchas veces participo, voluntaria o involuntariamente, en desgastantes debates sobre el mundo Open Source y el Mundo Propietario, y la mayoría de las veces, estas discusiones, responden más a cuestiones ideológicas o fundamentalistas que objetivas.

La verdad es que me gustaría invertir más tiempo en otros temas, pero quise publicar este post para referenciar mi opinión al respecto en futuras e inevitables discusiones sobre este tema inacabable. Espero así en el futuro, cuando me encuentre en estas discusiones y me pidan opinión, pueda decir simplemente: “leé mi post”. ;-)

Encontrarán que hago muchas referencias y expongo ejemplos de o relacionado a Microsoft y sus tecnologías con las cuales trabajo día a día. Sin embargo, intento ser objetivo y espero ver comentarios objetivos de otras personas que tienen o han tenido experiencias en otras plataformas.

Introducción

Existe una gran confusión y un eterno debate entre la adopción de tecnologías basadas en Software Libre versus Software Propietario. Sin ánimos de iniciar un nuevo debate, la mayoría de las personas y organizaciones siempre están de acuerdo en que lo que se busca son soluciones de calidad al menor costo posible. Siempre se piensa en la relación Costo/Beneficio o Retorno de la Inversión.

Yo comparto esa visión, que contiene un amplio sentido común, y he decido evaluar las alternativas y plantear en forma realista diferentes soluciones en ambos enfoques, incluso creando soluciones combinadas para sacar el mejor provecho de cada una.

En este sentido, un aspecto fundamental a considerar es la realidad actual de las empresas y organizaciones, sus tecnologías disponibles, personal capacitado, cambios de plataformas, aceptación de los usuarios, etc.

Antes de estudiar y evaluar las alternativas sobre cada plataforma, veamos algunos mitos que giran entorno al Software Libre y Software Propietario.

Mito 1: Si es Software Libre, es Gratis

La palabra Libre se refiere a que se le concede a los usuarios 4 libertades básicas:

Libertad de usar el programa con cualquier propósito
Libertad de adaptar el programa a sus necesidades
Libertad de copiar y distribuir
Libertad de mejorar y hacer pública las mejoras a toda la comunidad

Cualquier programa que conceda estas libertades será considerado libre, pero esto no implica que sea gratis. Es evidente que para permitir estas libertades se debe proporcionar el código fuente del programa.

En la actualidad muchas empresas privadas desarrollan programas, herramientas y componentes y entregan el código fuente correspondiente junto a licencias que permiten su modificación y distribución, sin embargo no todas lo ofrecen en forma gratuita, pero siguen siendo libres.

Por otro lado, si un programa se distribuye gratuitamente, no significa que sea libre. Existen muchos programas de distribución gratuita que no incluyen su código fuente. Son gratis!, pero no son libres.

Mito 2: Si es Software Propietario, no es Libre

Cada vez más las empresas líderes de software reconocen los beneficios que el software libre puede aportar a la comunidad de usuarios y desarrolladores.

En consecuencia existen iniciativas de dominio público respaldadas por estas empresas que favorecen el uso de software libre y promueven comunidades de usuarios para el desarrollo e intercambio de programas y código fuente. Por el lado de tecnologías Microsoft son muy reconocidas y valiosas las comunidades de intercambio proyectos de código abierto como CodePlex (www.codeplex.com), SourceForge (www.sourceforge.net) y Code Project (www.codeproject.com).

Siguiendo con el mito 2, hace un tiempo que Sun Microsystems ha adquirido el famoso gestor de base de datos MySQL, y por ello no ha dejado de ser libre.

Por su parte, Microsoft también ha liberado el código fuente de su plataforma de desarrollo más preciada: .NET Framework. Y las bases de esta plataforma y el lenguaje C# se encuentran definidos como estándares internacionales por la ECMA; lo que ha permitido el desarrollo de nuevas iniciativas Open Source como el Proyecto Mono (http://www.mono-project.com) y el Proyecto dotGNU (http://www.dotgnu.org)

Mito 3: Si es Software Propietario, hay que pagar licencias

Hoy en día muchas empresas ofrecen innumerables productos, plataformas y servicios en forma totalmente gratuita. Empresas como Sun, Adobe, HP, Oracle y Microsoft ofrecen desde programas de usuario final hasta completas suites de desarrollo y potentes motores de bases de datos en forma totalmente gratuitas.

Por ejemplo:

Sun Microsystem entrega en forma gratuita su suite de desarrollo Sun Studio 12 (http://developers.sun.com/sunstudio/downloads/) y la base de datos MySql.
Por su parte Microsoft ofrece la suite de desarrollo Visual Studio 2008 Express y SQL Server 2008 Express (http://www.microsoft.com/express/).

Las prestaciones de estas herramientas son totalmente funcionales y permiten el desarrollo de soluciones completas y de calidad profesional, no hay que pagar licencias para usarlas.

Mito 4: Si la licencia de uso es gratis, el costo del sistema es cero

Quizás este sea el mito qué más puede confundir y perjudicar. El costo real de un sistema no está en las licencias de uso, sino en el mantenimiento y soporte necesario durante todo el ciclo de vida.

Cada empresa u organización debe evaluar si dispone y/o puede costear el personal técnico capacitado para dar soporte y mantenimiento a los sistemas antes de implementarlos. También debe evaluar el respaldo tecnológico asociado a la plataforma elegida, la comunidad de usuarios técnicos y no técnicos, etc.

Hace tiempo que las empresas y el mundo han comprendido que nada es realmente gratis, todo tiene un costo asociado. Y en las soluciones informáticas, generalmente el principal costo reside en el soporte y mantenimiento que asegure el funcionamiento de los sistemas en las condiciones apropiadas.

Finalmente, no se encuentra mucho valor al enfocarse solo en el costo de la solución, sino en los beneficios que éste puede brindar. Volvemos al principio: la relación costo/beneficio.

Usar lo mejor de cada mundo

La buena noticia de todo esto es que existe competitividad y un gran abanico de posibilidades para elegir. Además no todo es blanco o negro, existe la interoperabilidad entre plataformas.

Por ejemplo, existen soluciones en ASP.NET usando como bases de datos MySql o PostgreSql. Lo mismo ocurre con Java y las plataformas de Sun; y desde PHP podemos conectarnos a Microsoft SQL Server u Oracle. Y ni hablar si usando un enfoque SOA.

En un proyecto actual en el que estoy trabajando, incluye una solución de escritorio, destinado al sector educativo. Hemos visto que todas las escuelas de la región que intentamos dar cobertura tienen PCs con Windows XP y Office. Analizando este escenario:

¿Porqué querríamos cambiar a Linux? ¿Por las licencias?
Microsoft le ha otorgado licencias a costo casi cero a todas las escuelas.
Y si así no lo fuera, ¿cuál sería el costo de contratar personal capacitado para instalar Linux en todas las escuelas?
¿Cuánto costará y cuánto tiempo llevará capacitar al personal administrativo?
¿Qué costos tendría el cambio radical de sus programas y su forma de trabajo al personal?

Con esto no quiero decir que Linux sea una mala opción. Sino que siempre hay que evaluar el escenario. Quizás aquí podría ajustarse una solución desktop para Windows basada en Java o .NET usando como motor de datos MySql o SQL Server Express.

En definitiva, creo que la clave está en evaluar y saber elegir las soluciones más convenientes y apropiadas para cada escenario. Podemos usar lo mejor de cada mundo y debemos tener siempre presente la relación costo/beneficio y podría destacar entre los beneficios, la proyección y visión hacia futuro.

Bueno, espero haber aportado algo de claridad sobre este tema tan discutido.
Saludos, Gus

ADO.NET Entity Framework: The version of SQL Server in use does not support datatype 'datetime2'

2009-03-08T14:20:00.001-02:00

Trabajando con ADO.NET EF, en mi entorno de desarrollo tengo SQL Server 2008 y en producción está SQL Server 2005. Al publicar mi aplicación, en algunas páginas obtengo el siguiente error:

The version of SQL Server in use does not support datatype 'datetime2'

SQL Server 2008 dispone de un nuevo tipo de datos Datetime2 que agrega soporte mejorado de fechas y horas.

Por ejemplo, Datetime2 soporta fechas y horas desde 0001-01-01 00:00:00 hasta 9999-12-31 23:59:59.9999999 (nanosegundos de precisión), mientras que el conocido Datetime solo acepta rangos desde 1753-01-01 00:00:00 hasta 9999-12-31 23-59:59.999 (solo milisegundos de precisión). Pueden leer más sobre esto en el siguiente enlace (en inglés): DATETIME2 vs DATETIME in SQL Server 2008

Para resolver el problema de incompatibilidad usando ADO.NET Entity Framework hay que abrir el archivo .edmx con el editor de XML y cambiar el valor del atributo ProviderManifestToken a 2005.

<edmx:Runtime>
<edmx:StorageModels>
<Schema Alias="Self" Provider="System.Data.SqlClient" ProviderManifestToken="2005">

Luego guardamos los cambios en el modelo y recompilamos la aplicación. Esto resolverá el error de versiones.

Algo importante a saber es que si posteriormente actualizamos el modelo en nuestro entorno de desarrollo el atributo ProviderManifestToken volverá a establecerse al valor 2008 y deberemos cambiarlo manualmente antes de publicar nuestra aplicación.

Quizás con una tarea postbuild podríamos hacer este cambio automáticamente. Si alguien se anima a crear una tarea como esta será bienvenida.

Espero que sirva.
Saludos, Gus

Paginación y Ordenamiento del lado servidor con GridView y ADO.NET Entity Framework

2009-03-06T14:24:00.001-02:00

Esta vez quiero mostrarles como actualmente estoy implementando paginación y ordenamiento del lado servidor, usando GridView, ObjectDataSource y ADO.NET EF. Aunque de una forma muy similar también es aplicable a LINQ2SQL.

Creando los métodos en la capa de negocio o servicios

El primer paso consiste en crear en nuestra capa de negocios o servicios un par de métodos que luego serán invocados por el control ObjectDataSource.

Básicamente necesito 2 métodos para lograr mi objetivo:

Un método que me devuelva la cantidad total de registros
Y otro método que me devuelva los registros paginados

Para el ejemplo voy a crear en una clase CatalogService, un método FindProducts() y otro método FindProductsCount().

public IList<Product> FindProducts(int? code, string description, int? categoryID, string sortExpression, int startRows, int maxRows)
       {
           using (var db = new StoreEntities())
           {
               var query = from p in db.Products select p;

query = FindProductsFilter(query, code, description, categoryID);
query = FindProductsSort(query, sortExpression);

               return query.Skip(startRows).Take(maxRows).ToList();
           }
       }

Aquí vemos que FindProducts() llamá a 2 métodos FindProductsFilter() y FindProductsSort() que se encargan de aplicar los filtros necesarios y ordenar los registros, y luego usa los métodos Skip y Take para paginar los resultados.

private static IQueryable<Product> FindProductsFilter(IQueryable<Product> query, int? code, string description, int? categoryID)
{
if (code.HasValue)
query = query.Where(p => p.Code== code);

if (!string.IsNullOrEmpty(description))
query = query.Where(p => p.Description== description);

if (categoryID.HasValue)
query = query.Where(p => p.Category.ID== categoryID);

return query;
}

private IQueryable<Product> FindProductsSort(IQueryable<Product> query, string sortExpression)
{
if (string.IsNullOrEmpty(sortExpression))
return query.OrderBy(p => p.Description);

return query.OrderBy(sortExpression);
}

Es importante saber que el método OrderBy() no acepta un parámetro string para realizar el ordenamiento. Sin embargo, aquí estoy usando unas extensiones de LINQ conocidas como Dynamic Query para lograr este objetivo.

Pueden leer un artículo de Scot Guthrie traducido al español sobre Dynamic Query y descargar el código fuente.

Sin Dynamic Query, tendría que parsear el parámetro sortExpression y escribir un switch o multiples ifs para aplicar el OrderBy correspondiente según el campo. En pocas palabras, tendría que escribir muuucho más código, entonces prefiero Dynamic Query.

Y ahora el método FindProductsCount() que no hace otra cosa más que contabilizar el total de productos. Este método lo utiliza el ObjectDataSource y la grilla para poder calcular el total de páginas necesarias, sin tener que traer todos los registros para luego paginarlos.

public int FindProductsCount(int? code, string description, int? categoryID)
{
    using (var db = new StoreEntities())
    {
        var query = from p in db.Products select p;

query = FindProductsFilter(query, code, description, categoryID);

return query.Count();
}
}

Consumiendo los métodos desde la UI

Ahora creo una página aspx con unos campos para filtrar, un botón y una grilla asociada a un ObjectDataSource para los resultados. El formulario se vería mas o menos así:

No deseo explicar cómo enlazar la grilla con un ObjectDataSource, solo bastaría con decir que debemos asociar al método FindProducts() creado anteriormente y asociar los parámetros del método con los controles de la página. Y luego hay que habilitar Paging y Sorting en la grilla.

Las propiedades establecidas para el ObjectDataSource aparecen en negrita:

Las propiedades sortExpression, startRows y maxRows serán pobladas y pasadas al método FindProducts y/o FindProductsCount automáticamente.

La última pieza es escribir código para el botón Buscar:

protected void FindButton_Click(object sender, EventArgs e)
{
if (!Page.IsValid) return;

try
{

    ProductsGridView.DataSourceID = ProductsDataSource.ID;
    ProductsGridView.DataBind();
}
catch (Exception ex)
{
    ShowError(ex.Message);
}

}

Debe observarse que solo en runtime estoy enlazando la grilla con el control ObjectDataSource. Es decir, después de configurar la grilla y el ObjectDataSource, en tiempo de diseño, quito la referencia al ObjectDataSource en la propiedad DataSourceID de la grilla. De esta forma, cuando la página se carga no se hace una búsqueda automática, sino solo cuando se completan los filtros de búsqueda y se presiona el botón Buscar.

Pero esto es una particularidad que quise implementar y no tiene ningún efecto sobre la paginación y ordenamiento, motivo de este post.

Bueno creo que ya está todo, ahora hay que probar.

A mí me funcionó de maravillas ;-).

Mirando con el SQL Profiler veo que solo se consultan 10 registros por página. Las consultas al SQL Server devuelven solo los registros que el usuario quiere ver. Esto permite que nuestras aplicaciones sean mucho más escalables, pues solo traemos los registros necesarios y se minimiza la carga de trabajo en la BD.

Bueno espero que sirva.
Comentarios son bienvenidos!

Saludos, Gus

RUN09

2009-03-06T12:32:00.001-02:00

Este es el nombre que finalmente fue bautizado al antes llamado Buenos Aires Briefing. Hoy Miguel Saez nos avisa que ya está disponible el site del evento en http://www.puertadeenlace.net/run09. Desde este sitio podrán registrarse, ver los oradores y revisar la Agenda del evento, y quizás descubrir algunas perlitas del site.

Es de destacar que el site tiene una UI inspirada en Windows 1.0, pero está desarrollado con las últimas tecnologías de MS. Incluso mike nos comenta en su blog que está disponible un servicio de WCF (http://www.puertadeenlace.net/run09/Models/Service.svc/) que se puede usar para construir otro cliente para el evento en Silverlight, WPF o Gadget de Vista y quizás ganar un poco de publicidad durante el evento.

Bueno, a tomarse un respiro y aprovechar este evento. Seguramente nos encontramos allí.
Saludos, Gus

Buenos Aires Briefing 09 o busquemos un nuevo nombre

2009-02-04T23:58:00.001-02:00

La gente de Microsoft Argentina y Uruguay están trabajando en la organización del próximo evento "Buenos Aires Briefing 09" con fecha 25 de Marzo. Se espera contar con la presencia de más de 1000 profesionales al evento entre desarrolladores y profesionales de IT.

Se invita a toda la comunidad a sumar sus aportes con ideas, sugerencias y comentarios a través del sitio www.puertadeenlace.net: un espacio para compartir con la comunidad de Desarrolladores y Profesionales IT en tecnologías Microsoft. Pronto se estará definiendo la agenda y los oradores.

Desde ahora podemos empezar a colaborar:

Poniendo un nuevo nombre al evento
Definiendo qué temas nos interesa para el evento
Difundiendo el evento en sus blogs, sites, amigos, vecinos, etc.

Bueno, la invitación ya está hecha y seguiremos los avances del evento. Estoy seguro que será uno de los grandes eventos del año.

Saludos, Gus

ADO.NET Entity Framework: ¿Cómo actualizar un objeto desconectado?

2009-01-29T09:42:00.001-02:00

Un escenario común es el siguiente:

"Al enviar un formulario web, creo una entidad Pedido con los datos proporcionados por el usuario y lo entrego a mi capa de negocios o servicios para que se valide y persista en el almacén de datos."

En este escenario la entidad Pedido enviada desde la página web (o enviada desde un Web Service), se encuentra en estado Deattached. Para que podamos persistir sus cambios necesitamos asociarla a un contexto y luego llamar al método SaveChanges().

Si la entidad aún no existe en el almacén de datos, debemos agregarla. Esto es muy simple, usando los métodos AddTo* generados en el modelo:

context.AddToOrders(order);
context.SaveChanges();

En cambio si la entidad ya existe en el almacén de datos, entonces debemos asociarla al contexto y guardar los cambios. Esta tarea parece ser simple y podríamos intentar resolverla de la siguiente manera:

context.AttachTo("Orders", order);
context.SaveChanges();

Sin embargo, esto no funciona, pues el objeto order se asocia exitosamente al contexto pero en el estado Unchanged. Luego el método SaveChanges() no persiste ningún cambio.

La forma de resolver este problema es recuperando la entidad original desde el almacén de datos, aplicar los cambios, y volver a guardarla.

Buscando en la web encontré diferentes enfoques para resolver este problema. Muchos utilizan Reflection para recorrer todas las propiedades y asignar las que han cambiado. La que más me ha interesado la encontré en el blog de Cesar de la Torre.

Se trata de un extension method llamado AttachUpdated() aplicado al ObjectContext. Me he tomado el atrevimiento de renombrar le método AttacheUpdated() por UpdateObject(), pues me pareció más consistente con otros métodos que ya existen en el ObjectContext como AddObject() y DeleteObject(). El código es el siguiente:

public static void UpdateObject(this ObjectContext context, string entitySetName, EntityObject entity)
{
var key = context.CreateEntityKey(entitySetName, entity);

    object originalEntity;
    if (context.TryGetObjectByKey(key, out originalEntity))
    {
        context.ApplyPropertyChanges(entitySetName, entity);
        context.ApplyReferencePropertyChanges(entity, (IEntityWithRelationships)originalEntity);
    }
    else
    {
        throw new ObjectNotFoundException();
    }
}

Este método primero crea la EntityKey asociada al objeto usando el método CreateEntityKey() y luego intenta recuperar el objeto desde el almacén de datos usando el método TryGetObjectByKey(). A continuación aplica los cambios usando el método ApplyPropertyChanges() y luego llama al método ApplyReferencePropertyChanges() que se encarga de aplicar los cambios a las entidades relacionadas. Este último método se trata de otro extension method:

private static void ApplyReferencePropertyChanges(this ObjectContext context, IEntityWithRelationships newEntity, IEntityWithRelationships oldEntity)
{
    foreach (var relatedEnd in oldEntity.RelationshipManager.GetAllRelatedEnds())
    {
        var oldRef = relatedEnd as EntityReference;

        if (oldRef != null)
        {
            var newRef = newEntity.RelationshipManager.GetRelatedEnd(oldRef.RelationshipName, oldRef.TargetRoleName) as EntityReference;
            if (newRef != null) oldRef.EntityKey = newRef.EntityKey;
        }
    }
}

Aquí no solo se resuelve el problema de aplicar los cambios a las propiedades del objeto en cuestión sino también los cambios en sus objetos relacionados.

Luego de crear estos extensions methods, el código final para actualizar una entidad desconectada quedaría como:

context.UpdateObject("Orders", order); //Extension method
context.SaveChanges();

He probado esto y funcionó para mí. Espero que también les sea de utilidad.

Saludos, Gus

ADO.NET Entity Framework: Nuevos proveedores de datos

2009-01-28T10:09:00.001-02:00

En el blog del equipo de ADO.NET Entity Framework se anuncia que están disponibles nuevos proveedores para ADO.NET EF, incluyendo versiones Beta.

Pueden leer más y descargar estos providers desde el siguiente link:
http://msdn.microsoft.com/en-us/data/dd363565.aspx

Saludos, Gus

ADO.NET Entity Framework: ¿Cómo cambiar la ForeignKey de un objeto?

2009-01-28T09:49:00.001-02:00

Tengo un formulario de edición de un Producto, y entre muchos otros datos, se debe seleccionar, por ejemplo, la Categoría desde un DropDownList. Al guardar el producto, se debe establecer el ID de la categoría asociada.

La intuición nos llevaría a escribir el siguiente código:

product.Category.Id = Convert.ToInt32(CategoryDropDownList.SelectedValue);

Desafortunadamente, esto provocará un error, porque la propiedad Category es null, o bien porque no se puede cambiar la propiedad Id.

Para resolver el problema podemos escribir lo siguiente:

var categoryId = Convert.ToInt32(CategoryDropDownList.SelectedValue);
product.CategoryReference.EntityKey = new EntityKey("ContosoEntities.Categories", "Id", categoryId);

En lugar de la propiedad Category estamos usando la propiedad CategoryReference y estamos asignando una nueva EntityKey. Esto permitirá que cuando ejecutemos el método SaveChanges, los cambios de la categoría asociada al producto se persistan en el almacén de datos.

Particularmente esta forma de resolver el problema me parece poco intuitiva y elegante. Algo tan simple como cambiar una clave externa implica escribir todo ese código. Sin embargo, hasta ahora, parece ser la única forma de resolver el problema.

Si nos interesa mejorar un poco nuestro código, y escribir algo más simple, podríamos crear una clase Partial de Product, y agregar una propiedad CategoryId:

public int CategoryId
{
   get
   {
       return Convert.ToInt32(CategoryReference.EntityKey.EntityKeyValues[0].Value);
   }

   set
   {
       var qualifiedEntitySet = "ContosoEntities.Categories";
       CategoryReference.EntityKey = new EntityKey(qualifiedEntitySet, "Id", value);
   }
}

Esta propiedad adicional, permitirá escribir algo como:

product.CategoryId = Convert.ToInt32(CategoryDropDownList.SelectedValue);

Muy similar a los que habíamos intentado al principio!

Antes de terminar, alguien podrá decir:

"Usando LINQ TO SQL, estas propiedades se generan automáticamente cuando se crea el modelo."

Es cierto! Pueden dirigir sus comentarios y sugerencias al Blog del Equipo de ADO.NET Entity Framework, y quizás tengamos suerte para la siguiente versión.

Hasta la próxima! Espero que sirva.
Saludos, Gus

ASP.NET Performance Tip: Eliminar HttpModules innecesarios

2009-01-28T09:04:00.001-02:00

En cada solicitud de ASP.NET se ejecutan una serie de módulos para completar diferentes tareas. Por ejemplo, el módulo SessionStateModule intercepta cada solicitud, recupera la cookie de sesión y carga los datos de sesión en el HttpContext. No siempre son necesarios todos los módulos, por ejemplo, si estás usando FormsAuthentication entonces quizás no necesites los módulos de WindowsAuthentication o PassportAuthenticacion.

De forma predeterminada, el archivo machine.config define los siguientes módulos:

</httpModules>

Los módulos que no utilizamos en nuestra aplicación ASP.NET, podemos removerlos desde el web.config:

Esto reducirá carga de trabajo innecesaria en cada solicitud ASP.NET, y nuestras aplicaciones estarán un poco más optimizadas.

Pueden encontrar este y otros tips de performance en el siguiente enlace:
http://www.codeproject.com/KB/aspnet/10ASPNetPerformance.aspx

En futuros posts, continuaré sumando más tips de performance, como Compresión Http, Optimización del ViewState, Combinación de Scripts y Css, etc. Incluiré código fuente y herramientas para hacer que nuestras aplicaciones ASP.NET se ejecuten cada vez más rápido.

Espero que sirva.
Saludos, Gus

Silverlight y PhotoSynth en la presidencia de Obama

2009-01-26T18:04:00.001-02:00

Como lo dice Scott G. en su blog:

"El día de la toma de posesión de Barack Obama fue un evento histórico. Silverlight se ha usado como la tecnología que ha permitido asistir a tal evento online."

Me resultó interesante el trabajo armado con PhotoSynth que nos permite tener una vista 3D del acto de inauguración a partir de fotos 2D tomadas por miles de personas que asistieron al evento. Pueden apreciarlo en el siguiente enlace:
http://edition.cnn.com/SPECIALS/2009/44.president/inauguration/themoment/

Enjoy It!
Gus

ADO.NET Entity Framework: ¿Cómo incluir los objetos relacionados?

2009-01-26T17:23:00.001-02:00

Una tarea común en el desarrollo con ADO.NET Entity Framework es escribir una consulta que incluya una o más entidades relacionadas. Por ejemplo, quiero obtener todas las fotos de un autor incluyendo los datos del autor:

var photos = from p in db.Photos.Include("Author")
where (p.AuthorId == authorId)
select p;

El método Include especifica que se incluya la entidad Author asociada a cada Photo.

Si además del autor, quisiera incluir otra entidad relacionada a la foto como su Categoría, podría agregar otro include:

var photos = from p in db.Photos.Include("Author").Include("Category")
where (p.AuthorId == authorId)
select p;

En este caso se incluirá también la categoría asociada a cada Photo.

Otro método que también permite cargar entidades relacionadas es el método Load(). Supongamos que deseo obtener los datos de una foto y sus palabras claves asociadas, podría escribir algo como:

var photo = db.Photos.First(p => p.Id == photoId);
photo.Tags.Load();

En otro escenario, podría interesarme verificar primero, antes de ejecutar el método Load():

var photo = service.GetPhoto(id);
if (!photo.Tags.IsLoaded) photo.Tags.Load();

La propiedad IsLoaded permite comprobar si se han cargado o no los objetos relacionados en la colección de Tags.

Para simplificar este trabajo, he creado un extension method EnsureLoad() que aplica a EntityCollection, así el código anterior se reduce a:

var photo = service.GetPhoto(id);
photo.Tags.EnsureLoad();

El código del extension method es el siguiente:

public static void EnsureLoad<T>(this EntityCollection<T> entityCollection)
where T: EntityObject
{
    if (!entityCollection.IsLoaded)
    {
        entityCollection.Load();
    }
}

Bueno, espero que sirva.
Saludos, Gus

Session Timeout vs FormsAuthentication Timeout

2009-01-26T16:12:00.001-02:00

Muchas veces me preguntan: ¿Cómo hago para aumentar el tiempo de sesión en una aplicación ASP.NET, y evitar que los usuarios vuelvan a la página de login luego de cierto período de inactividad?. Que ya han probado seteando el session timeout en el web.config, setarlo por código, etc. y ASP.NET simplemente ignora esos valores.

Se trata de un tema que ya tiene unos años, pero aún es bastante recurrente y muchas veces confuso. Por ello, he decido postear un poco al respecto.

Para comprenderlo mejor hay que considerar al menos 2 timeout independientes:

Session Timeout
Forms Authentication Timeout

Session Timeout define cuanto tiempo debe durar la cookie de sesión en el cliente. Cada vez que el usuario navega en el sitio se guarda una cookie de sesión, para identificar las solicitudes del cliente. Esto es independiente de si el usuario se autenticó o no. El valor predeterminado es de 20 minutos, pero puede modificarse con el elemento system.web/sessionState en el web.config:

<sessionState mode="InProc" timeout="60" />

Forms Authentication Timeout define cuanto tiempo debe durar la cookie de autenticación en el cliente. Expirada la cookie de authenticación el usuario deberá autenticarse nuevamente. El valor predeterminado es de 30 minutos, pero puede modificarse con el elemento system.web/authentication en el web.config:

Siempre complican estas cosas porque uno confunde la sesión con la autenticación. Son dos cosas independientes. Uno puede crear un sitio basado en Forms Authentication sin usar variables de Session, o viceversa, o combinando ambos (lo más común).

Normalmente, no hay problemas con los valores predeterminados de session y authentication, pero en aplicaciones donde el usuario puede pasarse bastante tiempo leyendo o escribiendo hasta finalmente presionar un link o botón, estos valores predeterminados pueden expirar y entonces necesitaremos aumentarlos.

Finalmente, otro timeout que a veces se quiere ajustar es el executionTimeout del elemento HttpRuntine. Este atributo define el tiempo máximo que puede durar la ejecución de una solicitud. El valor predeterminado es 90 segundos, tiempo suficiente para la mayoría de las aplicaciones. Sin embargo, existen escenarios donde se necesita un tiempo mayor, por ejemplo, para subir archivos de gran tamaño. En estos escenarios, seguramente también habrá que aumentar el atributo maxRequestLength. Pueden leer más sobre el tema en Carga de archivos ASP.NET.

Ahora que hay un poco más de luz en el asunto, pueden continuar investigando y profundizar más sobre estos temas.
Espero que sirva.

Saludos, Gus.

Control Extensions

2009-01-20T23:03:00.001-02:00

Continuando con los mini-aportes sobre extensions methods, en esta oportunidad quiero compartir algunos que simplifican la carga de datos en controles de lista como DropDownList, CheckBoxList o RadioButtonList.

El código habitual para llenar una lista desplegable con datos obtenidos desde algún origen de datos es el siguiente:

var countries = GlobalServices.GetCountries();
CountryDropDownList.DataValueField = "Id"; 
CountryDropDownList.DataTextField = "Name"; 
CountryDropDownList.DataSource = countries; 
CountryDropDownList.DataBind();

Habitualmente solemos agregar un item más al principio que diga, por ejemplo: (Seleccione). Entonces, al código anterior podemos agregar:

CountryDropDownList.Items.Insert(0, new ListItem("(Seleccione)", String.Empty));

Si bien esto no es muy complejo, se vuelve tedioso cuando hay que repetirlo para llenar otras listas adicionales. Un simple extension method puede reducir todo esto a solo 1 línea de código:

CountryDropDownList.Fill(countries, "Id", "Name");

Si quisieramos agregar el item adicional de (Seleccione), podríamos usar una sobrecarga de este método:

CountryDropDownList.Fill(countries, "Id", "Name", "(Seleccione)");

El código del extension method Fill() es muy simple:

public static void Fill(this ListControl list, object dataSource, string valueField, string textField) 
{ 
    if (list == null) return; 

    list.DataValueField = valueField; 
    list.DataTextField = textField; 
    list.DataSource = dataSource; 
    list.DataBind(); 
}

Como se puede observar, el extension method se aplica a los controles de tipo ListControl, esto incluye, además del control DropDownList, los controles CheckBoxList, RadioButtonList, BulletedList, y cualquier otro control que herede de ListControl.

Es un pequeño aporte que puede reducir, de una forma sencilla y elegante, una cantidad considerable de código y el consecuente ahorro de tiempo.

Pueden descargar la clase ControlExtensions.cs con estos métodos desde el siguiente link. Más adelante intentaré agregar nuevos métodos aplicables a otros controles.

Espero que sirva.

Saludos, Gus

Propiedades y métodos públicos en la MasterPage

2008-12-15T23:15:00.001-02:00

Este truco ya es un poco viejo, sin embargo, aún puede ser útil para muchos.

En muchas situaciones deseamos exponer propiedades y métodos públicos en la página maestra o página principal para accederlas desde las páginas de contenido. Sin embargo, al hacerlo vemos que no son accesibles. No aparecen en la lista de Intellisense.

Existe una directiva poco conocida llamada MasterType que podemos agregar fácilmente en nuestras páginas de contenido y así poder acceder a las propiedades y métodos públicos definidos en nuestra página maestra.

Una vez definida esta directiva podemos acceder en el código por detrás de nuestras páginas de contenido, a las propiedades y métodos públicos de la MasterPage.

Enjoy it!

¿Cómo recuperar el objeto DataItem del control ListView?

2008-12-15T22:53:00.001-02:00

Cada elemento o fila de los controles de datos como GridView, DataList o Repeater disponen de una propiedad DataItem que permite recuperar el registro de datos enlazado a la lista. Esta propiedad es muy útil para procesar los elementos y controles durante el evento de enlace de datos.

Sin embargo, al trabajar con el control ListView incluído en ASP.NET 3.5 habrán notado que no existe una propiedad similar o equivalente para recuperar los datos del ítem enlazado para procesarlos durante el evento ItemDataBound.

Investigando un poco sobre cómo resolver esta ausencia, encontré una forma poco intuitiva:

El truco es que el elemento e.Item de tipo ListViewItem se puede castear a ListViewDataItem y entonces ahí podemos acceder a la propiedad DataItem para luego castearlo nuevamente a la clase de datos que estamos enlazando.

Este doble casting no me agrada mucho, pero es la única forma que encontré para recuperar el elemento de datos que está siendo enlazado al control ListView.

Bueno, espero que sirva y ahorre algunos dolores de cabeza.

Saludos, Gus

String Extensions

2008-11-30T19:58:00.001-02:00

Como sabemos, los Extensions Methods son una de las nuevas características de C# 3.0. Podemos verlos como métodos estáticos que permiten agregar nuevas funcionalidades a clases ya existentes. No es mi intención explicar cómo crear Extensions Methods (pueden aprender más aquí y aquí), sino compartir varios extensions methods que uso habitualmente en mis proyectos de desarrollo.

Convirtiendo Strings

Convertir cadenas de texto a un número o fecha es una necesidad habitual en todos los proyectos. El código típico es el siguiente:

int number = int.Parse(NumberTextBox.Text);
DateTime date = DateTime.Parse(DateTextBox.Text);

El mismo resultado podríamos obtener usando la clase Convert:

int number = Convert.ToInt32(NumberTextBox.Text);
DateTime date = Convert.ToDateTime(DateTextBox.Text);

En este caso tenemos la ventaja de que si el argumento es null, el valor devuelto es cero. Esto puede comprobarse con Reflector.

Ninguno de los métodos anteriores resuelve el problema de conversión de datos cuando el usuario ingresa letras donde se esperaba números o fechas con formatos no válidos.

Para evitar esta situación podemos usar validators de ASP.NET, controles de máscara o bien el método TryParse:

int number;
if (int.TryParse(NumberTextBox.Text, out number))
{
//TODO: Do something
}

El único problema con esta solución es que implica escribir mucho más código, generando rutinas más extensas y difíciles de leer.

La situación se complica un poco más con los Guid, pues no disponen de un método TryParse, entonces habría que usar Try/Catch, lo que complica aún más el código resultante.

String Extensions

Es aquí donde los Extensions Métodos pueden proporcionar una solución efectiva, elegante e intuitiva. La siguiente figura muestra cómo convertir una cadena a un número usando un extension method:

La implementación del extension method es muy simple:

He creado una clase StringExtensions.cs con varios extensions methods para convertir a byte, short, long, float, double, decimal, boolean, datetime, guid, etc. Incluí también versiones compatibles con tipos nullables. Seguiré agregando nuevos métodos en la medida que encuentre aplicación práctica y aporten simplicidad en el código.

A continuación les dejo el link para descargar la clase StringExtensions.cs. En próximos post, publicaré otros extensions methods aplicables a controles de ASP.NET. Espero que sirva.

Saludos, Gus

Nuevo control de Chart en ASP.NET

2008-11-27T16:48:00.001-02:00

La gente de Microsoft ha liberado un nuevo control para ASP.NET 3.5 SP1 y Windows Forms para resolver nuestras necesidades de charting. Thanks!!!

Pueden leer el artículo de Scott Guthrie (en inglés) dando la noticia o si lo prefieren pueden leer la traducción en español de Juan María Laó Ramos.

Pueden arrancar con los siguientes links:

Finalmente pueden descargar los recursos en español para estos controles: Paquete de idioma de Microsoft Chart Control para Microsoft .NET Framework 3.5

Y aquí les dejo unos screenshots de los ejemplos. Se ven muy bien!

Saludos, Gus

Descubriendo Live Mesh

2008-11-20T13:25:00.001-02:00

Como comentaba en un post anterior, Live Mesh es una de las aplicaciones de Microsoft que, basado en los servicios de Live Framework, permite en principio una sincronización de archivos simple, segura y transparente entre múltiples dispositivos. Desde computadoras personales, portátiles y dispositivos móviles a cámaras digitales e impresoras, entre otras. Pero Mesh es mucho más que sincronización de datos e iré comentando más en la medida que vaya probando y descubriendo sus bondades.

Por el momento estoy empezando a usar las capacidades de sincronización de archivos de Mesh con amigos y compañeros de proyecto y realmente es muy útil, si bien hoy no es una herramienta de control de versiones con capacidades de merge, etc., la simple posibilidad de tener archivos y carpetas distribuidos y sincronizados entre diferentes dispositivos ya tiene un gran valor.

Instalando Live Mesh

El primer paso consiste en ingresar al sitio https://www.mesh.com y conectarse a Live Mesh usando alguna cuenta de Live ID (por ejemplo una cuenta de Hotmail).

Esto significa que no necesito registrarme, completar formularios, etc. Simplemente utilizo mi cuenta de Live ID para Live Mesh.

Después del login en Windows Live, veré la página de dispositivos de Mesh. Desde aquí podré agregar mis dispositivos a Mesh. De forma predeterminada, ya existe un Live Desktop listo para usar. Se trata de un escritorio virtual online, donde podré acceder y administrar mis archivos y carpetas disponibles a través de Mesh.

Para agregar mi equipo a Mesh, selecciono Add device, y podré descargar e instalar el cliente de Mesh.

El cliente de Mesh está disponible para Windows XP y Windows Vista; existe una versión para Mac y, si bien en la página oficial no encontré referencias, me enteré que ya existe una versión para Windows Mobile que pueden descargarla desde https://m.mesh.com

Continuando con la instalación, debemos seleccionar la plataforma correcta y al presionar el botón Install, iniciaremos la descarga de LiveMesh.exe. Su instalación no tiene inconvenientes y dura unos 3 a 5 minutos.

Finalizada la instalación encontraremos en el área de notificaciones el icono de Mesh y deberemos iniciar una sesión con nuestra cuenta Live ID para agregar nuestro dispositivo a la red.

El siguiente paso es darle un nombre a nuestro equipo para conectarlo a la red de Mesh.

En pocos segundos tendremos nuestro equipo conectado a Mesh y podremos verlo junto a los demás equipos y dispositivos. En este caso solo encuentro mi equipo portatil y el Live Desktop.

Y si volvemos a la página de dispositivos de Mesh en la web (https://www.mesh.com/Web/Devices.aspx), veremos nuestro dispositivo agregado al anillo de Mesh.

Compartiendo archivos y carpetas

Ahora quiero crear una carpeta y compartirla entre mis equipos de Mesh. Para lograr esto podría crear una carpeta en Live Desktop y luego sincronizarla con mi equipo portatil y viceversa.

A modo de ejemplo, voy a crear una carpeta Test en mi escritorio local y agregarla a Live Mesh.

Como se muestra en la imagen es muy simple, gracias a la integración de Live Mesh con el Escritorio, Mi PC, el Explorador de Windows, etc.

Al seleccionar Add folder to Live Mesh veremos una ventana de diálogo donde podremos indicar el nombre de la carpeta a compartir y cuando debe sincronizarse con los demás dispositivos. Presionamos Ok y listo!.

Ahora nuestra carpeta Live Mesh cambió a un color azulado y ya tenemos disponible la misma carpeta en el Live Desktop (y otros dispositivos conectados). Observen también que el sitio de Mesh usa un protocolo HTTPS que nos proporciona seguridad de encriptación de datos en la transferencia de nuestros bytes.

Para terminar las pruebas, abrimos la carpeta Test de nuestro equipo local y creamos un simple archivo de texto Prueba.txt.

Esperamos unos segundos y listo! Este archivo Prueba.txt ahora también esta replicado en nuestro Live Desktop (y otros dispositivos, si existiesen). Podemos verificarlo ingresando a nuestro Live Desktop, haciendo doble clic en la carpeta Test.

Conclusiones

Es muy simple el uso de Live Mesh para compartir y sincronizar archivos y carpetas entre diferentes equipos y dispositivos. Su integración con el Shell de Windows lo hace muy amigable. Además podemos invitar a amigos y colaboradores para compartir archivos o documentos de trabajo y mantenernos sincronizados. Basta de diferentes versiones de archivo en diferentes lugares, tendremos una sola versión en todos los lugares que necesitemos.

En futuros post comentaré mi experiencia con Remote Desktop de Live Mesh.
Hasta la próxima!

PDC 2008 Buenos Aires

2008-11-19T09:20:00.001-02:00

Ayer martes 18 de Noviembre tuve la oportunidad de asistir a este importante evento realizado aquí en Buenos Aires. El evento inició con unas keynotes de la mano de Miguel Saez, Ezequiel Glinsky, Juan Ladetto y Alejandro Ponicke que nos comentaron un poco sobre el PDC 2008 de Los Angeles, realizado hace apenas 2 semanas, y lo que se viene: Windows Azure, Cloud Computing, Windows 7, etc.

Juan y Miguel, como ya nos tienen acostumbrados, en una excelente presentación en tiempo y forma, nos mostraron algunas bondades muy interesantes y útiles de Live Mesh. En siguientes posts comentaré mis experiencias con estas aplicaciones, su API, etc.

Ezequiel nos mostró unas fotos de los impresionantes DataCenters de Microsoft, particularmente el DataCenter de Quincy. Con inversiones de miles de millones Microsoft demuestra su fuerte apuesta en el futuro de los servicios basados en la nube.

Finalmente, Alejandro nos dió un preview de Windows 7, si bien no fue una presentación en profundidad, destacó algunas características interesantes como una TaskBar mucho más rica, desde donde podemos lanzar aplicaciones, acceder a documentos recientes, alternar aplicaciones en ejecución e incluso interactuar con las aplicaciones en runtime directamente desde la taskbar.

Luego de las 2 horas que duraron las keynotes tuvimos un break de 30 minutos donde aprovechamos unos cafés con ricas medialunas.

Las siguientes charlas se dividieron en 3 salas: una sala dedicada a Servicios en la nube, otra donde hablaron de Aplicaciones Clientes y Presentación (WPF, Silverlight, ASP.NET 4.0) y en la tercer sala se dedicaron a Herramientas, Lenguajes y Framework (F#, C#, Oslo, VS2010, etc.). Todas las charlas eran muy interesantes, pero había que decidir cual asistir. Mi amigo Mariano Noguera y yo nos inclinamos por la nube.

Servicios en la nube

Arrancamos con un recorrido por Cloud Services de la mano de Juan Ladetto, donde empezamos a ver un poco más de qué se trata Windows Azure. En nuevos posts intentaré hablar sobre lo que vaya conociendo de esta nueva plataforma que se perfila como una excelente y novedosa alternativa para hostear nuestras aplicaciones.

A continuación, con Matías Woloski y Edgardo Rosetto, desplegamos un servicio en la nube. La experiencia fue muy simple. Creamos una típica aplicación Hola Mundo en ASP.NET y lo desplegamos en Windows Azure, todo lo que hicimos fue seguir un asistente web que nos permitió hostear la aplicación, primeramente en un estado de Stagging para luego pasarla a Production. Si bien la aplicación hacía exactamente nada, lo interesante fue ver cómo ponerla en la nube y ver cómo esta aplicación puede escalar a voluntad en tiempo record simplemente cambiando valores en configuración. Este es un punto sin precedentes que permitiría que una aplicación pueda escalar horizontalmente en cuestión de segundos.

Nuevamente, Miguel Saez nos dió un paseo más programático sobre Live Framework y Mesh Services. Obviando los aspectos teóricos, Miguel nos mostró a través de una aplicación WPF, como interactuar con la API de Live Mesh y Live Contact. La verdad que es una API muy simple e interesante que más de uno puede encontrarle usos prácticos en las aplicaciones del mundo real. Podrán encontrar ppts y ejemplos en su blog.

Para terminar, y ya un poco agotados con esta maratón de charlas y novedades, Nicolás y Maximiliano de Huddle Group nos dieron una muy prolija y perfectamente sincronizada presentación de SQL Data Services. Nos mostraron el actual estado del arte, vimos un par de aplicaciones Windows y Web haciendo uso de las APIs, posibilidades y limitaciones actuales, y la intención de MS de llevar toda la potencia de SQL Server en la nube.

Fin del PDC

Pasadas las 22hs, terminaron las charlas y luego de un agradecimento de la gente de MS, se hizo un rápido sorteo de Libros, MS Mouses y algunas gorritas MSDN. No tuve la suerte de llevarme ningún libro, y había varios interesantes (Silverlight 2, Application = Markup + Code, ASp.NET 3.5, etc.), así que tuve que conformarme con la pulsera de la registración :-(

La verdad fue una jornada muy enriquecedora que mostró a las claras la intención de MS de posicionarse fuertemente en el negocio del Cloud Computing, las plataformas y herramientas que ofrecerá y cómo nosotros podemos beneficiarnos de estas nuevas plataformas que se hablan hoy y reinarán en los próximos 5 a 10 años.

Bueno, seguiré comentando sobre estas nuevas plataformas y tecnologías en futuros posts.
Byes!

Libro de OpenXML

2008-01-22T10:50:00.000-02:00

Wouter Van Vugt ha escrito el primer libro sobre OpenXML "Open XML Explained". En este libro de 128 páginas cubre los aspectos básicos del desarrollo con OpenXML. El autor es un especialista en los formatos de OpenXML, podrán ver su participación en los foros de OpenXmlDeveloper.org y en su blog encontrarán algunos posts sobre OpenXML y otras tecnologías de .Net Framework.

Podrán descargar el libro en formato PDF desde aquí.
Y podrán acceder a un versión en formato docx desde aquí.

Limpiar los items recientes en Visual Studio 2005

2008-01-22T10:29:00.000-02:00

No es una novedad, pero muchos me han preguntado si conocía una forma fácil de eliminar las entradas de los proyectos recientes en Visual Studio 2005, sin tener que editar/borrar manualmente entradas en el registro de Windows. Googleando un poco encontré una respuesta: MRU Cleaner.
Se trata de un add-in para borrar las entradas de los proyectos recientes en Visual Studio 2005, y no solo de los proyectos, sino también la lista de archivos recientes. La siguiente imagen muestra su uso:

Lo he probado y funciona muy bien. Pueden descargar una versión de este complemento para Visual Studio 2005 aquí. Y pueden obtener una versión beta para Orcas aquí.

Los documentos WordprocessingML

2008-01-16T13:02:00.000-02:00

Ya hemos visto qué es y por qué nos interesaría usar OOXML, y presentamos sus componentes principales y tecnologías asociadas. Ahora vamos a explorar uno de sus tres lenguajes de marcas principales: WordprocessingML. Veremos su estructura, sus partes, elementos y relaciones; y cómo se almacena un documento de WordprocessingML dentro del contenedor.

Partes de un documento WordprocessingML
Como ya hemos dicho, un documento WordprocessingML tiene muchas partes relacionadas que se almacenan dentro de un contenedor. Actualmente se utiliza el formato ZIP para empaquetar y contener un documento WordprocessingML. Si renombramos un documento .docx a .zip podremos descomprimirlo y explorar internamente cada una de las partes del documento.

Figura 1: Estructura de un documento WordprocessingML

Ests estructura es definida por la especificación Open Packaging Conventions del formato OOXML. Como se muestra en la figura, el archivo.zip contiene una estructura de carpetas y archivos XML que forman las partes del documento. El contenido principal del documento se almacena en el archivo document.xml de la carpeta word y los demás archivos .xml (fontTable.xml, settings.xml, styles.xml, webSettings.xml) contienen información de estilos, fuentes, configuración, etc. El siguiente gráfico muestra un esquema de documento WordprocessingML y sus partes relacionadas:

Figura 2: Partes de un documento WordprocessingML

En la raíz del paquete .zip existe un archivo llamado [Content_Types].xml que describe todos los tipos de contenido para cada una de las partes dentro del paquete. El Content Type indica al consumidor del documento qué tipo de contenido debe ser esperado dentro del paquete.
Si continuamos explorando el archivo .zip, veremos una carpeta llamada _rels. Esta carpeta contiene un archivo XML con extensión .rels que describe las relaciones entre las diferentes partes del documento y permite unir el documento y sus partes.

En la carpeta docProps, encontraremos varios archivos XML como core.xml, app.xml y custom.xml. Estos archivos almacenan las propiedades del documento. Por ejemplo, el archivo core.xml contiene las propiedades generales aplicacables a todos los documentos de OOXML como Título, Asunto, Autor, etc. EL archivo app.xml contiene propiedades específicas del documento como Número de páginas, Número de líneas de texto, Versión de la aplicación, etc. Finalmente, el archivo custom.xml contiene propiedades personalizadas agregadas por el autor o usuario del documento.

Archivos binarios
El formato XML no soporta nativamente los datos binarios como imágenes u objetos OLE. OOXML almacena los datos binarios en como partes binarias en su formato nativo. Si examinamos la carpeta media encontraremos las imágenes y objetos binarios que han sido incluidos en el documento.

Un documento WordprocessingML básico
Si quisiéramos crear un documento WordprocessingML básico, necesitaríamos al menos 3 partes:

Un archivo document.xml que contiene el cuerpo principal del documento.

Un archivo [Content_Types].xml que describe los tipos de contenidos incluidos en el paquete.

Un archivo .rels que define las relaciones entre las diferentes partes y permite ubicar cada parte dentro del paquete.

Figura 3: Documento Wordprocessing básico

La parte de inicio, document.xml
El primer elemento al crear un documento de OOXML es la parte de inicio (start-part). Este es el lugar donde los consumidores empezarán a parsear el contenido del documento. Los 3 lenguajes de marcas principales de OOXML (WordprocessingML, SpreadsheetML, PresentationML) contienen dentro del archivo ZIP una parte considerada como la parte de inicio. En WordprocessingML la parte de inicio es el archivo document.xml y es usado para almacenar el contenido principal del documento.

La siguiente figura muestra un ejemplo del contenido de un archivo document.xml:

Figura 4: Contenido de document.xml

Se puede observar una estructura XML bastante sencilla para formar un documento. Dentro del elemento document se puede crear los bloques de construcción del documento como párrafos, tablas y gráficos. Muchos de estos elementos utilizan el mismo identificador de espacio de nombres XML. Microsoft Office 2007 utiliza el prefijo w. Podemos usar cualquier otro prefijo, pero debemos mantener el espacio de nombres XML de WordprocessingML:

http://schemas.openxmlformats.org/wordprocessingml/2006/main

Los tipos de contenidos, [Content_Types].xml
Los consumidores de OOXML necesitan saber qué tipos de contenidos existen dentro del paquete. La lista de tipos de contenidos está definida dentro del archivo [Content_Types].xml que debe estar ubicado en la raíz del contenedor.
Los tipos de contenidos se identifican de dos formas:

Utilizando la extensión del archivo de partes dentro del paquete.

Especificando la ubicación y tipo de contenido del archivo dentro del paquete.

La siguiente figura muestra el contenido de un archivo [Content_Types].xml:

Figura 5: Contenido de [Content_Types].xml

Se puede ver claramente las dos estrategias utilizadas para identificar y definir los tipos de contenidos de cada parte dentro del paquete. Dentro del elemento Types se puede crear dos elementos, Default y Override. En el ejemplo, el elemento Default asocia la extensión xml con el tipo de contenido application/xml, y de forma similar puede observarse el tipo de contenido asociado a los archivos rels y los archivos png.

Anteriormente, hablamos del archivo document.xml , que es la parte de inicio y contiene el cuerpo principal del documento. Como la extensión de este archivo es xml, el elemento default, del archivo de tipos de contenidos, indicaría que se trata de un simple archivo de tipo application/xml, sin embargo este archivo es especial y debe ser definido como tal. Para ello se utiliza el elemento Override, para sobrescribir la asociación de tipos por defecto y especificar el tipo de contenido asociado en forma explícita.

En el ejemplo, existe un elemento Override que asocia el archivo /word/document.xml con el tipo de contenido application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml. Este mismo enfoque se utiliza para definir el tipo de contenido de las partes restantes del documento.

Las relaciones entre partes
Otro elemento requerido en un documento Wordprocessing, es el archivo de relaciones entre partes. En el archivo .zip existe una carpeta _rels que contiene un archivo .rels. Este es un archivo XML que define las relaciones y ubicación de las partes principales del paquete.

La siguiente figura muestra el contenido del archivo .rels:

Figura 6: Contenido del archivo .rels

El elemento Relationship contiene tres piezas básicas de información:

ID: Un identificador único para la relación.

Type: define el tipo de relación.

Target: especifica la ubicación del elemento o parte relacionada.

Debe observarse que no hay información sobre el origen (Source) de la relación. En este caso, el origen de la relación es implícito y relativo a la raíz del paquete.

Además del archivo .rels principal, dentro de la carpeta word/_rels existe un archivo document.xml.rels que define las partes relacionadas al documento.xml como el encabezado, pie, estilos y fuentes.

Utilizando el attributo type y target del archivo .rels, los consumidores de documentos OOXML pueden localizar el documento principal (start-part), y, luego, usando el archivo de relaciones asociado al documento principal (document.xml.rels), es posible ubicar el encabezado y pie, encontrar las imágenes y otras partes relacionadas al documento.

Hasta aquí hemos visto las partes principales de un documento de WordprocessingML, su formato y estructura. En la próxima entrega empezaremos a hacer ejercicios y veremos cómo crear y empaquetar esas partes en forma manual y en forma programatica, utilizando la API de Packaging (System.IO.Packaging) incluida en .NET 3.0.

Conociendo Office Open XML

2008-01-15T18:11:00.000-02:00

Anteriormente, comenté acerca de OOXML, la idea de Software + Servicios y cómo podemos beneficiar nuestros desarrollos con estos nuevos enfoques. En este post vamos conocer un poco más sobre OOXML, sus elementos y su estructura.

Componentes de OOXML
Como vimos en el post anterior, Office Open XML es una especificación basada en XML para documentos digitales como planillas de cálculo, gráficos, presentaciones y documentos de procesamiento de texto. La especificación fue desarrollada por Microsoft para suceder al formato binario de Microsoft Office y fue estandarizada por la ECMA en diciembre de 2006.

En la especificación actual aparecen tres lenguajes de marcas principales:

WordprocessingML: para documentos.
SpreadsheetML: para hojas de cálculo.
PresentationML: para presentaciones

Además de estos lenguajes de marcas, existen otros lenguajes subyacentes como DrawingML usado para dar soporte a gráficos, tablas y diagramas.
Las partes de un documento OOXML son empaquetadas dentro de un contenedor. Hoy se utiliza el formato ZIP para empaquetar y contener los archivos y recursos que componen un documento, sin embargo, podría utilizarse una base de datos como contenedor de documentos OOXML.
Finalmente, además de los lenguajes de marcas, la estructura interna dentro del paquete o contenedor también ha sido estandarizada. Esta estructura se conoce como Open Packaging Convention.
El siguiente gráfico resume los elementos principales de la especificación OOXML. ZIP y XML + Unicode no son parte de la especificación.

Figura 1: Componentes de Office Open XML

En el siguiente post exploraremos el formato y estructura de documentos WordprocessingML y comprenderemos mejor la relación entre los componentes de OOXML.

¿Por qué Office Open XML?

2008-01-15T17:21:00.000-02:00

También conocida como OOXML, es una de las nuevas siglas que inspiran cientos de posts en los blogs de tecnología. Office Open XML es una especificación basada en XML para documentos digitales como planillas de cálculo, gráficos, presentaciones y documentos de procesamiento de texto. La especificación fue desarrollada por Microsoft para suceder al formato binario de Microsoft Office. Esta especificación fue estandarizada por la ECMA en diciembre de 2006.

Actualmente, la especificación está siendo evaluada por la ISO referida como DIS 29500 (Draft International Standard 29500) y se ha generado una polémica en su entorno que escapa los fines de este post.

Software + Servicios
Más allá de la polémica suscitada sobre la estandarización, muchos desarrolladores se preguntarán por qué o para qué necesito aprender OOXML. Bueno, existen muchas motivaciones para usarlo. En los siguientes enlaces encontrarán dos artículos en español interesantes que hablan acerca de los fundamentos del nuevo mundo de documentos y los formatos de Open XML: http://www.microsoft.com/spain/interop/openxml/new_world_of_docs.mspx http://www.microsoft.com/spain/interop/openxml/ds_open_xml.mspx

De las diferentes oportunidades que OOXML puede generar, la que más me ha interesado como desarrollador fue la posibilidad de construir e implementar soluciones S+S (Software + Services) combinando las soluciones de clientes ricos y soluciones móviles con servicios de Internet.

Por ejemplo, crear una solución basada en planillas de cálculo que permita generar una orden de compra y publicarla en el sistema de gestión de compras a través de Internet; o escribir un artículo en el procesador de texto y publicarlo en la web con un solo clic.

Se trata de aprovechar la flexibilidad y experiencia de usuario enriquecida proporcionada por las aplicaciones de escritorio y móbiles y combinarlas con servicios de Internet basados, por ejemplo, en el modelo SaaS. De hecho, podría arriesgar a decir que S+S intenta cubrir los aspectos que se pierden en un enfoque SaaS puro, como la experiencia de usuario enriquecida basada en soluciones de escritorio ricas, capacidad de trabajo offline, mayor aprovechamiento de la plataforma subyacente, etc.

El papel de OOXML en S+S
Resulta interesante la idea de S+S, pero ¿qué papel juega OOXML?. En el pasado ya se han construido aplicaciones capaces de generar o capturar información a través de planillas de cálculo y documentos de texto utilizando los formatos binarios de Microsoft Office y otras suites.
Entiendo que un aspecto interesante de OOXML para los desarrolladores es, por ejemplo, el soporte que ofrece Microsoft a través de .NET Framework para crear y manipular documentos de OOXML, facilitando la integración y construcción de soluciones S+S.

Muchos aún discuten que OOXML no es estándar, que no es abierto, que no es XML, etc. Pero la realidad es que la mayoría de las empresas en el mundo centran su trabajo en el uso de documentos electrónicos. Aplicaciones como Excel y Word, se han convertido en la herramienta principal o preferida para registrar, visualizar, manipular y publicar datos. Estos escenarios basados en documentos representan nuevas oportunidades para complementar, interoperar y extender nuestros productos y servicios.

En los próximos post empezaré a explorar este nuevo mundo de Open XML desde la perspectiva del desarrollador; veremos la teoría y crearemos ejemplos en .NET.
Hasta la próxima!

Gustavo Azcona

Entity Framework: Code First

Code First

¿Cómo se mapean las clases POCO a la base de datos?

¿Qué pasa si ya tengo una base de datos heredada?

¿Qué hacemos cuando el esquema de base de datos es diferente al modelo conceptual?

¿Qué tal si quiero especificar restricciones, tipos de datos o validaciones a los campos?

Data Annotations

Mapping Fluent API

¿Y el contexto de datos de Code First?

¿Cómo o cuando se genera la base de datos?

¿Cómo sería la inicialización de base de datos en un entorno de producción?

Conclusión

Entity Framework: Model First

Model First

¿Qué pasa si la base de datos cambia?

Ya tengo mi modelo conceptual creado, como sigo?

¿Las clases de entidades generadas con Model First son POCO?

Conclusión

Entity Framework: Database First

Introducción

Database First

¿Puedo modificar o extender las clases de entidades generadas por EF?

¿Qué pasa si la base de datos cambia?

Conclusión

Imperdible el Barcamp NEA 2011!!!

Tutorial de MVC3

Twitter is over capacity…again!

IsNullOrWhiteSpace, that’s the question!

Cuidado! Un copo de nieve

Todo es difícil

Un salvador por aquí

¿Cómo se llega a esta situación?

¿Qué se puede hacer?

¿Se puede evitar esta situación?

Todo el problema no está en la programación

Microsoft Sync Framework: 'min_active_rowversion' no es un nombre de función integrada reconocido

Próximamente: IIS Express

SQL Server CE embebido en ASP.NET

La familia crece: Nuevo Visual Studio LightSwitch

¿Cómo manejar el ciclo de vida del DataContext/ObjectContext en ASP.NET?

1. Un contexto por Session

2. Un contexto por Request

3. Un contexto por instancia de acceso a datos

4. Un contexto por operación de acceso a datos

Mejores enlaces en ASP.NET

Escribiendo enlaces correctos y limpios

Mejorando la escritura de los enlaces

Microsoft Web Platform Installer

Software Libre vs Software Propietario

Introducción

Mito 1: Si es Software Libre, es Gratis

Mito 2: Si es Software Propietario, no es Libre

Mito 3: Si es Software Propietario, hay que pagar licencias

Mito 4: Si la licencia de uso es gratis, el costo del sistema es cero

Usar lo mejor de cada mundo

ADO.NET Entity Framework: The version of SQL Server in use does not support datatype 'datetime2'

Paginación y Ordenamiento del lado servidor con GridView y ADO.NET Entity Framework

Creando los métodos en la capa de negocio o servicios

Consumiendo los métodos desde la UI

RUN09

Buenos Aires Briefing 09 o busquemos un nuevo nombre

ADO.NET Entity Framework: ¿Cómo actualizar un objeto desconectado?

ADO.NET Entity Framework: Nuevos proveedores de datos

ADO.NET Entity Framework: ¿Cómo cambiar la ForeignKey de un objeto?

ASP.NET Performance Tip: Eliminar HttpModules innecesarios

Silverlight y PhotoSynth en la presidencia de Obama

ADO.NET Entity Framework: ¿Cómo incluir los objetos relacionados?

Session Timeout vs FormsAuthentication Timeout

Control Extensions

Propiedades y métodos públicos en la MasterPage

¿Cómo recuperar el objeto DataItem del control ListView?

String Extensions

Nuevo control de Chart en ASP.NET

Descubriendo Live Mesh

PDC 2008 Buenos Aires

Libro de OpenXML

Limpiar los items recientes en Visual Studio 2005

Los documentos WordprocessingML

Conociendo Office Open XML