Entity Framework desde el principio (parte III)

 

“…Life is a lesson, you learn it when you're through”

Take a look around, Limp Bizkit

Introduccion

Hola a todos, luego de mas de un año de ausencia decido retomar mi blog con un nuevo post acerca de EF4, entre muchas otras motivaciones personales un post post en uno de los blogs que acostumbro seguir, sumo un elemento extra a esta motivacion, el blog del que les hablo es de Angel “Java” Lopez y el post que me motivo es este “Mi Tia Carlota, un año despues”. Concretamente en este ultimo tiempo si bien estuve involucrado, ya sea por motivos laborales o personales, en diferentes proyectos y estudiando nuevas tecnologias, en ningun caso o en muy pocos mis inquitudes y trabajos han generado algun “entregable” mas allla de lo producido en el ambito estrictamente laboral, lo cual solo incumbe a ese ambito y no es apto para compartir libremente hacia la comunidad. En fin; movido por estos aspectos es que retomo la actividad en mi blog.

Este post continua una serie, en los que vuelco aquello que voy aprendiendo acerca de Entity Framework 4, si bien aun no he tenido la posibilidad de utilizar esta herramienta en un proyecto profesional, estoy siempre jugando alrededor de este ORM de Microsoft y lo he probado y lo seguire utilizando en mis proyectos personales. Para este post voy a abordar un tema que fue largamente esperado por la comunidad que utiliza EF como es Code-First Development, esta modalidad es una alternativa a la que ya he tratado de ilustrar con los otros post de esta serie, en la que el desarrollo estaba “centrado en la base de datos” en esta en cambio el desarrollo se centra en el codigo.

Para ilustrar el uso de EF code first development vamos a crear una muy simple aplicacion web utilizando el framework de microsoft ASP.Net MVC 2, con el cual tambien he estado experimentando y leyendo bastante en este tiempo, y el cual me ha fascinado. Comencemos con el ejemplo propuesto:

Paso 1.

Lo primero que haremos sera crear un nuevo proyecto en visual studio 2010, seleccionaremos dentro de la categoria Web, el template ASP.NET MVC 2 Web Application, como vemos en la imagen a continuacion:

Una de las cosas que tiene de bueno el MVC de microsoft son sus puntos de extensibilidad, y el primero de estos puntos es la ventana que veremos luego de dar OK al dialogo de crear nuevo proyecto, y es una ventana que nos pregunta si queremos agregar un proyecto de test a nuestra aplicacion, y de crearlo, nos permitira seleccionar que framework de test vamos a utilizar (por defecto MSTest). En este caso nosotros seleccionaremos que no deseamos crear un proyecto de test (esta opcion significa en las palabras de Scott Hanselman; “Soy una mala persona” )

Paso 2.

Definimos el modelo, para este caso vamos a utilizar un modelo muy sencillo, digamos que los alumnos de 4to grado de un colegio van rindiendo diferentes evaluaciones a lo largo del a;o esta aplicacion me permite cargar dichas evaluaciones y realizar con ellas algunas operaciones sensillas con estos.

Vamos a agregar dos clases a nuestra carpeta de Modelo (boton derecho Add | Class), Alumno y Evaluacion, de esta forma:

public class Alumno
{
    public int ID { get; set; }
    public string Nombre { get; set; }
    public string Apellido { get; set; }
    public IList<Evaluacion> evaluaciones { get; set; }
}

public class Evaluacion
{
    public int ID { get; set; }
    public int Nota { get; set; }
    public string Name { get; set; }
    public DateTime Fecha { get; set; }
}

En las imagenes podemos ver los cambio que introducimos:

Como podemos ver aca acabamos de crear 2 clases que son “plain old CLR object” aka POCO, EF 4 tiene soporte para objetos POCO, nos valemos de esto cuando utilizamos esta estrategia de Code First, como vemos aqui aun no hemos puesto ni una sola palabra acerca de nuestra base datos, vamos a continuar con el ejemplo sin tocar aun este aspecto.

Paso 3

