Separar las entidades del negocio del modelo Entity Framework

En este post vamos a separar las entidades del negocio de nuestro modelo Entity Framework, para esto tenemos nuestro ejemplo:

En nuestro ejemplo tenemos una capa de Entidades y una de Acceso a Datos, en esta última tenemos un modelo de Entity Framework

Vamos a ubicar las entidades POCO en nuestra capa de entidades
para eso necesitamos tener instalada la extención: EF 5.x DbContext Generator

que podemos descargar de aquí: https://visualstudiogallery.msdn.microsoft.com/da740968-02f9-42a9-9ee4-1a9a06d896a2

en Entidades: click derecho -> Agregar -> Nuevo Elemento

esto agregará el archivo: Model1.tt

hacemos doble click en este

y reemplazamos: $edmxInputFile$ por la referencia a nuestro modelo EF

Ahora podemos eliminar el Archivo *.tt de la capa de acceso a datos

Y por último en nuestra capa de acceso a datos seleccionamos nuestro archivo *.Context.tt y cambiamos el espacio de nombres de la herramienta personalizada. Haciendo referencia al proyecto de entidades:

En el caso que necesitemos actualizar nuestro modelo, por ejemplo agregar una nueva tabla, tenemos que hacer doble click en el archivo *.tt (En nuestro caso Model1.tt) del proyecto de entidades y seleccionamos la opción: «Ejecutar herramienta personalizada»

Delegados C#

Un delegado es un tipo que representa referencias a métodos con una lista de parámetros determinada y un tipo de valor devuelto.

Los delegados se utilizan para pasar métodos como argumentos a otros métodos. Los controladores de eventos no son más que métodos que se invocan a través de delegado

Supongamos que tenemos el siguiente método Sumar

 public static int Sumar(int numeroA, int numeroB)
 {
 return numeroA + numeroB;
 }

 

Vamos a declarar nuestro delegado

public delegate int MiDelegado(int numeroA, int numeroB);

Como podemos ver la firma de nuestro delegado coincide con nuestro método Sumar, su tipo de retorno es entero y recibe como parámetro dos enteros

Ahora nosotros podemos crear objetos del tipo de nuestro delegado

MiDelegado miDelegado = new MiDelegado(Sumar);

y la invocación la hacemos de la siguiente forma

 int resultado = miDelegado.Invoke(10, 5);

 int resultado = miDelegado(10, 5);

en este último caso el compilador convierte miDelegado(10, 5) en miDelegado.Invoke(10, 5)

 

 class Program
 {
 public delegate int MiDelegado(int numeroA, int numeroB);

 static void Main(string[] args)
 {

 MiDelegado miDelegado = new MiDelegado(Sumar);
 int resultado = miDelegado(10, 5);

 }
 
 public static int Sumar(int numeroA, int numeroB)
 {
 return numeroA + numeroB;
 }
}

 

Métodos extensores (Extension)

Los métodos extensores nos permiten agregar métodos a los tipos existentes sin crear un nuevo tipo derivado. Estos son una clase especial de método estático con la diferencia que los podemos llamar como si fueran métodos de instancia en el tipo extendido Vamos a ver un ejemplo: supongamos el caso de que tenemos las siguiente clases:

 public class Producto
    {
        public string Nombre { get; set; }
        public decimal Precio { get; set; }
        public string Categoria { get; set; }
    }

    class Carrito
    {
        public List<Producto> ListaProductos { get; set; }        
    }

Y queremos agregar un método, pero no podemos modificarla. Para eso vamos a crear nuestra clase «Extension»

 static class Extension
    {
        public static decimal ObtenerTotal(this Carrito carrito)
        {
            decimal total = 0;
            foreach (var producto in carrito.ListaProductos)
            {
                total = total + producto.Precio;
            }
            return total;
        }
    }

Nuestro método itera sobre cada uno de los productos de la propiedad ListaProductos y calcula el Total sumando el precio de cada uno de estos. Como podemos ver nuestro método está definido en una clase estática El primer parámetro del método especifica el tipo en el que funciona el método, en nuestro caso: Carrito, este debe estar precedido del modificador this.

            var fideo = new Producto { Precio = 12, Categoria = "Alimentos" };
            var azucar = new Producto { Precio = 50, Categoria = "Alimentos" };
            var arroz = new Producto { Precio = 6, Categoria = "Alimentos" };
            var carrito = new Carrito { ListaProductos = new List<Producto> { fideo, azucar, arroz } };

