lunes, 31 de marzo de 2014

Entity Framework Code First

Code First, de Entity Framework, es el último enfoque agregado al Entity Framework, e introducido en la versión 4.1 del Framework de .NET (Los dos enfoques previos son Database First y Model First). 

Este enfoque, como su nombre lo dice, se basa en codificar primero, es decir crear clases POCO (Plain Old CLR Objects), utilizando el lenguaje deseado, VB.NET, C#, etc. de las diferentes entidades, y crear relaciones entre las mismas, luego se crea automáticamente la base de datos. Esta es la principal utilidad del EF Code First, aunque también puede utilizarse con Bases de Datos existentes, lo cual nos da un mayor control sobre el código generado, ya que nada será realizado por el asistente. 

La ventaja principal que posee el enfoque "Code First", es que ya no debemos preocuparnos mas por Transact SQL, ni por la base de datos en sí, ya que la misma será la manera en que se persisten los objetos creados. En síntesis, estaremos programando solamente con C# o VB.NET y LINQ.



Para abordar este enfoque, se debe comenzar definiendo nuestras entidades, lo cual puede realizarse como objetos POCO.




Luego de la definición de todas las entidades necesarias, se debe proceder a crear la clase de contexto para interactuar con la base de datos.





Tratándose de una aplicación web, en nuestro archivo web.config debe determinarse la cadena conexión a la base de datos, dentro de la correspondiente sección <connectionStrings>.




Posteriormente a esta configuración inicial de nuestro modelo, y sin necesidad de crear siquiera nuestra base de datos en el servidor definido en el web.config, podemos utilizar el modelo, para crear un nuevo empleado, y al llamar al método SaveChanges() de nuestro contexto se procederá a crear la base de datos, la tabla correspondiente en la base de datos y se insertará un registro en la misma. 



Posteriormente podemos conectarnos al servidor de nuestra base de datos, y verificar que todo ocurrió tal como fue codificado con nuestro EF Code First.

Más adelante entraremos más en detalle en la definición de las clases POCO, para lograr que se realicen las validaciones correspondientes al momento de registrar datos en las entidades y por consecuencia en la base de datos.

martes, 25 de marzo de 2014

Introducción a LINQ

LINQ (Microsoft.NET Language Integrated Query) es a la vez un lenguaje, y una extensión del Microsoft .NET Framework. Fue introducido con la versión 3.5 del Framework de .NET, para constituirse en un puente entre la programación de objetos y trabajar con los datos.

LINQ convierte el acceso a datos y las consultas en un lenguaje construido en Visual Basic o en Visual C#. Provee un modelo consistente para trabajar con los datos sin importar de donde vienen los datos. Por lo tanto la programación con LINQ permite utilizar todas las características propias de la programacion, para hacer el tratamiento de los datos más fácil y consistente.

LINQ cambia la manera en que accedemos y consultamos datos. Antes que LINQ fuera creado, las mayoría de las consultas se escribían y ejecutaban directamente contra la Base datos, por lo que dicho texto SQL dependía fuertemente de la tecnología subyacente.
LINQ posee dos ventajas principales:

  • La primera de ellas es que se realiza un chequeo de los objetos LINQ en tiempo de compilación, por lo que es posible de encontrar y descubrir más facilmente los errores, además de la posibilidad de utilizar IntelliSense para hacer más fácil escribir el código fuente.
  • La segunda, es que provee un modelo consistente para realizar las consultar contra todas las tecnologías de base de datos, y todo tipo de objetos, incluyendo listas, XML, arrays, etc.






LINQ permite realizar consultas a cualquier objeto que soporte la interface, IEnumerable o IEnumerable<T>; lo que serían todas las colecciones de datos, incluídos los DataSet, List<T>, Array y muchos más.

Supongamos que tenemos una lista de objetos Empleado, esta lista es llamada empleados. En dicha lista, por medio de la utilización de LINQ podremos obtener todos los empleados que trabajan en el departamento IT, de la siguiente manera:

IEnumerable<Employee> empQuery = from emp in empleados
                                 where emp.departamento == "IT"
                             select emp;

Los tipos más comunes en los que se puede grabar el resultado de LINQ, son IEnumerable<T> e IQueryable<T>, de todas maneras puede saltarse esta asignación, y utilizar, directamente la palabra reservada var:

var empQuery = from emp in empleados
               where emp.departamento == "IT"
              select emp;

Hay que tener en cuenta, que cuando se asigna la consulta LINQ a una variable sobre es eso, se guarda en la variable, pero no se ejecuta hasta que no se itera a través de la misma, por ejemplo con un bloque foreach

foreach (var emp in empQuery)
{
   Console.WriteLine(emp.departamento);
}

Otras maneras para que la consulta se ejecute, es usar algunas de las funciones de agregación: Count, Max, Average, First.

int cant = empQuery.Count();

También pueden utilizarse los métodos ToList<T> o ToArray<T> para ejecutar la consulta y guardar los resultados en una lista de objetos o en un array.

List<empleado> empQuery = (from emp in empleados
                          where emp.departamento == "IT"                                 select emp).ToList();


viernes, 21 de marzo de 2014

Aplicación ASP.NET MVC y ADO.NET Entity Framework


En esta entrega, realizaremos una primera aproximación al concepto de Entity Framework, para la creación de un modelo que nos permite efectuar tareas de ABMC: Altas, Bajas, Modificaciones y Consultas, o tal se conoce en idioma inglés operaciones CRUD.

El Entity Frameword de ADO.NET (EF) permite crear la capa de acceso a datos de una aplicación, abstrayendo los datos desde la base de datos y exponiendo un modelo mas cercano a los requerimientos de negocio de la aplicación. En el Framework 4.0 de NET, el EF ha sido considerablemente mejorado.

EF implementa el patrón ORM (Mapeo Objeto Relación), mediante el cual los objetos de la base de datos, se mapean con entidades del modelo conceptual de objetos.

Supondremos, que ya tenemos creada nuestra aplicación Web MVC, tal como vimos en entregas previas. 

Como primer paso, debemos crear un modelo de datos, que consistirá en una entidad "Empleado". Este modelo se encargará de realizar la comunicación con la base de datos para la gestión de los mismos.
Para esto, sobre la carpeta Models de nuestro proyecto, realizamos click con el botón derecho, y seleccionamos "Agregar Nuevo Elemento..."
Dentro del cuadro de dialogo, debemos seleccionar la opción Datos, y seleccionar "ADO.NET Entity Data Model".



Debemos determinar si en Entity Data Model , se creará a partir de una  base de datos, o crearemos un modelo vacío, para este caso, dado que ya tenemos la tabla en la base de datos, seleccionaremos la primera opción.



Seleccionamos la conexión a la base de datos, este paso producirá que se almacene dentro del Web.Config, los datos de la cadena de conexión, con el nombre que se determine.




Posteriormente seleccionamos los objetos que incluiremos en el modelo, dado que este será un ejemplo simple y básico, seleccionaremos la Tabla Empleados. Y le colocamos el nombre a nuestro modelo




Luego de este último paso, podremos observar que se creado nuestro Modelo Entidad Relación, dado que es un ejemplo extremadamente simple, vemos que se compone de una única clase.




Realizamos una generación del proyecto, para que se compilen las clases, y podamos relacionarla, con un Controlador, y las Vistas.

Posteriormente, sobre la carpeta "Controllers" Agregamos un nuevo Controlador, le colocamos el nombre, teniendo en cuenta de mantener el sufijo Controllers dentro de su nombre. También seleccionamos la clase del Modelo, y la clase del Contexto de Datos.



Al Agregar el controlador, con la plantilla seleccionado, se creará tanto el controlador, como las vistas que realizan las acciones de Crear / Editar / Borrar y Listar.

Si ejecutamos la aplicación y accedemos dentro de la URL inicial de la aplicación , a la carpeta Empleados, veremos el sistema en ejecución, el cual nos permitirá gestionar los datos de los empleados.