El siguiente paso consiste en crear una clase de contexto que maneje la persistencia en la base de datos nuestra clase de contexto vamos implmentarla de la siguiente forma: Nuevamente agregamos una clase a nuestra carpeta Models (boton derecho Add | Class) la cual nombramos como _4toGradoContext; aqui comenzamos a utilizar EF 4 haciendo que esta clase herede de DbContext como vemos en la siguiente imagen:

Como vemos en el codigo Visual Studio no conoce aun a que tipo estamos haciendo referencia cuando decimos que nuestra clase de contexto hereda de DbContext, entonces vamos completar este paso agregando las referencias que nos faltan. Para cumplir con esta tarea vamos a utilizar NuGet.

Brevemente NuGet es un sistema de administracion de paquetes orientado a desarrolladores, open source y gratis; para el framework .NET y cuyo fin es simplificar el proceso de incorporar librerias de terceras partes al framework .NET durante el desarrollo. Descargando NuGet desde aqui:

http://nuget.codeplex.com/releases/58939/download/222685

Una vez que instalamos NuGet, estaremos listos para agregar el paquete de EF Code First que necesitamos de la siguiente forma: boton derecho en References | Add Library Package Reference…)

Aqui vemos el dialogo que aparece:

En el menu de la izquierda deleccionamos la opcion Online, y alli podemos buscar en la barra de busqueda Entityframework y vamos a seleccionar la opcion que esta resaltada en la imagen de arriba, y hacemos click en el boton Install y se agregaran todas las herramientas necesarias para usar EF 4.

Ahora si podremos completar nuestra clase de contexto de la siguiente forma:

Este es todo el codigo que necesitamos agregar para “mapear” nuestro dominio a la base de datos, sin archivos XML ni wizards, incluso aun no hemos escrito ni una sola palabra acerca de nuestra base de datos, de la que nos vamos a ocupar ya mismo.

Paso 4

Ahora si ha llegado el momento de hablar de nuestra base de datos, vamos a crear una base de datos de la siguiente forma: Previamente tengo instalado Microsoft SQL Server 2008 R2 Express, en caso de no tenerlo instalado podemos rapida y sencillamente hacerlo sin salir de Visual Studio 2010, tenemos un boton que nos abre directamente la aplicacion Web Platform Installer 3.0 como vemos en la imagen. Desde alli es muy sencillo dercargar Microsoft SQL Server Express 2008 R2 en instalarlo.

Vamos entonces a agregar una nueva base de datos de esta forma:

Una vez creada nuestra nueva base de datos editamos el archivo de configuracion Web.config de la aplicacion web y agregamos nuestra nueva conexion a la base de datos recientemente creada

Paso 5

Vamos a utilizar ahroa nuestro modelo, y lo primero que haremos es crear un controller para crear un nuevo alumno de la siguiente forma: Haciendo click boton derecho sobre la carpeta Controllers seleccionamos Add | Controller…

Luego vemos este dialogo:

Alli editamos el codigo de nuestro nuevo Controller al que llamamos Alumno

El linea 12 podemos ver como usamos nuestra clase de contexto que sera la encargada de manejar la persistencia con la base de datos, en el metodo Create vemos que es muy sencillo crear y guardar un nuevo alumno en nustra base de datos.

Vamos ahora a crear una vista para este metodo, haciendo click boton derecho en alguna region del metodo Create del controller y alli Add View…

Para ver este dialogo:

      

Aqui es donde podemos crear nuestra vista que llamaremos Create y la cual sera tipada (chequeando la casilla Create a strongly-typed view) y tambien seleccionaremos Create de la lista de View Content.

Y asi vemos como se ha creado la vista para nuestro metodo create que nos permitira ingresar datos que luego a traves de la clase Alumno del modelo sera persistida en la base de datos.

Ahora SI, vamos a ver la accion, presinemos F5 y vamos a navegar a la direccion

/Alumnos/Create

Y nos encontraremos con lo siguiente:

Ahora veamos un poco que esta pasando en el controller cuando completo los campos y hago click en el boton Create

y finalmente…

Conclusion