y en la siguiente imagen vemos como podemos usar nuestro método extensor: ObtenerTotal como si fuera un método de instancia de la clase Carrito

Certifications: Skills measured by Exam 70-316

Skills measured by Exam 70-316 Course 2389B Course 2555
Creating user services
Create a Windows Form by using the Windows Forms Designer.
•
Add and set properties on a Windows Form.
•
Create a Windows Form by using visual inheritance.
•
Build graphical interface elements by using the System.Drawing namespace.

Add controls to a Windows Form.
•
Set properties on controls.
•
Load controls dynamically.
•
Write code to handle control events and add the code to a control.
•
Instantiate and invoke an ActiveX control.
•
Configure control licensing.
•
Create menus and menu items.

Implement navigation for the user interface (UI).
•
Configure the order of tabs.

Validate user input.
•
Validate non-Latin user input.

Implement error handling in the UI.
•
Create and implement custom error messages.
•
Create and implement custom error handlers.
•
Raise and handle errors.

Implement online user assistance.

Display and update data.
•
Transform and filter data.
•
Bind data to the UI.

Instantiate and invoke a Web service or component.
•
Instantiate and invoke a Web service.
•
Instantiate and invoke a COM or COM+ component.
•
Instantiate and invoke a .NET component.
•
Call native functions by using platform invoke.

Implement globalization.
•
Implement localizability for the UI.
•
Convert existing encodings.
•
Implement right-to-left and left-to-right mirroring.
•
Prepare culture-specific formatting.

Create, implement, and handle events.

Implement print capability.

Implement accessibility features.

Creating and managing components and .NET assemblies
Create and modify a .NET assembly.
•
Create and implement satellite assemblies.
•
Create resource-only assemblies.

Create a Windows control.
•
Create a Windows control by using visual inheritance.
•
Host a Windows control inside Microsoft Internet Explorer.

Consuming and manipulating data
Access and manipulate data from a Microsoft SQL Server database by creating and using ad hoc queries and stored procedures.

Access and manipulate data from a data store. Data stores include relational databases, XML documents, and flat files. Methods include XML techniques and ADO .NET.

Handle data errors.

Testing and debugging
Create a unit test plan.

Implement tracing.
•
Add trace listeners and trace switches to an application.
•
Display trace output.

Debug, rework, and resolve defects in code.
•
Configure the debugging environment.
•
Create and apply debugging code to components and applications.
•
Provide multicultural test data to components and applications.
•
Execute tests.
•
Resolve errors and rework code.

Deploying a Windows-based application
Plan the deployment of a Windows-based application.
•
Plan a deployment that uses removable media.
•
Plan a Web-based deployment.
•
Plan a network-based deployment.
•
Ensure that the application conforms to Windows Installer requirements and Windows Logo Program requirements.

Create a setup program that installs an application and allows for the application to be uninstalled.
•
Register components and assemblies.
•
Perform an install-time compilation of a Windows-based application.

Deploy a Windows-based application.
•
Use setup and deployment projects.

Add assemblies to the Global Assembly Cache.

Verify security policies for a deployed application.
•
Launch a remote application (URL remoting).

Maintaining and supporting a Windows-based application
Optimize the performance of a Windows-based application.

Diagnose and resolve errors and issues.

Configuring and securing a Windows-based application
Configure a Windows-based application.

Configure security for a Windows-based application.
•
Select and configure authentication type. Authentication types include Windows authentication, none, forms-based, Windows Live ID (formerly Microsoft Passport), and custom authentication.
•
Specify the security level for an application.
•
Use custom attributes to configure security.

Configure authorization.
•
Configure role-based authorization.
•
Implement identity management.

Pipes en c#

Las Pipes son un medio de comunicación entre procesos. Existen dos tipos de Pipes:

Pipes anónimos.

Los Pipes anónimos permiten la comunicación entre procesos en un equipo local. Los Pipes anónimos ofrecen servicios limitados pero requieren menos esfuerzo que los Named Pipes. Los Pipes anónimos son unidireccionales y no se pueden utilizar a través de una red. Sólo admiten una instancia de servidor única. Son útiles para la comunicación entre subprocesos o entre procesos primarios y secundarios