jueves, 20 de marzo de 2014

Estructura de una aplicación ASP.NET MVC

Analizaremos la estructura de carpetas de una aplicación ASP.NET MVC.


Creamos un nuevo Proyecto: ASP.NET MVC 4 Web Application, y lo colocamos un nombre al mismo, por ejemplo: MvcAppWeb.


En el Cuadro de Diálogo seleccionamos la plantilla "Internet Application", y el Motor de Vistas "Razor". También se da la posibilidad de crear un test de prueba unitario, pero por ahora lo dejamos deshabilitado.

De esta manera se habrá creado una aplicación web, la cual ya posee un contenido predefinido, el cual se irá editando para armar la solución deseada. De todas maneras, lo importante en este punto es analizar la estructura de la aplicación ASP.NET MVC.


La estructura de carpetas es igual en toda aplicación MVC (aunque puede ser que de acuerdo a la versión del framework MVC haya carpetas que no estén en una aplicación web), esta convención de nombres y carpetas hace más fácil al desarrollador entender los proyectos MVC.

La aplicación se compone de:

  • Carpetas de Información sobre la aplicación:
    • Properties
    • References
  • Carpetas propias de la aplicación:
    • App_Data: En esta carpeta se almacenan los datos de la aplicación, generalmente bases de datos de Microsoft SQL. Por defecto, al crear la aplicación esta carpeta esta vacía.
    • App_Start: Esta carpeta contiene los archivos de código que se ejecuta, para realizar todas las configuraciones necesarias, al iniciarse la aplicación.
    • Content: Carpeta usada para contenido estático, tal como hojas de estilos CSS, iconos, imágenes, temas.
    • Controllers: Los archivos de clases de controladores se alojan en esta carpeta. MVC requiere que todos los archivos de controladores finalicen con el texto "Controller". Los Controladores son aquellas clases que reciben las peticiones HTTP desde la Aplicación y realizan las gestiones correspondientes.
    • Filters: Carpeta en la cual se ubican los archivos de filtros. Los filtros son clases que permiten incluir comportamiento antes y después de las acciones de los controladores. De esta manera se puede añadir cierta funcionalidad a los controladores evitando reescribir la misma lógica una y otra vez.
    • Images: Esta carpeta contiene imágenes usadas por la aplicación. Debe tenerse en cuenta de que imágenes se alojarán en esta ubicación, ya que si las mismas son imágenes que hacen al aspecto visual de la aplicación deben ir en la carpeta Content, ya que se trata de contenido estático. Supongamos que tenemos una aplicación que muestra la foto de los empleados, dichas fotos se almacenarían en este directorio, ya que se trata de contenido dinámico que depende de los datos de la aplicación.
    • Models: Directorio, que contiene las clases que representan el modelo de la aplicación. Los Modelos son los encargador de manipular los datos de la aplicación.
    • Scripts: En esta carpeta se almacenan todos los archivos javascript (*.js). Es decir todo el código que se ejecuta en la parte del cliente.
    • Views: Aquí se encuentran alojados los archivos de Vistas, es decir todos los archivos relacionados con la "Interface de Usuario" de la aplicación. En la carpeta de Vistas, existe una carpeta por cada controlador existente en la aplicación. También dentro de esta se encuentra la carpeta Shared, la cual posee Vistas que serán reutilizadas en otras vistas, entre ellas _Layout.cshtml la cual posee un comportamiento similar a las MasterPages de los WebForms.
  • Archivos de Configuración:
    • Global.asax: Este archivo es la clase de entrada a nuestra aplicación, a partir del método Application_Start().
    • packages.config
    • web.config: es un archivo XML que posee toda la configuración de la aplicación.

miércoles, 19 de marzo de 2014

Aplicación MVC + Razor Simple

MVC, Modelo Vista Controlador, es un patrón de arquitectura de una aplicación, el cual define una clara separación entre la interfaz del usuario, y la capa de negocios de la aplicación. 
Como su nombre lo indica, las tres partes principales de este patrón son:

Controlador: Es el elemento encargo de recibir y procesar la peticiones HTTP, desde el usuario, y se encarga de comunicarse con el Modelo, para devolver la Vista correcta. Es el corazón del patrón, se encarga de coordinar la ejecución, generar el modelo y devolver la vista.
Modelo: Es la capa de datos y entidades de la aplicación.

Vista: Es la que recibe los datos del modelo, para representarlos visualmente.

La "Vista", como vimos en la entrada previa, puede ser renderizada en la forma clásica aspx, en Razor, o en otras formas más. Por lo tanto como último paso el motor de renderizado del ASP.NET MVC se encarga de traducir la vista, de acuerdo al View Engine utilizado para devolver al usuario los datos.

A continuación procedemos a crear una aplicación básica ASP.NET MVC utilizando el Motor de renderizado RAZOR.

a) CREAR LA APLICACION ASP.NET MVC

Dentro de Microsoft Visual Studio, se debe "Crear Nuevo Proyecto..."
Se selecciona dentro del árbol VISUAL C# -> Web, y se selecciona ASP.NET MVC 4 Web Application.
Se ingresa un nombre para el proyecto (.csproj), la ruta donde se guardaran los archivos, y un nombre para la solución(sln).


Posteriormente se debe seleccionar una plantilla, "Empty", y el View Engine "Razor".


Luego de haber creado el proyecto, se puede apreciar en el explorador de soluciones el grupo de carpetas y archivos que han sido creadas automáticamente.


b) CREAR UN MODELO

En el explorador de soluciones, click derecho sobre la Carpeta MODELS, Agregar -> Clase.



Se ingresa un nombre a la clase, para este ejemplo UsuarioModel.cs


Un Modelo es una Clase con propiedades. Las propiedades que definamos en el modelo deben estar de acuerdo a la Interface de Usuario.


c) CREAR UN CONTROLADOR

Se debe crear un controlador. En el explorador de soluciones, click derecho sobre la Carpeta CONTROLLERS, Agregar -> Controller.


Se le coloca el nombre teniendo en cuenta de dejar el sufijo controller


Se crear un controlador vacío, aunque ya es agregada por defecto el método de Acción "Index".


d) CREAR UNA VISTA

Para crear la Vista correspondiente al ActionResult Index, del Controlador UsuarioController, se debe hacer click con el botón derecho en el código correspondiente el método de Acción, y posteriormente hacer click en "Agregar Vista".



En el momento de crear la vista pueden definirse una seria de opciones, tales como el Motor de renderizado, se puede determinar si es una vista fuertemente tipada, es decir relacionada directamente a un modelo, en este caso la relacionamos al modelo creada previamente UsuarioModel.
También puede determinarse si se desea crear una vista vacía, una vista de detalle de datos, de alta de datos, de edición, de eliminación o de listado.
Por último puede determinarse el nombre de la master page, layout, la cual estaría alojada dentro de la carpeta Shared. Para este ejemplo en particular trabajeremos sin Layout Master.


Como puede verse se crea el código de la vista, con el renderizado Razor.


En este momento, si se inicia la aplicación, y accedemos dentro de nuestro servidor de desarrollo a la carpeta: http://localhost/Usuario (tal y como es el nombre del controlador) estariamos recuperando la Vista INDEX de dicho Controlador. Para el ejemplo, una página en blanco.

Ahora realizamos una serie de modificaciones en el código, primero dentro del controlador, realizamos una llamada al paquete Models de nuestra aplicación, y dentro del método de Acción de la llamada al Index, creamos una nueva instancia del Modelo Usuario, y se la pasamos a la Vista (dado que esta esta fuertemente tipada).

var usuarioModelo = new UsuarioModel() 
                {
                    IdUsuario=1,
                    Nombre="Sebastián",
                    Email="loquesea@gmail.com" 
                };
return View(usuarioModelo);