Bueno este ha sido mi post de regreso, EF ha evolucionado mucho en este ultimo tiempo, y ha mejorado drasticamente. Por mi parte yo seguire probando esta herramienta y espero poder volcar en subsiguientes posts esas experiencias; dejo aqui algunas funtes que me ayudaron a armar este post:

Mis links sobre entity framework en delicious.com: http://www.delicious.com/camilovera/entityframework

El libro que (por ahora) me gusta sobre ASP.NET MVC 2:http://www.amazon.com/Professional-ASP-NET-MVC-Wrox-Programmer/dp/0470643188/ref=sr_1_1?s=books&ie=UTF8&qid=1303096285&sr=1-1

Un link super interesante de Jose Romaniello donde hace una comparacion profunda entre Entity Framework y NHibernate, para aquellos que quieran profundizar y ver otra herramienta ORM (mas madura que EF): http://jfromaniello.blogspot.com/2011/03/entityframework-41-rc-code-first-review.html

Entity Framework Desde El Principio (Parte II)

Interactuando con la base de datos

“Where is the ‘any’ key?”
– Homer Simpson, in response to the message, “Press any key”

En esta segunda parte del tutorial acerca de Entity Framework 4.0, pondremos el acento en como persisitir los cambios que realizo en el modelo (EDM) en la base de datos asociada. Para ello nos serviremos de un nuevo ejemplo que podran descagar siguiendo el link al final del post. Como ya hemos visto en el primer post de esta serie, recuperar datos desde la base de datos, ahora nos abocaremos a la persistencia de nuevos objetos, la modificacion de entidades existentes y la eliminacion de estas.

Veamos en la figura el EDM planteado para este ejemplo:

Ahora vamos a crear algunos objetos nuevos e intentar que estos cambios impacten en nuestra base de datos de forma adecuada, en el siguiente listado vemos un ejmplo de como hacerlo.

class Program
{
  static void Main(string[] args)
  {
      using (CopyRentADMEntities ctx=new CopyRentADMEntities())
      {
          //Creo algunas Marcas nuevas
          MarcasEquipo m1 = new MarcasEquipo();
          m1.MarcaID = 1;
          m1.Nombre = "Perox";
          MarcasEquipo m2 = new MarcasEquipo();
          m2.MarcaID = 2;
          m2.Nombre = "Sister";
          m2.Web = "http://www.Sister.net";
          MarcasEquipo m3 = new MarcasEquipo();
          m3.MarcaID = 3;
          m3.Nombre = "Sonica-Pinolta";
          m3.Web = "http://www.Sonica-Pinolta.com";
          //Agrego las Marcas Creadas al contexto
          ctx.MarcasEquipo.AddObject(m1);
          ctx.AddToMarcasEquipo(m2);
          ctx.AddToMarcasEquipo(m3);
          //Persisto los cambios realizados
          ctx.SaveChanges();
      }
      System.Console.WriteLine("Wait for user entry!");
      System.Console.ReadLine();
  }
}

Si nos dirijimos ahora al SQL Server Management Studio y realizamos una consulta en la tabla en la que acabamos de ingresar los nuevos datos podemos ver como estos fueron guardados con exito en la base de datos, como se puede ver en la siguiente imagen.

Completemos algunos datos de las demas entidades del modelo, con el siguiente listado.