Pipes con nombre (Named Pipes).

Los Named pipes permiten la comunicación entre procesos entre un servidor de canalización y uno o varios clientes de canalización. pueden ser unidireccionales o dúplex. Admiten la comunicación mediante mensajes y permiten que varios clientes se conecten simultáneamente al proceso de servidor utilizando el mismo Named Pipe. También admiten la suplantación, que permite a los procesos que se conectan utilizar sus propios permisos en servidores remotos.

vamos a ver un sencillo ejemplo

using System;
using System.Text;
using System.IO.Pipes;

namespace PipeServer
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Esperando conexión");
            while (true)
            {
                var namedPipeServerStream = new NamedPipeServerStream("MundoNetPipe");
                namedPipeServerStream.WaitForConnection();
                byte[] buffer = new byte[255];
                namedPipeServerStream.Read(buffer, 0, 255);
                string request = ASCIIEncoding.ASCII.GetString(buffer);
                Console.WriteLine(request);
                request=request.Trim('\0');
                if(request.ToLower()=="cerrar")
                    break;
                namedPipeServerStream.Close();
            }
            Console.WriteLine("Fin");
            Console.ReadLine();
        }
    }
}

using System;
using System.Text;
using System.IO.Pipes;

namespace PipeCliente
{
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                var clienteStream = new NamedPipeClientStream("MundoNetPipe");
                clienteStream.Connect(60);
                Console.WriteLine("Escribe un Mensaje");
                string line = Console.ReadLine();
                if (line.ToLower() == "salir")
                    break;
                byte[] buffer = ASCIIEncoding.ASCII.GetBytes(line);
                clienteStream.Write(buffer, 0, buffer.Length);
                clienteStream.Close();
            }
        }
    }
}

Son dos aplicaciones de Consola, una para asumir el papel de Servidor y la otra el de Cliente, el Servidor solo espera en un bucle y cuando se establece una conexión con el cliente, el servidor se hace eco de los datos del cliente en la consola

como vemos en la imagen lo que escribimos en consola en la aplicación cliente se escribe en la consola de la aplicación servidor

Además:

Si ingresamos la palabra «salir» se haría un break al bucle while

 if (line.ToLower() == "salir")
 break;

Y el cliente abandonaría el canal de comunicación

clienteStream.Close();

Si se ingresa la palabra «cerrar» el servidor cerraría el canal de comunicación

 if(request.ToLower()=="cerrar")
                    break;
 namedPipeServerStream.Close();

Threading en C#

Un hilo de ejecución es la unidad de procesamiento más pequeña que puede ser planificada por un sistema operativo.
La creación de un nuevo hilo es una característica que permite a una aplicación realizar varias tareas a la vez (concurrentemente). Los distintos hilos de ejecución comparten una serie de recursos tales como el espacio de memoria, los archivos abiertos, situación de autenticación, etc. Esta técnica permite simplificar el diseño de una aplicación que debe llevar a cabo distintas funciones simultáneamente.
Un hilo es básicamente una tarea que puede ser ejecutada en paralelo con otra tarea.

using System;
using System.Threading;

namespace Threads
{
    class Program
    {
        static void Main(string[] args)
        {
            var t = new Thread(Write);
            t.Start();
            Console.ReadLine();
        }

        static void Write()
        {
            for (int i = 0; i < 1500; i++)
            {
                Console.WriteLine("x");
            }
        }
    }

}

En el sencillo ejemplo creamos un tread pasandole como parámetro un método que se ejecutara en otro hilo de ejecución.

var t = new Thread(Write);

Iniciamos el mismo:

t.Start();

ahora vamos a ver cómo es esto de dos hilos de ejecución, mientras se ejecuta el método Write en otro hilo, sigue ejecutándose el método Main

using System;
using System.Threading;

namespace Threads
{
    class Program
    {
        static void Main(string[] args)
        {
            var t = new Thread(Write);
            t.Start();
            for (int i = 0; i < 150; i++)
            {
                Console.Write("a");
            }
            Console.WriteLine("Mundo .NET");
            Console.ReadLine();
        }