Y por último dentro del contenido de la vista, mostramos el nuevo usuario creado, por medio de una label para el titulo, y una caja de texto para el valor

    <div>
        @*Codigo Razor => Muestra el Nombre*@
        <span>@Html.LabelFor(m=>m.Nombre)</span>
        <span>@Html.TextBoxFor(m=>m.Nombre)</span>
  </div>


Si ahora se inicia nuevamente la aplicación, y accedemos dentro de nuestro servidor de desarrollo a la carpeta: http://localhost/Usuario, se observarán en acción los cambios realizados.

Hasta aquí esta primera aplicación simple en MVC con Motor RAZOR, más adelante iremos agregando funcionalidades extras, como conexiones a base de datos, Altas, Bajas, Consultas y Actualizaciones de datos.

Introducción al Motor de Vistas Razor

Una aplicación ASP.NET MVC, soporta diferentes Motores de Vistas (View Engine), los cuales definen la manera en que se estructura la página HTML.

Uno de estos motores de vistas, es el clásico .aspx/.ascx/.master  utilizado en los Web Forms de ASP.NET. 

Razor es un motor de vista, que permite embeber código C# dentro de una página, sin utilizar los delimitadores <%=%>. Los archivos basados en este motor de vistas, poseen la extensión .cshtml.



Bloque de Sentencia Simple.
Cada bloque de código debe comenzar con el símbolo @, y posteriormente debe ir encerrado entre llaves { } el código C# correspondiente.

@{ var mensaje = "Hola Mundo"; }
El Mensaje de esta página es : @mensaje







En este bloque se asigno a una variable una cadena de texto "Hola Mundo", posteriormente, fuera del bloque, dicha variable es accesible globalmente por medio del caracter @.


El Bloque anterior generaría una página HTML, la cual le muestra al usuario el texto:




El Mensaje de esta página es : Hola Mundo






Bloque de Múltiples Sentencias.



Cuando se trabaja con un grupo de sentencias, para generar un resultado, la forma de trabajar es exactamente igual que en el caso previo, pero teniendo en cuenta de finalizar cada línea con punto y coma.

@{
    var montoinicial = 100;
    var interes = 12;
    var montofinal = (montoinicial * interes) / 100;
}
Aplicando al monto inicial @montoinicial un interés del @interes % nos da como reresultado @montofinal





Condicionales.



Con el Motor de Vistas Razor, puede definirse un condicional dentro de bloque Razor o fuera del mismo, como puede observarse en el siguiente ejemplo.




@{
var esValido = true;
if(esValido)
{
    <p>Probando un Condicional dentro de bloque Razor, entrada positiva</p>
}
else
{
    <p>Probando un Condicional dentro de bloque Razor, entrada negativa</p>;
}
}






Bucles.


Puede incluirse dentro de una páginas ASP.NET MVC con Motor de Vistas RAZOR, los mismos bucles que se utilizan en la programación C#, es decir, for, while do while, foreach


@{ 

for(var cont=1, cont<=3, cont++) {
    <p>Contador es @cont</p>
}

string[] nombres = {"Juan","Jose","Maria"};
foreach(var nombre in nombres) {
    <p>El Nombre es @nombre</p>
}

var contador=1;
do {
  <p>Este es el paso @contador por el Bucle DO</p>
  contador++;
} while(contador<3);

}



Comentarios.


Existen 3 maneras de realizar comentarios en un bloque RAZOR, las dos primeras son las clásicas utilizadas por C#, es decir, anteponer a una línea los caracteres // o encerrar un bloque entre /* */.
Además de estas, RAZOR incluye la posibilidad de comentar un bloque de texto, encerrando el mismo entre los caracteres @*   *@.



Utilizar Objetos Propios del C#.


Anteponiendo siempre el caracter @, o bien encerrando código dentro de un bloque RAZOR, se puede acceder a los objetos, y sus propiedades, tal como puede verse en el siguiente ejemplo:

Hoy es @System.DateTime.Now.Date.ToString("D"), y la hora es @System.DateTime.Now



Hasta aquí esta breve introducción a Razor, la cual brinda las bases para comenzar a utilizar este motor de vistas.