class Program
{
  static void Main(string[] args)
  {
      using (CopyRentADMEntities ctx=new CopyRentADMEntities())
      {
          //Creo algunos Modelos
          ModelosEquipos mo1 = new ModelosEquipos();
          ModelosEquipos mo2 = new ModelosEquipos();
          ModelosEquipos mo3 = new ModelosEquipos();
          ModelosEquipos mo4 = new ModelosEquipos();
          ModelosEquipos mo5 = new ModelosEquipos();
          ModelosEquipos mo6 = new ModelosEquipos();
          //Setting properties
          mo1.MarcaID = 1;
          mo1.ModeloID = 1;
          mo1.NombreModelo = "MK2000";
          mo2.MarcaID = 2;
          mo2.ModeloID = 2;
          mo2.NombreModelo = "Vison208";
          mo3.MarcaID = 2;
          mo3.ModeloID = 3;
          mo3.NombreModelo = "Printer3";
          mo4.MarcaID = 3;
          mo4.ModeloID = 4;
          mo4.NombreModelo = "CR100";
          mo5.MarcaID = 3;
          mo5.ModeloID = 5;
          mo5.NombreModelo = "Comodo64";
          mo6.MarcaID = 3;
          mo6.ModeloID = 6;
          mo6.NombreModelo = "Ataque_77";
          //Add objects to context
          ctx.AddToModelosEquipos(mo1);
          ctx.AddToModelosEquipos(mo2);
          ctx.AddToModelosEquipos(mo3);
          ctx.AddToModelosEquipos(mo4);
          ctx.AddToModelosEquipos(mo5);
          ctx.AddToModelosEquipos(mo6);
          //Saving Changes
          ctx.SaveChanges();
          //Creo algunos Equipos nuevos
          Equipos e1 = new Equipos();
          Equipos e3 = new Equipos();
          Equipos e2 = new Equipos();
          Equipos e4 = new Equipos();
          // Seting Properties
          e1.EquipoID = 1;
          e1.Medidor = 23399;
          e1.ModeloID = 1;
          e1.Propio = true;
          e1.Tension = true;
          e2.EquipoID = 2;
          e2.ModeloID = 2;
          e2.Propio = false;
          e2.Tension = false;
          e3.EquipoID = 3;
          e3.ModeloID = 5;
          e3.Propio = true;
          e3.Tension = false;
          e4.EquipoID = 4;
          e4.ModeloID = 5;
          e4.Propio = true;
          e4.Tension = true;
          //Adding Equipos to context
          ctx.AddToEquipos(e1);
          ctx.AddToEquipos(e2);
          ctx.AddToEquipos(e3);
          ctx.AddToEquipos(e4);
          //Saving Changes
          ctx.SaveChanges();
      }
  }
}

Veamos ahora como editar los elementos:

//Making some changes
//Selecting the elements
var SelEquipos = from p in ctx.Equipos
               where p.ModeloID == 5
               select p;
foreach (Equipos e in SelEquipos)
  e.Medidor = 1000;
//Saving changes
ctx.SaveChanges();

Y ahora eliminamos un elemento:

//Deleting an Object
var SelEquiposToDelete = from p in ctx.Equipos
               where p.EquipoID == 2
               select p;
ctx.DeleteObject(SelEquiposToDelete.First());
//Saving changes
ctx.SaveChanges();

Conclusion

En estos dos primeros post que sirven como introduccion al uso de Entity Framework 4.0 cubri los aspectos basicos acerca de la herramienta a saber:

• Conectar con una base de datos y obtener un modelo (EDM) a traves del asistente.



• Obtener el contexto para operar sobre las entidades del modelo y persistir luego los cambios en la base de datos.



• Realizar Operaciones CRUD.

En el siguiente post veremos uno de los features mas esperados de EF 4 y es el soporte POCO (Plain Old CLR Objects). Desde esa perspectiva podremos apreciar el verdadero poder de Entity Framework.

Feliz Programacion!

Entity Framework Desde El Principio (Parte I)

“Software is like entropy: It is difficult to grasp, weighs nothing, and obeys the Second Law of Thermodynamics; i.e., it always increases.”
– Norman Augustine

Voy a escribir una serie de posts acerca de Entity Framework, concentrandome en la nueva version de esta herramienta, Entity Framework 4.0 (EF 4, de aqui en mas). La intencion es abordar el uso de esta solucion desde el principio e ir icrementando alguna aplicacion de ejemplo.
En principio voy a listar algunas descargas que nos permitiran seguir los ejemplos y realizar pruebas.
Visual Studio 2010 Utlimate Beta 2
ADO .NET Entity Framework 4.0 Feature Comunity Technology Preview 2
Microsoft SQL Server 2008 Express
Microsoft SQL Server 2008 Database Product Sample AdventureWorks 2008R2 November CTP
Una vez que tenemos estas herramientas podemos poner manos a la obra y empezar a hacer pruebas, para realizar las pruebas con EF 4, voy a utilizar la base de datos AdventrueWorks cuyo link de descarga he dejado mas arriba. Aqui podemos ver una pantalla del SQL Management Studio que nos muestra las tablas de la base de datos de ejemplo.