        static void Write()
        {
            for (int i = 0; i < 150; i++)
            {
                Console.Write("b");
            }
        }
    }

}

el siguiente es el resultado de la ejecución del código anterior:

Ahora vamos a ver un ejemplo del uso del método. JOIN, este método indica que se debe esperar a que termine la ejecución del thread antes de continuar

using System;
using System.Threading;

namespace Threads
{
    class Program
    {
        static void Main(string[] args)
        {
            var t = new Thread(Write);
            t.Start();
            t.Join();
            
            for (int i = 0; i < 150; i++)
            {
                Console.Write("a");
            }

            Console.WriteLine("Mundo .NET");
            Console.ReadLine();
        }

        static void Write()
        {
            for (int i = 0; i < 150; i++)
            {
                Console.Write("b");
            }
        }
    }
}

Como vemos en la imagen se ejecuta el método Write que escribe en la consola la letra: b y al terminar la ejecución de este continúa recién ahí la ejecución del métod Main con el bucle for que tiene como única línea la que escribe en consola la lerta a

Expresiones de consulta LINQ

Una expresión de consulta comienza con la palabra clave from luego debemos utilizar una variable de rango.
Una variable de rango representa cada elemento sucesivo de la secuencia de origen mientras esta se recorre
La variable de rango está fuertemente tipada, basada en el tipo de elementos del origen de datos, esto quiere decir que se puede utilizar el operador punto para acceder a cualquier miembro disponible del tipo

veamos un ejemplo

vamos a consultar la Tabla Clientes de la Base Prueba:

Para ello vamos a agregar un modelo Entity Framework

click derecho sobre el proyecto en el explorador de soluciones, seleccionar la opción agregar y luego: nuevo elemento:

Seleccionar la opción Generar desde la base de datos

Click en: Nueva Conexión

Ingresar el nombre del servidor, seleccionar la base de datos y hacer click en Aceptar

Presionar Siguiente

Seleccionar los objetos de la base de datos que queremos incluir en nuestro modelo

En nuestro caso seleccionamos solo la tabla Clientes:

ahora si podemos hacer nuestras consultas…

  public IEnumerable<Clientes> Listar()
        {
            var contexto = new Contexto();
            var query = from c in contexto.Clientes select c;
            return query;
        }

De esta forma listamos todos los clientes de nuestra entidad Clientes,como vemos se usa la variable de rango «c» y como se dijo antes, esta variable está fuertemente tipada, entonces vamos a utilizar el operador punto «.» para acceder a sus atributos

 public IEnumerable<Clientes> Buscar(string apellido)
        {
            var contexto = new Contexto();
            var query = from c in contexto.Clientes 
                        where c.Apellido==apellido select c;
            return query;
        }

De esta forma obtenemos los clientes cuyos apellidos coincidan con el apellido recibido por parámetro.
Ahora vamos a ver algunas cosas interesantes que podemos hacer…

Por ejemplo de esta forma obtenemos los clientes cuyos Apellidos contengan el valor recibido en el parámetro apellido

var query = from c in contexto.Clientes where c.Apellido.Contains(apellido) select c;

para nuestra tabla:

si pasamos como parámetro «Marchetti» devolverá el cliente

Los clientes con apellidos que comiencen con el valor de parámetro apellido:

 var query = from c in contexto.Clientes where c.Apellido.StartsWith(apellido) select c;

Además podemos personalizar nuestras consultas como nos parezca:

 public IEnumerable Buscar(string apellido)
        {
            var contexto = new Contexto();
            var query = from c in contexto.Clientes 
                        where c.Apellido==apellido 
                        select new
                            {
                                Datos=c.Apellido+", "+c.Nombre
                            };
            return query;
        }

Helpers MVC 3

Creamos un nuevo proyecto de aplicación web asp.net MVC 3 y lo nombramos Prueba_Helpers

creamos una carpeta llamada Entidades dentro de la carpeta Models
en esta carpeta agregamos una clase y le ponemos el nombre: Usuarios.cs

namespace Prueba_Helpers.Models.Entidades
{
    public class Usuarios
    {
        public string Apellido { get; set; }
        public string Nombre { get; set; }
        public int Edad { get; set; }
    }
}

en la carpeta Models agregamos una clase y la nombramos GestionUsuarios.cs

using System.Collections.Generic;
using Prueba_Helpers.Models.Entidades;

namespace Prueba_Helpers.Models
{
    public class GestionUsuarios
    {
        public List<Usuarios> Listar()
        {
            var usuario1 = new Usuarios { Apellido = "Marchetti", Nombre = "Javier", Edad = 29 };
            var usuario2 = new Usuarios { Apellido = "Perez", Nombre = "Juan", Edad = 12 };
            var usuario3 = new Usuarios { Apellido = "Lopez", Nombre = "Diego", Edad = 50 };

            var lista = new List<Usuarios> { usuario1, usuario2, usuario3 };

            return lista;
        }
    }
}

En nuestra carpeta Controllers agregamos un nuevo controlador: UsuariosController.cs

using System.Web.Mvc;
using Prueba_Helpers.Models;

namespace Prueba_Helpers.Controllers
{    
    public class UsuariosController : Controller
    {
        public ActionResult Listar()
        {
            var gestionUsuarios = new GestionUsuarios();
            var listaUsuarios=gestionUsuarios.Listar();
            return View(listaUsuarios);
        }
    }
}

y agregamos la vista que devolverá el Action: «Listar»

Ahora llegó el momento de los Helpers

la sintaxis es la siguiente:

@helper IdentificadorHelper(parametros) { ... }

estos encapsulan bloques de código html y de servidor reutilizables

podemos crear helpers en una vista o algo más interesante, para poder usarlos en todas las vistas de nuestras aplicación…

Vamos a crear una carpeta llamada App_Code, dentro de esta agredamos un archivo con el nombre: HelperFile y en este agregamos nuestro helper:

@helper MostrarEdad(int edad)
    {
        if (edad > 21)
        {
    <span>Mayor </span>
        }
        else
        {
    <span>Menor </span>
        }
}

ahora en nuestra vista:

@using Prueba_Helpers.Models.Entidades
@model List<Usuarios>
@foreach (var usuario in Model)
{
    <span>
        @usuario.Apellido
    </span>    
    <span>
        @usuario.Nombre
    </span>
    @HelperFile.MostrarEdad(usuario.Edad)
    <br />
}

como vemos usamos nuestro helper haciendo referencia a HelperFile que es el archivo donde está el mismo y le pasamos como parámetro la edad

@HelperFile.MostrarEdad(usuario.Edad)

EditorForModel

este interesante «Helper» devuelve un elemento input HTML para cada propiedad del modelo

@Html.EditorForModel()

creamos un nuevo proyecto de aplicación web de ASP.NET MVC 3 y lo nombramos: Ejemplo_EditorForModel

Creamos una nueva clase en la carpeta Models (haciendo click derecho sobre la misma y seleccionando agregar y luego clase) nombramos a esta: Clientes

Agregamos a esta tres propiedades:
Apellido, Nombre, Tel

namespace Ejemplo_EditorForModel.Models
{
    public class Clientes
    {
        public string Apellido { get; set; }
        public string Nombre { get; set; }
        public string Tel { get; set; }
    }
}

Agregamos un controlador a nuestra carpeta Controllers

Agregamos un Action a nuestro controlador llamado Editar

using System.Web.Mvc;

namespace Ejemplo_EditorForModel.Controllers
{
    public class ClientesController : Controller
    {
        public ActionResult Editar()
        {
            return View();
        }
    }
}

Hacemos click derecho sobre View y seleccionamos la opción Agregar Vista

@model Ejemplo_EditorForModel.Models.Clientes
           
@{
    ViewBag.Title = "Editar";
}

<h2>Editar</h2>

@Html.EditorForModel()

Ejecutamos nuestra aplicación y vemos cómo se genera un Input con su correspondiente etiqueta por cada una de las propiedades del modelo

$.Load()

Realiza una request al servidor y carga el html devuelto en el elemento que se indique:

$.load
( url,
[data],
[complete(responsEnlaceeText, textStatus,XMLHttpRequest)]
)

url: Cadena de caracteres que contiene la URL del archivo que se envía.

data: Cadena de caracteres que contiene la respuesta del servidor.

complete: (responseText, textStatus, XMLHttpRequest) Funcion que se ejecuta cuando la solicitud se completó.