En este primer post voy a mostrar como generar un modelo a partir de una base de datos existente en mi instancia local de SQL Server 2008 Express, este primer ejemplo es muy basico y talvez trivial pero es un primer acercamiento al uso de Entity Framework y esta orientado a aquellas personas que talvez ni siquiera conocian la herramienta. Es por este motivo que este ejemplo no debe ser tomado como un ejemplo acerca de como construir software de calidad, simplemente es un ejemplo util a la hora de conocer EF 4. Ahora si, nos dirigimos al Visual Studio 2010 y creamos un nuevo proyecto (Libreria de clases) que llamaremos DemoEF40.DataL y nombraremos a la solucion DemoEF40. Como vemos en la primer imagen:

Luego hacemos click en el proyecto que acabamos de crear y en el menu Proyecto, seleccionamos Add Item y alli seleccionamos el template ADO .NET Entity Data Model. Una vez seleccionado el template se nos va a abrir la ventana del Entity Data Model Wizard, alli seleccionamos la opcion Generate From Database y click en Next. Una vez alli nos encontraremos con un asistente que nos permitira conectarnos con nuestra base de datos, seleccionamos algunas tablas de la base de datos, aquellas entidades que seran luego las clases de nuestro modelo y finalmente le damos click al boton Finish! Esta serie de pasos se puede ver en las siguientes imagnes:

En la ultima imagen podemos ver el modelo generado a partir de las tablas que seleccionamos en el asistente, en el Solution Explorer, vemos la clase generada a partir del generador de codigo T4, cuyo nombre en mi caso es DemoEF40Model.Designer.cs si hacemos clic derecho sobre este item y navegamos sus propiedades podemos ver lo siguiente:

Ahora que tenemos nuestro modelo creado y listo para usar, haciendo click con el boton derecho en la solucion DemoEF40, luego en la opcion Add new project, agregamos un proyecto de consola a la solucion al cual llamare DemoEF40.Console, con este proyecto vamos a realizar unas pruebas a nuestro modelo de datos y verificaremos si impacta de forma correcta en nuestra base de datos. Lo primero que probaremos sera traer datos de la base de datos. Para realizar esto vamos a tener en cuenta lo siguiente:

1. Vamos a Agregar una referencia en nuestro proyecto DemoEF40.Console al proyecto DemoEF40.DataL, en el menu Project haciendo click en Add Reference.
2. Vamos a setear el proyecto DemoEF40.Console como Start Up Project.
3. Vamos a agregar una referencia a System.Data.Entity
4. Vamos a copiar el archivo de configuracion App.conf del proyecto DemoEF40.DataL al proyecto DemoEF40.Console.

Ahora vamos a probar un codigo sencillo para recuperar algunos elementos desde la tabla Products, como el sigiuente listado

class Program
{
    static void Main(string[] args)
    {
        AdventureWorksEntities ctx = new AdventureWorksEntities();
        foreach (Product b in ctx.Products)
        {
            System.Console.WriteLine(b.Name);
        }

    }
}

En este codigo podemos ver como listar los productos que existen en nestra base de datos y que corresponden a los registros de la tabla Products. Simple no? Podemos destacar de este codigo la siguente linea:

AdventureWorksEntities ctx = new AdventureWorksEntities();

En esta linea vemos como accedemos al contexto que envuelve nuestro modelo mediante la creacion de una instancia de AdventureWorksEntities, si observamos esta clase en la definicion del modelo veremos que es esta la que hereda de ObjectContex, por el momento no nos adentraremos en detalles sobre este topico en particular pero en sucesivos post veremos mas en detalle la clase ObjectContext.

Veamos como podemos realizar consultas de manera muy simble con Linq, como la que realizamos en el siguiente listado:

class Program
{
    static void Main(string[] args)
    {
        AdventureWorksEntities ctx = new AdventureWorksEntities();
        var s = from p in ctx.Products
                where p.ProductID < 100
                select p;
        foreach (Product b in s)
        {
            System.Console.WriteLine(b.Name+"["+b.ProductID.ToString()+"]");
        }
        System.Console.ReadLine();
    }
}