Ejemplo:

$("#divContenedor").load("pagina2.html");

vamos a demostrar como funciona en una pequeña aplicación con MVC

Click derecho en la carpeta Models
Seleccionar la opción Agregar
Seleccionar Clase
cambiar el nombre por Usuarios.cs

namespace Prueba_MVC3.Models
{
    public class Usuarios
    {
        public string Apellido { get; set; }

        public string Nombre { get; set; }
    }
}

Agregar un nuevo controlador en la carpeta: Controllers. Llamamos a este: UserController

Agregamos en nuestro controlador el siguiente Action:

   public ActionResult ListarUsuarios()
        {
            var usuario1 = new Usuarios { Apellido = "Marchetti", Nombre = "Javier" };
            var usuario2 = new Usuarios { Apellido = "Perez", Nombre = "Juan" };
            var usuario3 = new Usuarios { Apellido = "Diehl", Nombre = "Russell" };

            var listaUsuarios = new List<Usuarios> { usuario1, usuario2, usuario3 };
           
            return PartialView();
        }

Agregar una vista parcial, haciendo click derecho sobre PartialView y seleccionando la opción agregar vista, como muestra la imagen siguiente:

Chequear la opción Crear como vista parcial

cambiar el nombre de la vista por: ListarUsuarios y presionar Agregar

pasar como parámetros al método PartialView:

El nombre de la vista parcial: «ListarUsuarios»
y la lista: listaUsuarios

el action quedaría de la siguiente manera:

     public ActionResult ListarUsuarios()
        {
            var usuario1 = new Usuarios { Apellido = "Marchetti", Nombre = "Javier" };
            var usuario2 = new Usuarios { Apellido = "Perez", Nombre = "Juan" };
            var usuario3 = new Usuarios { Apellido = "Diehl", Nombre = "Russell" };

            var listaUsuarios = new List<Usuarios> { usuario1, usuario2, usuario3 };
           
            return PartialView("ListarUsuarios",listaUsuarios);
        }

el controlador completo:

using System.Web.Mvc;
using Prueba_MVC3.Models;
using System.Collections.Generic;

namespace Prueba_MVC3.Controllers
{
    public class UserController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }
        
        public ActionResult ListarUsuarios()
        {
            var usuario1 = new Usuarios
                {
                    Apellido = "Marchetti", Nombre = "Javier"
                };
            var usuario2 = new Usuarios
                {
                    Apellido = "Perez", Nombre = "Juan"
                };
            var usuario3 = new Usuarios
                {
                    Apellido = "Diehl", Nombre = "Russell"
                };

             var listaUsuarios = new List<Usuarios>
                {
                    usuario1, usuario2, usuario3
                };
           
            return PartialView("ListarUsuarios",listaUsuarios);
        }
    }

modificar la vista parcial de la siguiente manera:

@using System.Collections
@model IEnumerable<Prueba_MVC3.Models.Usuarios>
@foreach (var usuario in Model)
{
    <div>
        <p>@usuario.Apellido</p>
        <p>@usuario.Nombre</p>        
    </div>       
}

en la vista: Index agregar un enlace:

<a id="Listar" href="#" onclick="Listar()">Listar</a>

un div llamado: «divContenedor»

<div id="divContenedor"></div>

y en la sección de scripts la función Listar:

<script type="text/javascript">
    function Listar() {
        $("#divContenedor").load("../User/ListarUsuarios");
    }
</script>

quedaría de la siguiente manera:

@{
    ViewBag.Title = "Index";
}
<h2>Index</h2>

<a id="Listar" href="#" onclick="Listar()">Listar</a>
<br/>
<div id="divContenedor"></div>

<script type="text/javascript">
    function Listar() {
        $("#divContenedor").load("../User/ListarUsuarios");
    }
</script>

en esta función es donde usaremos nuestro $.Load()

$("#divContenedor").load("../User/ListarUsuarios");

esta cargará el contenido html de la respuesta del servidor a la petición (que es controlada por el Action: ListarUsuarios del Controlador: User) en el divContenedor

vamos a probar…

Ejecutamos nuestra aplicación (F5)

en la barra de direcciones colocamos la url correspondiente: http://localhost:xxxx/User/Index

presionamos sobre nuestro enlace Listar