Conclusion

He cubierto con este post un primer acercamiento a Entity Framework 4.0 para aquellos que jamas habian utilizado esta herramienta o algun otro ORM. Vimos como crear un modelo a traves del Entity Model Wizard, partiendo de una base de datos existente (una caso muy comun) y como traer datos desde la base de datos hacia el modelo conceptual o de objetos planteado y generado automaticamente. Este ejemplo es solo util a los efectos de conocer EF, ya que carece de valor en el mundo real, veremos en sucesivos post como nos acercaremos a un ejemplo de mundo real con los nuevos features de EF 4.

PD: Este es el ultimo post del año 2009!!, espero que en el venidero 2010 sigamos compartiendo nuestra pasion por la tecnologia y que se cumplan nuestros mas profundos y ansiados deseos. Que empiecen bien el año. Y Feliz programacion!

Run Reloaded 2009 - PARTE III (Final)

Herramientas de arquitectura
Este es el ultimo post de una serie de tres donde la tematica central son las mejoras que traera consigo el nuevo IDE Visual Studio 2010, inspirandome en el evento Run Reloaded 2009 que microsoft realizo el mes de novimenbre pasado en Buenos Aires, Argentina y en cual expertos oradores nos mostraron y debatieron con nosotros (la comunidad) el uso de estas nuevas herramientas; para el final de esta serie de posts he dejado una mejora muy interesante y son las nuevas herramientas de arquitectura que trae incoporado VS 2010. Para poder probar es necesario descargar (es gratuito) la version Ultimate de Visual Studio 2010 beta 2. Visual Studio 2010 Ultimate Beta 2 puede descargarse desde AQUI.
Microsoft nos ofrece un nuevo esquema de versiones para Visual Studio 2010 y es el siguiente:
Visual Studio 2010 Professional
Visual Studio 2010 Premium
Visual Studio 2010 Ultimate
En la version Ultimate es en la cual tenemos completas las herramientas para arquitectura.
Las herramientas principales son las siguientes:

• Architecture Explorer (Explorador de arquitectura)
• UML Support (Soporte UML)
• Layer Diagram (Diagrama de capas)

Para probar estas nuevas herramientas he tomado un proyecto de la pagina Code Porject, un sitio que recomiendo a todos los interesados en el desarrollo de software, como una fuente muy rica de recursos de los mas variados. El proyecto pertenece a Marcelo Ricardo de Oliveira y consiste en un juego de Pool llamado Snooker. Pueden descargar el codigo fuente AQUI.

Architecture Explorer
Con esta herramienta podemos obtener diferentes vistas de nuestra solucion y nuestros poryectos, esta herramienta la encontramos en el nuevo menu de Arquitectura.

En la imagen podemos ver como se despliega el menu Generate Dependency Graph, este grafico lo puedo generar por Assemblie, por Namespace, por Clase o de forma personalizada. En este caso voy a generar por Namespace y obtengo lo siguiente:

En la imagen podemos ver como genero el grafico con las dependencias entre cada namespace.
Ahora expandimos el nodo CSharpSnookerCore.Model y vemos los elementos en su interior:

Podemos lograr aun mas profundidad si expandimos por ejemplo alguna clase dentro del nodo anterior y vemos los metodos de las clases por ejemplo de la clase Pocket:

En el menu View podemos ver el Architecture Explorer, nos permite navegar nuestra arquitectura de manera facil, intuitiva, y establecer filtros para los elementos

Podemos establecer filtros para facilitar la navegacion dentro de los elementos de la siquiente forma:

Como podemos apreciar, el Explorador de Arquitectura tiene muchas opciones y es una herramienta poderosa que nos permitira ampliar nuestra vision del poryecto en su conjunto.

UML Support
El soporte para UML (Unified Modeling Language), es una herramienta totalmente nueva en Visual Studio, la creacion de modelos es a traves de un template y veremos a continuacion como realizarla
Un proyecto de modelado UML se crea como cualquier proyecto nuevo en el menu File, New Proyect, en la categoria Modeling Projects existe un solo template que se llama Modeling Project

Una vez creado el proyecto podemos ver la ventana del UML Explorer, a la cual podemos acceder a traves del menu View, alli podemos agregar algunos elementos a nuestro modelo, haciendo click derecho sobre el modelo vemos el menu Add


Agregar un nuevo diagrama al modelo es tan sencillo como agregar cualquier item a un proyecto, en el menu Project, Add new Item, vemos el cuadro de dialogo para agregar un nuevo diagrama.

Podemos usar la ventana toolbox para agregar nuevos elementos al diagrama o podemos utilizar los elementos que ya existen en nuestro modelo arrastrandalos al diagrama.

De la misma forma podemos crear diferentes tipos de Diagramas UML, utilizando los items de la toolbox dependiendo del diagrama que estemos creando


Layered Diagram (Diagrama de Capas)
En el proyecto de modelado si agregamos un Diagrama de Capas (Layer Diagram) podemos ver lo siguiente

Para agregar un diagrama de capas, lo podemos hacer desde el menu Architecture, Add New Diagram, alli veremos el siguiente dialogo

Este tipo de diagramas es de gran utilidad ya que nos permite agrupar en capas la estructura de nuestro proyecto y verificar la comunincacion entre las diferentes capas. Realizando la validacion de la arquitectura.

He tomado la siguiente imagen de Skinner's Blog. Y se puede ver claramente el funcionamiento de los diagramas de capas


Conclucion
Hasta aqui he presentado las nuevas herramientas de arquitectura que incluye Microsoft Visual Studio 2010 (recordemos que esta version es la Ultimate y se encuentra en Beta 2). Las cuales a mi parecer son muy utiles y le agregan mucho valor al IDE. Una cosa a mejorar es la ausencia de una herramienta que me permita generar codigo a partir del modelo UML (seria ideal la utilizacion de templates T4? para ello) talvez veamos estas features en la version final de VS 2010. La primera experienca utilizando esta herramienta fue muy placentera y sumamente util, aun sigo probando el nuevo VS 2010.
Saludos a todos y feliz programacion!

Aqui empezo todo

"Un viaje de mil millas comienza con el primer paso"
Lao-Tsé

Este post no tiene nada que ver con C# ni con el .Net Framework, ni siquiera con Microsoft ni nada parecido, al menos para ustedes, para mi talvez si, ya que este post, se trata de mi primer contacto con una computadora, me puse nostalgico!; particularmente este primer contacto sucedio cuando un tio me obsequio una cz Spectrum, este evento fue alla por el ahora lejano 1987, donde yo que era un incipiente gamer pero de consolas (con mi Atari 5200 con que mas?!?!) descubriria el mundo de los computadores gracias a mi cz Spectrum, y con ella se abririan para mi las puertas de los lenguajes de programacion, primero el basic, luego el c, y mas tarde el assembler... En aquel tiempo lejano y heroico comence a andar en este mundo de la tecnologia.

La cz Spectrum fue la version Argentina de la zx Spectrum de Sinclair, fabricada en Parana, provincia de Entre Rios por Tadeo Czerweny.

Aqui algunas caracteristicas tecnicas de aquel equipo:

• Procesador: Z80A - 8 bits a 3,25 Mhz
• Ram: 2 KB expandible a 16 KB
• Rom: 8 KB
• Basic: Sinclair Basic (37 funciones y 34 comandos)
• Teclado: Membrana: 40 teclas
• Pantalla (modo texto): 32 x 22 caracteres
• Pantalla (modo grafico): 64 x 44 pixeles

A continuacion dejo algunos links para los nostalgicos como yo:
El foro del spectrum speccy.org: http://www.speccy.org/foro/index.php

Planet Sinclair, aqui recomiendo ver la biografia de Sir Clive Marles Sinclair, personaje controvertidos si los hay y creador entre otras cosas de la spectrum, http://www.nvg.ntnu.no/sinclair/contents.htm

CZ Spectrum en Wikipedia: http://es.wikipedia.org/wiki/CZ_Spectrum

Con esto me despido de ustedes, feliz programacion!