Freddy Alday Sfarcic-Ncapas

Introducción al desarrollo de aplicaciones
N-Capas con tecnologías Microsoft

Manual de estudiante
Introducción al
desarrollo de
aplicaciones N-Capas
con tecnologías
Microsoft
Primera edición
Junio de 2018
Soporte técnico:
soporte@mail.ticapacitacion.com
Este manual fue creado por TI Capacitación para uso personal de:
Freddy Alday Sfarcic

falday@hotmail.com
1 https://ticapacitacion.com/curso/ncapas
Contenido
Acerca del curso ........................................................................................................................... 4
Audiencia ..........................................................................................................................................4
Objetivos ..........................................................................................................................................4
Requerimientos ................................................................................................................................5
Contenido del curso .........................................................................................................................5
Módulo 1: La Arquitectura N-Capas ............................................................................................... 7
Acerca del módulo ...........................................................................................................................8
Objetivos ..........................................................................................................................................8
Lección 1 Definición de conceptos ......................................................................................................9
Objetivos de la lección .....................................................................................................................9
Arquitectura basada en capas ....................................................................................................... 10
Comunicación entre las capas de la arquitectura N-Capas ........................................................... 13
Capas Vs Niveles (Layers Vs Tiers) ................................................................................................. 18
Módulo 2: Desarrollando una aplicación N-Capas ........................................................................ 23
Acerca del módulo ........................................................................................................................ 24
Objetivos ....................................................................................................................................... 24
Lección 1 Creando la capa de datos con SQL Server ........................................................................ 26
Objetivos de la lección .................................................................................................................. 26
Laboratorio Creando la base de datos con Microsoft SQL Server Management Studio .............. 27
Laboratorio Creando la base de datos con la herramienta Server Explorer de Visual Studio ..... 31
Laboratorio Creando el diagrama Entidad-Relación .................................................................... 37
Lección 2 Creando la capa de Entidades y Acceso a Datos con Entity Framework.......................... 41
Laboratorio Creando la capa de Acceso a Datos .......................................................................... 42
Laboratorio Creando la capa de entidades .................................................................................. 50
Laboratorio Definiendo la interface del patrón Repositorio ........................................................ 54
Laboratorio Implementando la interface del patrón Repositorio ................................................ 57
Laboratorio Probando la Capa de Acceso a Datos ....................................................................... 61
Lección 3 Creando la capa de Lógica de negocios ............................................................................ 67
Freddy Alday Sfarcic (falday@hotmail.com)

Laboratorio Creando la Capa de Lógica de Negocio .................................................................... 68
Lección 4 Creando la capa de Servicio utilizando Web API .............................................................. 72
Laboratorio Creando el contrato del servicio............................................................................... 73
Laboratorio Implementando el servicio ....................................................................................... 75
Laboratorio Probando el servicio ................................................................................................. 79
Lección 5 Creando la capa de Presentación ..................................................................................... 85
Laboratorio Creando una biblioteca Proxy .................................................................................. 86
Laboratorio Creando una aplicación MVC.................................................................................... 90
Laboratorio Creando una aplicación WPF .................................................................................. 106
Laboratorio Creando el elemento ViewModel........................................................................... 109
Laboratorio Probando la aplicación WPF ................................................................................... 116
Laboratorio Creando una aplicación Xamarin.Forms ................................................................. 121
Laboratorio Configurando el servicio ......................................................................................... 128
Laboratorio Probando la Aplicación Xamarin.Forms ................................................................. 131
Resumen .................................................................................................................................. 134
Acerca del curso

Este entrenamiento tiene como objetivo mostrar al participante una forma sencilla de implementar la
arquitectura N-Capas (N-Layers) y N-Niveles (N-Tiers) utilizando herramientas y tecnologías Microsoft.
No se pretende enseñar al participante cada uno de los patrones existentes alrededor de esta
arquitectura ya que se necesitaría más de un curso para lograrlo.
Este entrenamiento, se enfoca en ejemplificar la forma de utilizar Visual Studio con productos y
tecnologías como SQL Server, Entity Framework, ASP.NET Web API, ASP.NET MVC, UWP y Xamarin
para crear aplicaciones N-Capas y N-Niveles.
El entrenamiento inicia describiendo los conceptos N-Capas y N-Niveles para posteriormente describir
sus características y razones para utilizar N-Capas o N-Niveles en el desarrollo de aplicaciones.
Al finalizar este entrenamiento, los participantes tendrán las bases para empezar a desarrollar
aplicaciones N-Capas y N-Niveles.
Audiencia
Este entrenamiento está dirigido principalmente a desarrolladores con experiencia en el desarrollo de
aplicaciones .NET con acceso a base de datos.
Para un mejor aprovechamiento de este entrenamiento, se recomienda que los participantes cuenten
con conocimientos básicos sobre las herramientas y tecnologías que serán utilizadas durante este
entrenamiento, tales como:
• Visual Studio
• Visual C#
• SQL Server
• Entity Framework
• ASP.NET MVC
• ASP.NET Web API
• WPF
• UWP
• Xamarin
Objetivos
Al finalizar este entrenamiento, los participantes contarán con las habilidades y conocimientos para:
• Definir los conceptos N-Capas (N-Layers) y N-Niveles (N-Tiers).

• Describir las características de la Arquitectura N-Capas.
• Describir los escenarios en los cuales es conveniente utilizar el modelo N-Capas.
• Aplicar el modelo N-Capas para el desarrollo de diferentes tipos de aplicaciones.

• Utilizar Visual Studio con productos y tecnologías como SQL Server, Entity Framework,
ASP.NET Web API, ASP.NET MVC, Windows Presentation Foundation, UWP y Xamarin para
crear aplicaciones N-Capas y N-Niveles.
Requerimientos
Para poder realizar las prácticas de este entrenamiento, se recomienda contar con lo siguiente:
• Sistema Operativo Windows 10.
• Visual Studio 2017.

• SQL Server 2016 o posterior.
Los ejemplos de este entrenamiento fueron realizados sobre Windows 10 Pro, Visual Studio Enterprise
2017 y SQL Server 2017.
Contenido del curso

El contenido de este entrenamiento consta de 2 módulos.
Módulo 1. La Arquitectura N-Capas
En este módulo se describen los conceptos N-Capas y N-Niveles, así como la diferencia existente entre
ellos. Se describen también las características y razones para utilizar N-Capas o N-Niveles en el
desarrollo de aplicaciones.
Al finalizar este módulo, los participantes podrán:
• Describir los conceptos N-Capas y N-Niveles.

• Identificar aplicaciones N-Capas y aplicaciones N-Niveles.
• Identificar las capas típicas de la mayoría de las aplicaciones N-Capas.
• Describir los escenarios en los cuales es conveniente utilizar la Arquitectura N-Capas.
El tema que forma parte de este módulo es:
• Lección 1: Definición de conceptos.
Módulo 2. Desarrollando una aplicación N-Capas
En este módulo se aplican los conceptos teóricos descritos en el módulo anterior para desarrollar una
aplicación en la cual se implementa la Arquitectura N-Capas.
• Crear la capa de origen de datos utilizando Microsoft SQL Server.

• Crear la capa de Acceso a datos utilizando Entity Framework.

• Crear la capa de Entidades utilizando una biblioteca de clases .NET Standard.
• Crear la capa de Lógica de Negocios.
• Crear la capa de Servicio utilizando ASP .NET Web API.
• Crear la capa de Presentación con una Aplicación ASP.NET MVC.
• Crear la capa de Presentación con una Aplicación Windows Presentation Foundation.
• Crear la capa de Presentación con una Aplicación Xamarin.Forms.
Los temas que forman parte de este módulo son:
• Lección 1: Creando la capa de datos con SQL Server.

• Lección 2: Creando la capa de Entidades y Acceso a Datos con Entity Framework.
• Lección 3: Creando la capa de Lógica de Negocios.
• Lección 4: Creando la capa de Servicio utilizando ASP.NET Web API.
• Lección 5: Creando la capa de Presentación.
Introducción al
desarrollo de
con tecnologías
Microsoft
Modulo 1: La Arquitectura N-Capas
Acerca del módulo

En este módulo se describen los conceptos N-Capas y N-Niveles, así como la diferencia existente entre
Objetivos
Al finalizar este módulo, los participantes contarán con las habilidades y conocimientos para:
El tema que se cubre en este módulo es:

• Lección 1: Definición de conceptos.
Lección 1
Definición de conceptos
Antes de empezar con la demostración del desarrollo de aplicaciones con la arquitectura basada en
Capas, es importante definir algunos de los conceptos relacionados con dicha arquitectura.
En esta lección se describen los conceptos N-Capas y N-Niveles, así como la diferencia existente entre
Objetivos de la lección
Al finalizar esta lección, los participantes contarán con las habilidades y conocimientos para:

Arquitectura basada en capas

La arquitectura basada en capas se enfoca principalmente en el agrupamiento de funcionalidad
relacionada dentro de una aplicación en distintas capas que son colocadas verticalmente una encima
de otra, la funcionalidad dentro de cada capa se relaciona con un rol o responsabilidad especifica.
El dividir en capas una aplicación, permite la separación de responsabilidades lo que proporciona una
mayor flexibilidad y un mejor mantenimiento.
Por ejemplo, en una aplicación con una capa de presentación, una capa de lógica y una capa de acceso
a datos, la responsabilidad de la capa de presentación es la de interactuar con el usuario, solicitando y
proporcionando la información que el usuario requiere.
La responsabilidad de La capa de Lógica de negocio es la de hacer cumplir las reglas de negocio o
requerimientos de la aplicación mientras que la responsabilidad de la Capa de acceso a datos es la de
recuperar y modificar datos del origen de datos.
Supongamos que tenemos un sistema de ventas:
1. La capa de presentación solicita el ID del producto que el usuario desea comprar y se lo

proporciona a la capa de lógica de negocio.
2. La capa de lógica de negocio debe verificar si aún hay existencias del producto requerido por
el usuario y para esto solicita los datos del producto a la capa de acceso a datos pasándole el
ID del producto a buscar.
3. La capa de acceso a datos busca la información del producto en la fuente de datos y lo devuelve
a la capa de lógica de negocio.
4. Con los datos recibidos, la capa de lógica de negocio determina si el producto puede ser
vendido o no y proporciona la respuesta de la consulta a la capa de presentación.
5. La capa de presentación muestra al usuario la respuesta que la capa de lógica le ha

proporcionado.
En la siguiente imagen podemos ver el flujo completo entre las distintas capas de este
ejemplo.
Objetivo de la Arquitectura basada en capas

El objetivo principal de la arquitectura basada en capas es el de estructurar una aplicación para
soportar requerimientos operacionales complejos y disponer de una buena reusabilidad, escalabilidad,
flexibilidad, seguridad, robustez y un fácil mantenimiento. Por ejemplo, supongamos que una empresa
nos solicita una aplicación Windows y nosotros la diseñamos con una arquitectura basada en capas.
Cuando la empresa necesite escalar la aplicación para dar soporte a usuarios en la Web, la arquitectura
flexible nos permitirá dar un mantenimiento fácil a nuestra aplicación añadiendo una capa de
presentación mediante el desarrollo de una aplicación Web y reutilizando las demás capas actuales sin
necesidad de realizar un solo cambio en ellas.
Comunicación entre las capas de la arquitectura N-Capas

Veamos un ejemplo de algunas de las posibles capas en las que puede estar dividida una aplicación.
Capa de datos
La capa de datos es básicamente el servidor que almacena los datos de una aplicación, por ejemplo,
un sistema externo que expone sus datos mediante un servicio web, un servidor que ejecuta SQL
Server o el servicio SQL DataBase de Microsoft Azure. No se puede obtener acceso a la capa de datos
directamente desde el cliente en el nivel de presentación. En su lugar, se utiliza el componente de
acceso a datos para la comunicación entre la Capa de Datos y las capas superiores.
Capa de Acceso a Datos
Esta capa proporciona la capacidad de persistir datos y acceder a ellos. Pueden ser datos propios del
sistema o incluso acceder a datos expuestos por otros sistemas como, por ejemplo, Servicios Web
Externos. Esta capa de persistencia se comunica con la Capa de Datos para exponer el acceso a datos
a las capas superiores. Esta capa permite realizar las operaciones de Altas, Bajas, Cambios y Consultas
sobre la Capa de Datos. Uno de los Frameworks de acceso a datos más utilizados es Entity Framework.
Lógica de negocio
La capa de lógica de negocio implementa la funcionalidad principal del sistema y encapsula la lógica
que hace cumplir las reglas de negocio de la aplicación. La capa de Lógica de Negocio permite la
independencia entre la aplicación cliente o servicio y la capa de Acceso a datos. Esta capa tiene el
código principal que puede utilizar la clase que implementa un servicio o bien el código que puede
consumir una aplicación cliente.
Capa de Servicio
La función principal de la Capa de Servicio es la de exponer la funcionalidad de la Capa de Lógica de

Negocio a clientes remotos o sistemas externos. Se puede pensar en la Interfaz de servicio como una
fachada que expone la Lógica de negocio implementada en la aplicación a los consumidores
potenciales, por ejemplo, una aplicación Universal Windows Platform (UWP), Android o iOS que por
diseño no pueden acceder directamente a los datos de un servidor Microsoft SQL Server. Estos clientes
podrían acceder a estos datos a través de un servicio ASP.NET Web API que exponga la funcionalidad
de la Lógica de Negocio para manipular dichos datos.
Capa de Presentación
La función principal de la capa de presentación es la de implementar la funcionalidad requerida para

que los usuarios puedan interactuar con la aplicación a través de una interfaz de usuario (UI). La capa
de presentación está compuesta por aplicaciones con elementos visuales utilizados para mostrar
información y aceptar entradas del usuario.
La capa de Presentación puede consumir la Capa de Servicio o bien puede consumir directamente el
código de la capa de Lógica de Negocio.
Ejemplos de aplicaciones que podemos encontrar en esta capa son aplicaciones Universal Windows
Platform (UWP), Android o iOS que requieren de la Capa de Servicio para acceder a la capa de lógica
de negocio o también aplicaciones Windows Presentation Foundation y aplicaciones ASP. NET MVC
que podrían consumir directamente la capa de Lógica de negocio.
Capa de Entidades
En esta capa se almacenan las entidades que permiten representar los datos de la fuente de datos y
que son utilizadas por la mayoría de las otras capas.
Por ejemplo, podemos utilizar una clase Empleado como una entidad que represente los datos de un
Empleado almacenados en una base de datos Microsoft SQL Server. La capa de Acceso a datos
obtendrá los datos de la entidad y los proporcionará a las capas superiores, en consecuencia, la Capa
de Entidades podrá comunicarse con todas las demás capas.
En la Arquitectura basada en capas, cada capa se comunica con la capa inferior adyacente, esto es, la
capa superior consume la funcionalidad de la capa inferior, por ejemplo, la Capa de Presentación se
comunica con la Capa de Servicio o directamente con la Capa de Lógica de Negocio, la capa de Lógica
de Negocio se comunica con la capa de Acceso a Datos y la capa de Acceso a datos se comunica con la
Capa de Datos.
En esta arquitectura no es permitido que una capa se comunique con una capa inferior no adyacente,
esto es, no está permitido, por ejemplo, que la capa de Lógica de Negocio consuma a la Capa de Datos
o que la Capa de Presentación consuma directamente la capa de Datos o Acceso a datos.
Es importante mencionar que no todas las aplicaciones deben utilizar el mismo número de capas,
dependiendo de la complejidad de la aplicación, podemos encontrar aplicaciones con 2-Capas, 3-Capas
o N-Capas. También es importante mencionar que en una aplicación N-Capas pueden existir más capas
que las mencionadas anteriormente.
Beneficios de la Arquitectura N-Capas

Dentro de los beneficios que nos aporta la Arquitectura basada en capas podemos mencionar los
siguientes:
• El mantenimiento de mejoras en una solución será mucho más fácil porque las funciones
siempre están localizadas en el mismo lugar de la arquitectura. Además, las capas deben estar
débilmente acopladas, pero con una relación bien definida entre ellas, lo cual permite
intercambiar de una forma sencilla diferentes implementaciones. Por ejemplo, si la capa de
Acceso a Datos de una aplicación esta optimizada para trabajar con Microsoft SQL Server y
posteriormente deseamos cambiar a otro motor de base de datos, únicamente tendremos que
modificar esta capa sin necesidad de realizar cambios en las otras capas.
• Otras aplicaciones pueden reutilizar la funcionalidad expuesta por las diferentes capas de la
aplicación, por ejemplo, si la lógica de negocio que implementa la autenticación y autorización
de usuarios en una aplicación se crea como una capa, esta capa podrá ser reutilizada en otra
aplicación que requiera también de autenticación y autorización de usuarios.
• El desarrollo de aplicaciones distribuidas es mucho más sencillo de implementar al estar
diseñadas en diferentes capas lógicas. Por ejemplo, podemos crear un servicio que
implemente la lógica de acceso a datos y que proporcione los datos a sistemas web ubicados
en un lugar remoto.
• La distribución de capas (layers) en diferentes niveles físicos (tiers) puede, en algunos casos,
mejorar la escalabilidad.
Capas Vs Niveles (Layers Vs Tiers)

Frecuentemente los conceptos Capas (Layers) y Niveles (Tiers) tienden a ser confundidos o utilizados
de forma incorrecta.
Capas (Layers)
Las Capas (Layers) se ocupan de la división lógica de componentes y funcionalidad de una aplicación y
no tienen en cuenta su ubicación física en diferentes servidores o en diferentes lugares.
Supongamos que tenemos una aplicación en la cual tenemos un solo proyecto, en este proyecto
implementamos todo lo referente a la Presentación, la Lógica de negocio, el acceso a datos y en el
mismo servidor tenemos nuestra base de datos SQL Server que sería otra capa. En este caso estamos
hablando de una aplicación de 2 capas.
Un ejemplo de una aplicación de 3 capas puede ser aquella que contiene 2 proyectos diferentes, en
uno de ellos podemos ubicar los componentes de la capa de Presentación, en otro proyecto tenemos
todo lo referente a la Lógica de Negocio y Acceso a Datos. Además, en el mismo servidor tenemos
nuestra base de datos SQL Server que es la Capa de Datos.
Por lo regular, cuando hablamos de aplicaciones de más de 3 capas, es común referirnos a ellas como
aplicaciones N-Capas. Por ejemplo, un proyecto para la capa de Presentación, otro para la capa de
Lógica de Negocio, un proyecto más para la Capa de Acceso a Datos y además en el mismo servidor
tenemos nuestra base de datos SQL Server que sería nuestra Capa de Datos.
Niveles (Tiers)
Los niveles se ocupan de la distribución física de los componentes y funcionalidad de una aplicación en
uno o más servidores.
Cuando hablamos de Niveles nos estamos refiriendo a la forma o al lugar físico donde se encuentran
las capas que componen una aplicación. Veamos algunos ejemplos.
Diseño de 2 niveles
Este modelo tiene el mismo diseño físico que el patrón Cliente/Servidor, la principal diferencia está en
la forma en que los componentes en los niveles se comunican. En algunos casos como se muestra en
el ejemplo, todo el código de la aplicación está localizado en el cliente y la base de datos está localizada
en un servidor independiente. El cliente hace uso de procedimientos almacenados o de instrucciones
de acceso a datos sobre el servidor de Base de datos.
Podemos considerar el patrón 2-Niveles si deseamos desarrollar una aplicación cliente que accederá a
un servidor de aplicaciones o un cliente que accederá a un servidor de base de datos independiente.
Diseño de 3-niveles
El Cliente interactúa con el software de la aplicación implementada sobre un servidor independiente

y el Servidor de la aplicación interactúa con una base de datos localizada en otro servidor como se
muestra en la imagen.
Este es un patrón muy común para la mayoría de las aplicaciones y servicios Web que resulta ser
suficiente para la mayoría de los escenarios.
Se podría implementar un firewall entre el cliente y el nivel web de la aplicación y otro firewall entre
el nivel web de la aplicación y el nivel de base de datos.
Se puede considerar este modelo si estamos desarrollando una aplicación para una Intranet, donde
todos los servidores se encuentran localizados en la misma red privada o una aplicación para Internet
y los requerimientos de seguridad no impiden implementar la lógica de negocios en el servidor web
público o servidor de aplicación.
Diseño de N niveles
En este escenario el servidor Web está físicamente separado del servidor de aplicación.
Esto se hace frecuentemente por razones de seguridad, donde el Servidor Web está ubicado dentro
de la zona perimetral de la red y accede al servidor de aplicación que se encuentra en una red diferente.
En este escenario podríamos implementar un firewall entre el Cliente y el nivel Web y otro firewall
entre el nivel Web y el nivel de Lógica de negocios.
Se puede considerar este diseño de N-Niveles si los requerimientos de seguridad exigen que la lógica
de negocios no puede ser implementada en la zona perimetral de la red, o si tenemos código de la
aplicación que haga un uso pesado de recursos en el servidor y queremos asignar esa funcionalidad
hacia otro servidor.
Para obtener más información sobre la arquitectura basada en Capas puedes consultar
el siguiente enlace:
Microsoft Application Architecture Guide, 2nd Edition

https://msdn.microsoft.com/en-us/library/ff650706.aspx
Introducción al
desarrollo de
con tecnologías
Microsoft
Modulo 2: Desarrollando una aplicacion
N-Capas
Acerca del módulo

En este módulo aplicaremos los conceptos teóricos descritos en el módulo anterior desarrollando una
aplicación en la cual implementaremos la Arquitectura N-Capas.
Para ejemplificar el desarrollo de una aplicación en N-Capas, desarrollaremos una aplicación que nos
permita realizar operaciones CRUD con 2 tablas en una base de datos de una empresa ficticia.
La capa de datos se encontrará alojada en un servidor Microsoft SQL Server. Utilizando el enfoque
Database-First que es el enfoque más común, construiremos la Capa de acceso a datos y la capa de
entidades utilizando Entity Framework. Separaremos las Entidades POCO en un proyecto .NET
Standard independiente de la capa de acceso a datos para poder reutilizar esta capa de entidades en
las demás capas, incluyendo en los clientes Xamarin.Forms.
Crearemos una capa de lógica de negocios para permitir el acceso a los datos desde las otras capas,
construiremos una capa de servicio utilizando un Web API ASP.NET MVC para dar soporte a
aplicaciones WPF, Web, UWP, iOS y Android.
En la capa de presentación, construiremos una aplicación ASP.NET Web MVC para mostrar la forma en
que se relaciona el modelo MVC con la arquitectura N-Capas.
Para el ambiente gráfico de Windows, construiremos una aplicación Windows Presentation

Foundation que estará ubicada en la capa de presentación.
Para dispositivo móviles desarrollaremos una aplicación Xamarin.Forms que nos permitirá ejemplificar
la forma de consumir datos desde una aplicación iOS, Android y UWP.
Toda la solución será desarrollada utilizando Visual Studio como entono de desarrollo. Los pasos
descritos en los ejercicios están diseñados con Visual Studio Enterprise 2017 versión 15.7 sobre una
máquina con Windows 10 Pro y SQL Server 2017.
Objetivos
• Crear la capa de origen de datos utilizando Microsoft SQL Server.

• Crear la capa de Acceso a datos utilizando Entity Framework.
• Crear la capa de Entidades utilizando una biblioteca de clases .NET Standard.
• Crear la capa de Lógica de Negocios.
• Crear la capa de Servicio utilizando ASP .NET Web API.
• Crear la capa de Presentación con una Aplicación ASP.NET MVC.
• Crear la capa de Presentación con una Aplicación Windows Presentation Foundation.
• Crear la capa de Presentación con una Aplicación Xamarin.Forms.
Los temas que forman parte de este módulo son:
• Lección 1: Creando la capa de datos con SQL Server.

• Lección 2: Creando la capa de Entidades y Acceso a Datos con Entity Framework.
• Lección 3: Creando la capa de Lógica de Negocios.
• Lección 4: Creando la capa de Servicio utilizando ASP.NET Web API.
• Lección 5: Creando la capa de Presentación.
Lección 1
Creando la capa de datos con SQL Server
En este ejercicio empezaremos por crear la capa de datos de la empresa ficticia NorthWind. La capa
de datos se encontrará alojada en un servidor Microsoft SQL Server 2017.
Al finalizar esta lección, los participantes contarán con las habilidades y conocimientos para:
• Crear la capa de datos utilizando Microsoft SQL Server.

• Crear la capa de datos utilizando la herramienta Server Explorer de Visual Studio.
Laboratorio
Creando la base de datos con Microsoft SQL Server Management
Studio
Para crear la base de datos que utilizaremos en nuestra aplicación podemos utilizar dos herramientas,
una de ellas es Microsoft SQL Server Management Studio y la otra es la ventana Server Explorer de
Visual Studio.
Empecemos con SQL Server Management Studio.
1. Abre la aplicación Microsoft SQL Server Management Studio.
2. En la ventana Connect to Server selecciona Database Engine como tipo de servidor.
3. Introduce o selecciona el nombre del servidor SQL Server.
4. Selecciona Windows Authentication como el tipo de autenticación. Sí lo prefieres puedes

seleccionar otro tipo de autenticación y proporcionar los datos de autenticación que te sean
solicitados.
5. Haz clic en el botón Connect para realizar la conexión.
Después de realizar la conexión te será mostrada la ventana Object Explorer.
6. Desde la ventana Object Explorer selecciona la opción New Database del menú contextual del
nodo Databases.
7. En la ventana New Database establece el nombre NWind a la base de datos y haz clic en el
botón OK para crear la nueva base de datos.
8. En la ventana Object Explorer, selecciona la opción New > Table… del menú contextual del
nodo Tables.
9. En la ventana de diseño de la tabla, registra la siguiente información
Columna Tipo Acepta Valores

Null
CategoryID int No
CategoryName varchar(50) No
Description varchar(Max) Si
10. Selecciona la opción Set primary Key del menú contextual del campo CategoryID para
establecer el campo CategoryID como la llave primaria de la tabla.
11. En la sección Column Properties del campo CategoryID establece la propiedad Is Identity con
el valor Yes.
12. Guarda la tabla con el nombre Categories.
Después de guardar los cambios, podrás ver la tabla Categories dentro de la carpeta Tables
de la Base de Datos NWind.
Laboratorio
Creando la base de datos con la herramienta Server Explorer de Visual
Studio
En este ejercicio, agregaremos una tabla a la base de datos creada en el ejercicio anterior utilizando la
ventana Server Explorer de Visual Studio.
1. Ejecuta Visual Studio en contexto de Administrador.
2. Haz clic en la pestaña View de la barra de herramientas de Visual Studio y selecciona la opción
Server Explorer.
3. En la ventana Server Explorer selecciona el icono Connect to Database.
4. En la ventana Choose Data Source selecciona la opción Microsoft SQL Server y haz clic en
Continue.
5. En la ventana Add Conection verifica que la opción Data Source sea Microsoft SQL Server
(SqlClient), escribe el nombre del servidor al que te vas a conectar, selecciona el tipo de
autenticación e ingresa las credenciales en caso de ser necesario. Finalmente selecciona la
base de datos NWind y haz clic en Test Connection para verificar que la conexión es correcta.
Si la conexión es correcta, te será mostrado un cuadro de diálogo similar al siguiente.
6. Haz clic en el botón OK para cerrar el cuadro de diálogo.
7. Haz clic en el botón OK de la ventana Add Connection para continuar.
En la ventana Server Explorer se habrá agregado la nueva conexión.
8. Expande el contenido de la conexión. Verás una estructura similar a la siguiente.
Crearemos ahora la tabla Products.
9. Selecciona la opción Add New Table del menú contextual del nodo Tables.
10. Escribe los nombres de las columnas, tipos de datos y opciones Null de acuerdo con la siguiente
tabla:
Columna Tipo Acepta Valores

Null
ProductID int No
ProductName varchar(40) No
CategoryID int No
UnitPrice decimal(9,2) No
UnitsInStock decimal(9,2) No
11. Selecciona la opción Properties del menú contextual del campo ProductID para abrir la
ventana de propiedades.
12. Establece el campo Is Identity con el valor True.
De manera predeterminada el campo ProductID está marcado como llave primaria, de

no ser asi, establécelo como llave primaria.
13. En la ventana de código T-SQL, cambia el nombre de la tabla por Products.
14. Haz clic en el botón Update para actualizar la base de Datos.
15. En la ventana Preview Database Updates puedes ver un resumen de las acciones que serán
efectuadas. Haz clic en el botón Update DataBase para crear la tabla.
16. Al finalizar, en la ventana Data Tools Operations podrás ver que la actualización a la base de
datos fue exitosa.
17. En la ventana Server Explorer, selecciona la opción Refresh del menú contextual del nodo
Tables. Puedes observar la nueva tabla creada.
Laboratorio
Creando el diagrama Entidad-Relación
Para terminar con la Capa de Datos, en este ejercicio crearemos la llave foránea de las tablas creadas
en los ejercicios anteriores, una forma de realizarlo es mediante un diagrama Entidad-Relación en
Microsoft SQL Server Management Studio.
1. Abre Microsoft SQL Server Management Studio y expande el nodo NWind.
2. Selecciona la opción New Database Diagram del menú contextual de la opción Database
Diagrams.
3. En caso de que te sea mostrada la ventana de diálogo indicándote que se requiere de objetos
de soporte, haz clic en Yes para crearlos.
La ventana Add Table será mostrada.
4. En la ventana Add Table, selecciona las tablas Categories y Products y haz clic en el botón Add.
5. Haz clic en el botón Close para cerrar la ventana Add Table.
6. Crea la relación entre ambas tablas seleccionando el campo CategoryID de la tabla Categories
y arrastrándolo hacia el campo CategoryID de la tabla Products. Al soltar el botón del ratón se
mostrará la ventana Tables and Columns.
7. Verifica que las tablas y campos sean los correctos y haz clic en el botón OK.
8. En la ventana Foreign Key Relationship haz clic en el botón OK para crear la llave foránea. Se
mostrará un diagrama similar al siguiente.
9. Haz clic en el botón Save de la barra de herramientas.
10. En el cuadro de dialogo Choose Name escribe el nombre NWindDiagram y haz clic en OK para
guardar los cambios.
11. En la ventana Save, aparecerá un resumen de las tablas que serán afectadas. Haz clic en Yes
para aceptar los cambios.
Con esto finaliza este ejercicio y como resultado tenemos la capa de datos con la base de datos NWind
con sus relaciones entre las tablas Categories y Products.
Lección 2
Creando la capa de Entidades y Acceso a Datos con
Entity Framework
Entity Framework es una tecnología que proporciona una solución ORM (Object Relational Mapping),
ORM es una técnica de programación que permite a los desarrolladores trabajar con datos relacionales
usando objetos específicos del dominio a través de mapeos de entidades con tablas y de propiedades
de la entidad con campos de la tabla. Un ORM reduce la cantidad de código de acceso a datos que los
desarrolladores deben escribir para realizar consultas o actualizaciones sobre la fuente de datos.
Cuando desarrollamos aplicaciones con acceso a datos utilizando Entity Framework podemos elegir
alguno de los 3 enfoques que nos ofrece:
• Database-First, la base de datos se crea primero y el código y el modelo se crean después.

• Model-First, primero se crea el modelo y posteriormente se genera la estructura de la base de
datos a partir del modelo.
• Code-First, donde se crean primero las entidades y después se crea la base de datos en base a
las entidades.
En esta lección se describe la forma de crear la capa de Acceso a datos utilizando Entity Framework
con el enfoque Database-First y se describe la forma de crear la capa de Entidades.
Finalmente, se describe de manera sencilla la forma de implementar el patrón Repository para el

acceso a datos.
• Crear la capa de Acceso a Datos.
• Crear la capa de Entidades.
• Implementar el patrón Repositorio.
• Probar la capa de Acceso a Datos.
Laboratorio
Creando la capa de Acceso a Datos
Una vez creada la base de datos, el siguiente paso es iniciar con el desarrollo de la aplicación que podrá
realizar operaciones CRUD sobre la información de nuestra base de datos.
Empecemos creando una solución vacía en Visual Studio, los pasos a seguir son los siguientes:
1. Abre Visual Studio en contexto de administrador.
2. Selecciona la opción File > New > Project… de la barra de menús de Visual Studio.
3. En la ventana New Project selecciona la plantilla Blank Solution del nodo Other Project
Types.
4. Escribe el nombre NWind para la solución, selecciona la ubicación y haz clic en el botón OK.
El siguiente paso será agregar un proyecto a la solución para implementar la capa de acceso a
datos utilizando Entitiy Framework 6.
5. Selecciona la opción Add > New Project… del menú contextual de la solución.
6. En la ventana Add New Project, selecciona la plantilla Class Library (.Net Framework).
7. Escribe el nombre DAL y haz clic en el botón OK para agregar el proyecto.
Al utilizar la plantilla Class Library con el .NET Framework, podremos utilizar distintos
controladores de bases de datos en nuestra aplicación, por ejemplo, cuando tengamos la
necesidad de utilizar controladores de bases de datos que solo sean soportadas en Windows
como Visual FoxPro. Si utilizáramos .NET Standard o .NET Core, no tendríamos la opción de
utilizar Entity Framework que requiere el .NET Framework.
8. Elimina el archivo Class1.cs que es generado automáticamente.
Ahora es momento de crear el modelo.
9. Selecciona la opción Add > New Item… del menú contextual del proyecto DAL.
10. Selecciona la plantilla ADO.NET Entity Data Model.
11. Escribe el nombre NWindDBModel y haz clic en el botón Add para continuar.
La ventana Entity Data Model Wizard será mostrada. Entity Data Model Wizard es uno de los
asistentes de ADO.NET Entity Framework que nos permite generar un nuevo modelo
conceptual.
12. En la ventana Entity Data Model Wizard selecciona la opción EF Designer from DataBase y haz
clic en Next.
13. En la pantalla Choose Your Data Connection selecciona la conexión a la base de datos
NWind.
Puedes ver la cadena de conexión que el asistente ha creado automáticamente, en ella se

especifican los datos del modelo conceptual con sus definiciones y sus mapeos asi como el
nombre del servidor, el nombre de la base de datos inicial, la seguridad y el soporte a múltiples
resultados activos. La cadena de conexión será guardada en el archivo App.Config.
14. Escribe el nombre NWindEntities para la llave que será guardada en el archivo de
configuración y haz clic en Next.
15. En la ventana Choose Your Versión, selecciona la opción Entity Framework 6.x y haz clic en el
botón Next.
Aparecerá una ventana donde podrás ver los posibles elementos que se pueden agregar al
modelo.
16. Selecciona las tablas Categories y Products.
17. Verifica que la casilla foreign key columns in the model esté seleccionada, esto permitirá
importar las relaciones que existen entre las tablas.
La opción Import Selected store procedures… permitirá importar los procedimientos

almacenados que podrán ser utilizados como funciones de C#. Esta opción no nos es útil por
el momento ya que no tenemos Stored procedures en la base de datos.
La opción Pluralize or singularize generated objects names singulariza los nombres de las
tablas por ejemplo de Products a Product y de Categories a Category.
18. Selecciona la opción Pluralize or singularize generated objects names y haz clic en el botón
Finish para finalizar.
19. Haz clic en OK en caso de que te sea solicitada la autorización para ejecutar la plantilla.
Cuando creamos un modelo mediante el Entity Data Model Wizard el modelo se abrirá en el
panel del diseñador mostrando las entidades que el asistente haya generado y las relaciones
entre ellas (Propiedades de navegación). Se puede utilizar este panel para agregar, modificar
y eliminar entidades y relaciones.
La siguiente imagen muestra la solución después de agregar el modelo. Observa los archivos
NWindDBModel.context.tt y NWindDBModel.tt que conforman el modelo.
Es importante hacer notar, que tanto el código de acceso a datos como las entidades han quedado
en el mismo proyecto. El siguiente ejercicio será separar a las entidades del código de acceso a
datos para que queden en un proyecto independiente y de esta forma puedan ser utilizadas por
las demás capas sin violar las reglas de la arquitectura n-capas que nos indica que una capa solo
puede consumir los servicios de la capa inmediatamente inferior.
Laboratorio
Creando la capa de entidades
Como podemos darnos cuenta, en nuestro modelo creado en nuestra capa DAL, tenemos tanto el
Contexto como las Entidades en el mismo proyecto. El siguiente paso por realizar es separar las
entidades del contexto para crear nuestra capa de Entidades. Es aquí donde surge la pregunta que
muchos desarrolladores que utilizan Entity Framework se plantean ¿Cómo separo las Entidades del
Contexto?
Existen varias alternativas para separar el contexto de las entidades, algunas implican modificar el
archivo de proyecto, agregar o modificar plantillas de texto T4 o utilizar el generador de contexto.
Mostremos la solución modificando la plantilla T4 que genera las entidades.
1. Agrega un nuevo proyecto a la solución de tipo Class Library (.NET Standard) con el nombre
Entities.
Al trabajar con una biblioteca .NET Standard podremos reutilizar nuestras entidades en otras
plataformas como por ejemplo en una aplicación Xamarin para dispositivos Android o iOS.
2. Borra el archivo Class1.cs que se genera automáticamente.
3. Abre la plantilla NWindDBModel.tt en el proyecto DAL dando clic sobre el archivo. Esta
plantilla tiene el código que genera las entidades.
4. Modifica la ruta donde genera las clases que representan las entidades.
WriteHeader(codeStringGenerator, fileManager);
foreach (var entity in
typeMapper.GetItemsToGenerate<EntityType>(itemCollection))
{
fileManager.StartNewFile($@"..\Entities\{entity.Name}.cs");
BeginNamespace(code);
#>
<#=codeStringGenerator.UsingDirectives(inHeader: false)#>
<#=codeStringGenerator.EntityClassOpening(entity)#>
5. Selecciona el archivo NWindDBModel.tt y presiona la tecla F4 para abrir la ventana de

propiedades.
6. Modifica la propiedad Custom Tool NameSpace de la plantilla NWindDBModel.tt con el valor

Entities, para indicar el espacio de nombres de las entidades a generar.
7. Guarda los cambios del archivo y espera a que se creen las clases. Observa que las clases
Category y Product se han creado en el proyecto Entities.
8. Compila la solución.
El contexto en el proyecto DAL busca las entidades en su mismo espacio de nombres DAL, por
lo que ahora muestra un error al no encontrar los tipos entidad.
Tenemos que modificar las propiedades de la plantilla NWindDBModel.Context.tt para que se

genere el contexto en el mismo espacio de nombres de las entidades.
9. Abre la ventana de propiedades del archivo NWindDBModel.Context.tt.
10. Establece el espacio de nombres Entities en la propiedad Custom Tool Namespace.
La capa DAL necesita una referencia a la capa Entities para poder hacer uso de las entidades.
11. Selecciona la opción Add Reference del menú contextual del nodo References del proyecto
DAL.
12. Selecciona el proyecto Entities y haz clic en el botón OK.
13. Selecciona el archivo Category.cs de la DAL.
14. Presiona F4 para abrir la ventana de propiedades.
15. Establece el valor None a la propiedad Build Action.
16. Repite los pasos anteriores para establecer None a la propiedad Build Action del archivo
Product.cs.
17. Verifica que la aplicación compile correctamente ahora.
Laboratorio
Definiendo la interface del patrón Repositorio
La capa de lógica de negocios utiliza a la capa de acceso a datos para recuperar la información que
necesita. La capa de lógica de negocios debe ser ignorante del tipo de datos que existe en la capa de
origen de datos. Por ejemplo, la capa de datos puede ser una base de datos, una lista de SharePoint o
un servicio Web.
Podemos utilizar el patrón Repositorio para separar la lógica de negocios de la lógica que utiliza la capa
de acceso a datos para recuperar los datos y mapearlos a las entidades del modelo.
Para obtener más información sobre el patrón Repositorio puedes consultar el

siguiente enlace:
The Repository Pattern

https://msdn.microsoft.com/en-us/library/ff649690.aspx
En pocas palabras, un repositorio es un mediador entre el dominio de la aplicación y los datos que le
dan persistencia. Con este planteamiento podemos pensar que el cliente de este repositorio no
necesitaría conocer la tecnología utilizada para acceder a los datos, sino que le bastará con saber cuáles
son las operaciones que le facilita este “mediador”, esto es, el repositorio.
Implementaremos de forma sencilla el patrón Repositorio en nuestra capa de acceso a datos para
implementar la recuperación de datos.
Siguiendo las recomendaciones del patrón Repositorio, definamos una interface con las operaciones
básicas que utilizaremos para realizar las operaciones CRUD sobe la fuente de datos.
1. Agrega un nuevo elemento de tipo Interface al proyecto DAL con el nombre de IRepository.
2. Modifica el código de la interface de la siguiente manera.
public interface IRepository: IDisposable

{
La interface implementará la interface IDisposable para poder liberar al contexto de datos.
3. Define ahora las operaciones que expondrá la interface: Create, Delete, Update, Retrieve y
Filter para crear, eliminar, actualizar, obtener y filtrar una entidad respectivamente.
// Para agregar una nueva entidad a la DB

TEntity Create<TEntity>(TEntity toCreate) where TEntity : class;
// Para eliminar una entidad

bool Delete<TEntity>(TEntity toDelete) where TEntity : class;
// Para actualizar una entidad

bool Update<TEntity>(TEntity toUpdate) where TEntity : class;
// Para recuperar una entidad en base a un criterio

TEntity Retrieve<TEntity>(Expression<Func<TEntity, bool>> criteria)
where TEntity : class;
// Para recuperar un conjunto de entidades

// que cumplan con un criterio de búsqueda
List<TEntity> Filter<TEntity>(Expression<Func<TEntity, bool>> criteria)
where TEntity : class;
Puedes notar que los métodos son genéricos. El tipo genérico representa el tipo de una
Entidad. Existe una restricción en el tipo y es que ese tipo debe ser un tipo Referencia.
Como buenas prácticas, podemos definir esta interface en su propio proyecto para poder
reutilizarlo en otros proyectos que implementen esta interface.
4. Agrega el siguiente código al inicio del archivo IRepository.cs para importar el espacio de
nombres System.Linq.Expressions que define la clase Expression.
using System.Linq.Expressions;
Laboratorio
Implementando la interface del patrón Repositorio
Ya que hemos definido la Interface del patrón Repositorio, vamos a crear la clase que implementará
los métodos declarados en esta interface. Esta implementación estará diseñada para obtener los datos
de un contexto Entity Framework. Como buena práctica, lo recomendable seria implementar esta
clase en su propio Assembly para poder reutilizarlo en otros proyectos que requieran un repositorio
que trabaje con contextos Entity Framework. Por simplicidad, nosotros implementaremos la interface
en nuestro proyecto DAL.
1. Agrega una clase con el nombre de EFRepository al proyecto DAL.
2. En esta clase, implementaremos la interface realizada en el ejercicio anterior. Modifica el

código de la siguiente manera.
public class EFRepository: IRepository

{
3. Agrega el siguiente código a la clase, donde se define el contexto que utilizará el repositorio.
DbContext Context;
// Recibamos una instancia del contexto al crear la clase
public EFRepository(DbContext context)
{
this.Context = context;
}
4. Agrega el siguiente código para importar los espacios de nombres donde se encuentra la clase
DbContext y la clase Expression.
using System.Data.Entity;
using System.Linq.Expressions;
5. Agrega el siguiente código a la clase EFRepository para implementar los miembros de la

Interface.
public TEntity Create<TEntity>(TEntity toCreate) where TEntity : class

{
TEntity Result = default(TEntity);
try
{
Context.Set<TEntity>().Add(toCreate);
Context.SaveChanges();
Result = toCreate;
}
catch { }
return Result;
}
public bool Delete<TEntity>(TEntity toDelete) where TEntity : class

{
bool Result = false;
try
{
Context.Entry<TEntity>(toDelete).State = EntityState.Deleted;
Result = Context.SaveChanges() > 0;
}
catch { }
return Result;
public bool Update<TEntity>(TEntity toUpdate) where TEntity : class

{
try
{
Context.Entry<TEntity>(toUpdate).State =
EntityState.Modified;
Result = Context.SaveChanges() > 0;
}
catch { }
return Result;
public TEntity Retrieve<TEntity>

(Expression<Func<TEntity, bool>> criteria)where TEntity : class
{
TEntity Result = null;
try
{
Result = Context.Set<TEntity>().FirstOrDefault(criteria);
}
catch { }
return Result;
}
public List<TEntity> Filter<TEntity>

(Expression<Func<TEntity, bool>> criteria) where TEntity : class
{
List<TEntity> Result = null;
try
{
return Context.Set<TEntity>().Where(criteria).ToList();
}
catch { }
return Result;
}
public void Dispose()

{
if (Context != null)
{
Context.Dispose();
}
6. Agrega una nueva clase al proyecto DAL con el nombre RepositoryFactory. Esta clase será la
que expondremos a la lógica de negocio. La función de esta clase será la de crear un repositorio
especifico de la fuente de datos a utilizar. Por ejemplo, esta clase decidiría utilizar un
repositorio Entity Framework o alguna otra implementación del repositorio.
7. Agrega el siguiente código a la clase para pasar el contexto al Repositorio.
public class RepositoryFactory

{
public static IRepository CreateRepository()
{
return new EFRepository(new Entities.NWindEntities());
}
}
En este ejercicio, implementamos la lógica de acceso a datos para realizar operaciones CRUD utilizando
el patrón Repositorio.
Laboratorio
Probando la Capa de Acceso a Datos
Antes de continuar con las demás capas de nuestra aplicación, podríamos probar la funcionalidad de
la capa de Acceso a Datos.
1. Agrega a la solución una aplicación de consola con el nombre Test.
2. Agrega una referencia de los proyectos DAL y Entities al proyecto Test.
3. Localiza la cadena de conexión a la base de datos en el archivo App.config del proyecto DAL.
El código es similar al siguiente.
<connectionStrings>
<add name="NWindEntities"
connectionString="metadata=res://*/NWindDBModel.csdl|res://*/NWindDBModel.ssdl|res:
//*/NWindDBModel.msl;provider=System.Data.SqlClient;provider connection
string="data source=.;initial catalog=NWind;integrated
security=True;MultipleActiveResultSets=True;App=EntityFramework""
providerName="System.Data.EntityClient" />
</connectionStrings>
4. Copia ese código al archivo App.config del proyecto Test dentro del elemento
<configuration>.
Entitiy Framework ahora es desarrollado bajo licencia open source así que ya no forma parte
del .NET Framework. A partir de Entity Framework 6 debemos registrar a los proveedores que
utilizará nuestra aplicación. En este caso, el proveedor Microsoft SQL Server.
La manera más fácil de realizar este registro es a través de un paquete NuGet.
5. Selecciona la opción Manage NuGet Packages… del menú contextual del proyecto Test
6. En la pantalla NuGet haz clic en la pestaña Browse e ingresa Entitiy Framework en la caja de
texto para buscarlo.
7. En la lista de resultados, haz clic en EntitiyFramework y posteriormente en el botón Install.
8. Acepta los cambios y acuerdo de licencia cuando te sea requerido.
9. Establece la aplicación de consola como proyecto de inicio dando clic derecho sobre el
proyecto y seleccionando la opción Set as Startup Proyect del menú contextual.
10. Agrega el siguiente código al archivo Program.cs para importar los espacios de nombres de los
proyectos DAL y Entities.
using DAL;
using Entities;
11. Agrega el siguiente método a la clase Program para agregar una categoría y producto a la base
de datos.
static void AddCategoryAndProduct()
{
Category c = new Category()
{
CategoryName = "Cereales",
Description = "Productos de Maíz"
};
Product Cereal = new Product

{
ProductName = "Cereal",
UnitsInStock = 0,
UnitPrice = 15
};
c.Products.Add(Cereal);
using (var r = RepositoryFactory.CreateRepository())

{
r.Create(c);
}
Console.WriteLine($"Categoría:{c.CategoryID}, " +
$"Producto:{Cereal.ProductID}");
}
12. Agrega el siguiente código al método Main para invocar el método agregado en el paso
anterior.
static void Main(string[] args)
{
AddCategoryAndProduct();
Console.Write("Presione <enter> para finalizar");
Console.ReadLine();
}
13. Ejecuta la aplicación. Observa que muestra los ID de categoría y Producto creados.
14. Agrega ahora un producto de la categoría creada en el paso anterior, con ayuda del siguiente
método.
static void AddProduct()

{
Product Avena = new Product
{
CategoryID = 1,
UnitsInStock = 100,
ProductName = "Avena",
UnitPrice = 10
};
{
r.Create(Avena);
}
Console.WriteLine($"Producto: {Avena.ProductID}");
}
15. Modifica el método Main para invocar el método AddProduct de la siguiente manera:

{
// AddCategoryAndProduct();
AddProduct();
16. Ejecuta la aplicación nuevamente. Observa el ID del producto creado que es mostrado en la
consola.
17. Detén la aplicación y agrega el siguiente método en la clase Program para probar los métodos
de buscar y modificar.
static void RetrieveAndUpdate()

{
{
// Buscar el último producto agregado
var P = r.Retrieve<Product>(p => p.ProductID == 2);
if (P != null)
{
Console.WriteLine(P.ProductName);
P.ProductName = P.ProductName + "***";
r.Update(P);
Console.WriteLine("Nombre modificado");
}
else
{
Console.WriteLine("Producto no encontrado");
}
}
}
18. Invoca el método creado en el paso anterior desde el método Main.

{
//AddProduct();
RetrieveAndUpdate();
19. Ejecuta la aplicación y observa el resultado en la consola.
20. Prueba ahora el filtro de registros agregando el siguiente código a la clase Program.
static void List()

{
{
// Buscar una categoría agregada previamente
var Productos = r.Filter<Product>(p => p.CategoryID == 1);
foreach (var p in Productos)
{
Console.WriteLine($"{p.ProductName}");
}
}
}
21. Modifica nuevamente el método Main para invocar el método List().

{
//AddProduct();
//RetrieveAndUpdate();
List();
22. Ejecuta la aplicación, podrás ver una pantalla similar a la siguiente.
23. Finalmente prueba el método para eliminar agregando el siguiente código para buscar un
producto y eliminarlo.
static void SearchAndDelete()

{
{
// Buscar el último producto agregado
var P = r.Retrieve<Product>(p => p.ProductID == 2);
if (P != null)
{
Console.WriteLine(P.ProductName);
r.Delete(P);
Console.WriteLine("Producto eliminado");
}
else
{
Console.WriteLine("Producto no encontrado");
}
}
}
24. Modifica el método Main para invocar al método agregado.

{
//AddProduct();
//RetrieveAndUpdate();
//List();
SearchAndDelete();
25. Ejecuta la aplicación y observa el resultado en la consola.
En este ejercicio creaste una aplicación de consola para probar que la capa de Acceso a datos y la capa
de Entidades estén funcionando correctamente.
Lección 3
Creando la capa de Lógica de negocios
La capa de negocios implementa la funcionalidad principal del sistema y encapsula la lógica de negocio
relevante que posteriormente podrá ser expuesta a través de la capa de servicio para clientes remotos.
Esta lección describe la forma de crear la capa de lógica de negocios para una aplicación.
• Crear la capa de lógica de negocio.
Laboratorio
Creando la Capa de Lógica de Negocio
Siguiendo con el modelo de desarrollo de aplicaciones en N-Capas, es momento de incorporar la capa
de Lógica de Negocio a nuestra aplicación, la capa de lógica implementa la funcionalidad principal del
sistema y encapsula la lógica de negocio relevante, por ejemplo, una empresa pudiera tener las
siguientes restricciones:
• No se puede eliminar un producto si este tiene existencias.

• No se puede modificar el nombre del producto si ya existe un producto con el mismo
nombre.
• No se puede agregar un producto si el nombre del producto nuevo ya existe.
1. Agrega un nuevo proyecto a la solución de tipo Class library (.NET Framework) llamado BLL.
2. En el proyecto BLL, agrega la referencia de la capa de Entidades (Entities) y de la capa de Acceso

a Datos (DAL).
3. Cambia el nombre de la clase Class1 a Products. En la clase Products implementaremos los

métodos que nos permitirán realizar las operaciones sobre los datos de los productos de
nuestra base de datos NWind.
public class Products

{
}
4. Agrega los espacios de nombre de la DAL y Entities a la clase Products.
using DAL;
using Entities;
Ahora vamos a implementar nuestros métodos, iniciemos por el método para crear un
producto.
5. Agrega el siguiente código a la clase Product.
public Product Create(Product newProduct)

{
Product Result = null;
{
// Buscar si el nombre de producto existe
Product res =
r.Retrieve<Product>(
p => p.ProductName == newProduct.ProductName);
if (res == null)
{
// No existe, podemos crearlo
Result = r.Create(newProduct);
}
else
{
// Podríamos aquí lanzar una excepción
// para notificar que el producto ya existe.
// Podríamos incluso crear una capa de Excepciones
// personalizadas y consumirla desde otras
// capas.
}
}
return Result;
}
Creamos ahora un método que nos permita buscar un producto por su ID.
6. Agrega el siguiente código a la clase Products.
public Product RetrieveByID(int ID)

{
{
Result = r.Retrieve<Product>(p => p.ProductID == ID);
}
return Result;
}
Creamos ahora un método para actualizar un producto.
7. Agrega las siguientes instrucciones a la clase Products.
public bool Update(Product productToUpdate)

{
{
// Validar que el nombre de producto no exista
Product temp =
r.Retrieve<Product>
(p => p.ProductName == productToUpdate.ProductName
&& p.ProductID != productToUpdate.ProductID);
if (temp == null)
{
// No existe
Result = r.Update(productToUpdate);
}
else
{
// Podemos implementar alguna lógica para
// indicar que no se pudo modificar
}
}
return Result;
}
8. Agrega el siguiente código que nos permitirá eliminar un producto.
public bool Delete(int ID)

{
// Buscar el producto para ver si tiene existencias
var Product = RetrieveByID(ID);
if (Product != null)
{
if (Product.UnitsInStock == 0)
{
// Eliminar el producto
{
Result = r.Delete(Product);
}
}
else
{
// Podemos implementar alguna lógica adicional
// para indicar que no se pudo eliminar el producto
}
}
else
{
// Podemos implementar alguna lógica
// para indicar que el producto no existe
}
return Result;
}
9. Agrega el siguiente código para buscar los productos de una categoría.
public List<Product> FilterByCategoryID(int categoryID)

{
List<Product> Result = null;
{
Result = r.Filter<Product>
(p => p.CategoryID == categoryID);
}
return Result;
}
10. Agrega una clase con el nombre de Categories al proyecto BLL para realizar las operaciones
CRUD con la clase Category.
11. Agrega los espacios de nombres de la DAL y Entities a la clase Categories.
using DAL;
using Entities;
12. Modifica el código de la clase categorías de la siguiente manera.
public class Categories

{
public Category Create(Category newCategory)
{
{
newCategory = r.Create(newCategory);
}
return newCategory;
}
}
Si el tiempo te lo permite agrega los métodos para actualizar, buscar y eliminar categorías tal y como
lo hicimos con Products.
Lección 4
Creando la capa de Servicio utilizando Web API
En esta lección se describe la forma de implementar la capa del Servicio utilizando ASP.NET Web API
para exponer la lógica de negocio de la aplicación a clientes remotos como iOS o Android. Una
estrategia recomendada es crear un contrato que defina la funcionalidad que el servicio expondrá a
los clientes. El contrato facilitará la creación de una clase proxy en el cliente para consumir el servicio.
• Crear el contrato del servicio.

• Implementar el servicio.
• Probar el servicio.
Laboratorio
Creando el contrato del servicio
Ya que hemos creado la capa de Acceso a datos, la capa de Entidades y nuestra capa de Lógica de
negocio, el siguiente paso es crear nuestro servicio. El servicio será creado utilizando ASP.NET Web API
y lo hospedaremos sobre IIS. Una estrategia recomendada es crear un contrato que defina la
funcionalidad que el servicio expondrá a los clientes. El contrato facilitará la creación de una clase
proxy en el cliente para consumir el servicio.
1. Agrega un nuevo un nuevo proyecto a la solución de tipo Class library (.NET Standard)
llamado SLC. Al crear una biblioteca .NET Standard, otras plataformas podrán consumirla
fácilmente.
2. Elimina el archivo Class1.css generado automáticamente.
Definamos ahora el contrato del servicio a través de una interface.
3. Agrega al proyecto SLC un nuevo elemento de tipo Interface y nómbralo IService.
4. Agrega una referencia del proyecto Entities.
5. Agrega el código para importar el espacio de nombres Entities en el archivo IService.cs.
using Entities;
6. Modifica la interface con el siguiente código.
public interface IService

{
Product CreateProduct(Product newProduct);
Product RetrieveProductByID(int ID);
bool UpdateProduct(Product productToUpdate);
bool DeleteProduct(int ID);
List<Product> FilterProductsByCategoryID(int ID);
Category CreateCategory(Category newCategory);
Por simplicidad solo estamos agregando pocos métodos, sin embargo, de ser necesario podríamos
agregar más métodos.
Laboratorio
Implementando el servicio
Ya que tenemos nuestro contrato ahora vamos a crear el servicio que implementará los métodos
definidos en el contrato.
El servicio simplemente funcionará como una fachada que permitirá el acceso a la capa de lógica.
1. Agrega un proyecto ASP.NET Web API a la solución seleccionando la plantilla ASP .NET Web
Application (.Net framework). Asigna el nombre Service al nuevo proyecto.
2. En la ventana New ASP.NET Web Application selecciona la plantilla Empty con la estructura
de archivos Web API y haz clic en OK.
3. Agrega al proyecto Service la referencia de la capa de lógica, entidades y contrato del servicio.
4. Compila la solución y verifica que compile correctamente.
5. En el proyecto Service, selecciona la opción Add > Controller... del menú contextual del nodo
Controllers.
6. En la ventana Add Scaffold selecciona la opción Web API 2 Controller - Empty y haz clic en el
botón Add.
7. Escribe NWindController para el nombre del controlador y haz clic en el botón Add.
8. Importa los espacios de nombres de la capa de lógica, contrato del servicio y entidades en el
controlador.
using Entities;
using BLL;
using SLC;
9. Modifica la clase para que implemente el contrato del servicio.
public class NwindController : ApiController, IService

{
}
10. Agrega el siguiente código para implementar el contrato del servicio.
[HttpPost]
public Category CreateCategory(Category newCategory)
{
var BL = new Categories();
var NewCategory = BL.Create(newCategory);
return NewCategory;
}
[HttpPost]
public Product CreateProduct(Product newProduct)
{
var BL = new Products();
var NewProduct = BL.Create(newProduct);
return NewProduct;
}
[HttpGet]
public bool DeleteProduct(int ID)
{
var Result = BL.Delete(ID);
return Result;
}
[HttpGet]
public List<Product> FilterProductsByCategoryID(int ID)
{
var Result = BL.FilterByCategoryID(ID);
return Result;
}
[HttpGet]
public Product RetrieveProductByID(int ID)
{
var Result = BL.RetrieveByID(ID);
return Result;
}
[HttpPost]
public bool UpdateProduct(Product productToUpdate)
{
var Result = BL.Update(productToUpdate);
return Result;
}
11. Abre el archivo App_Start/WebApiConfig.cs y modifica la ruta predeterminada de ASP.NET

Web API para incluir el método de acción en la petición.
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
Debido a que ahora la aplicación que hospeda el servicio será la que se ejecutará, debemos
actualizar la cadena de conexión y el registro del proveedor Entity Framework.
12. Localiza la sección <ConnectionStrings> con la cadena de conexión del archivo App.config en
el proyecto DAL y cópialo hacia el archivo Web.config del proyecto Service.
13. Agrega el paquete NuGet EntitiyFramework al proyecto Service y espera a que finalice la
instalación.
En este ejercicio hemos creado la implementación del servicio, el siguiente paso es realizar pruebas
del servicio para verificar que funcione correctamente.
Laboratorio
Probando el servicio
Ya que tenemos nuestro servicio, es momento de realizar pruebas de su funcionamiento. Para realizar
las pruebas del servicio utilizaremos la aplicación Postman que puedes descargar e instalar desde el
siguiente enlace:
https://www.getpostman.com/
1. Selecciona la opción Debug > Start New Instance del menú contextual del proyecto Service.
2. Abre la aplicación Postman e ingresa los siguientes parámetros como se muestra en la

siguiente tabla.
Método Post
URL URL donde se ejecuta el servicio, por ejemplo:

http://localhost: 50508/api/nwind/createproduct
Body/Raw/Json {
"ProductName":"Frijol",
"CategoryID":1,
"UnitsInStock":100,
"UnitPrice":25
}
3. Haz clic en el botón Send para enviar la petición al servicio. Observa que el resultado
devuelto es un objeto Product.
4. Prueba ahora buscar un producto con los siguientes datos en Postman.
Método GET
URL http://localhost:50508/api/nwind/RetrieveProductByID/1
Remplaza el id por uno que exista en tu base de datos
Observa que el resultado es una excepción.
5. Coloca un punto de ruptura en el método RetrieveByID de la clase NWindController en el

proyecto Service.
6. Haz clic en el botón Send de Postman. Observa el valor de la variable Result en Visual Studio.
Cuando se crean instancias de tipos de entidades POCO, el Entity Framework frecuentemente

crea instancias de tipos derivados generados dinámicamente que actúan como un proxy para
la entidad. Este proxy sobrescribe algunas propiedades virtuales de la entidad para insertar
código que realizan acciones automáticamente cuando la propiedad es accedida. Por ejemplo,
este mecanismo es utilizado para soportar la carga diferida o aplazada conocida como Lazy
Loadind de relaciones. Lazy Loading es una técnica utilizada para aplazar la inicialización de
un objeto hasta el punto en el cual sea necesitado.
7. Detén la aplicación.
8. Abre el archivo RepositoryFactory.cs del proyecto DAL y modifica el código del constructor
de la siguiente manera.
public static IRepository CreateRepository()

{
var Context = new Entities.NWindEntities();
Context.Configuration.ProxyCreationEnabled = false;
return new EFRepository(Context);
}
9. Selecciona la opción Debug > Start New Instance del menú contextual del proyecto Service.
10. En Postman vuelve a enviar la petición para verificar su funcionamiento. Puedes notar que
ahora obtienes el resultado esperado.
11. Prueba ahora el método FilterProductsByCategory. Configura Postman con los siguientes
datos y observa el resultado en la pantalla.
Método GET
URL http://localhost:50508/api/nwind/FilterProductsByCategoryID/1
Remplaza el id por uno que exista en tu base de datos
12. Prueba el método CreateCategory con los siguientes datos.
Método POST
URL http://localhost:50508/api/nwind/CreateCategory
Body/Raw/Json {
"CategoryName": "Frutas",
"Description": "Manzana, peras, naranjas..."
Observa el resultado, podrás notar que devuelve el objeto creado, por lo que ahora
conocemos el ID de la nueva categoría.
13. Prueba el método UpdateProduct ingresando la siguiente información en Postman.
Método POST
URL http://localhost:50508/api/nwind/UpdateProduct
Body/Raw/Json {
“ProductID”: 1,
"ProductName":"Frijol***modificado***",
"CategoryID":1,
"UnitsInStock":0,
"UnitPrice":25
}
El resultado es el siguiente.
14. Finalmente prueba la eliminación de un producto ingresando los siguientes datos en

Postman.
Método GET
URL http://localhost:50508/api/nwind/DeleteProduct/1
Remplaza el id de un producto que no tenga existencias para

que pueda ser eliminado
La siguiente imagen muestra el resultado.
En este ejercicio probamos la funcionalidad de la Capa de Servicio.
Lección 5
Creando la capa de Presentación
La capa de presentación, también conocida como la Interfaz gráfica de la aplicación, permite al usuario
interactuar con el sistema.
En esta lección realizaremos una serie de ejercicios que nos perimirán incluir varias capas de
presentación a una aplicación, entre las que se incluye una aplicación Web MVC, aplicaciones de
escritorio WPF y aplicaciones multiplataforma con Xamarin.Forms.
Al finalizar esta lección los participantes contarán con las habilidades y conocimientos para:
• Crear una biblioteca proxy.
• Crear la capa de presentación MVC.
• Crear la capa de presentación WPF.
• Crear la capa de presentación Xamarin.Forms.
Laboratorio
Creando una biblioteca Proxy
Para facilitar el consumo del servicio podemos crear una biblioteca de clases que funcione como un
Proxy. Una aplicación cliente podrá utilizar la clase Proxy para que a través de esta pueda consumir la
funcionalidad del servicio.
1. Agrega un nuevo proyecto a la solución de tipo Class library .NET Standard con el nombre
NWindProxyService.
2. Renombra el archivo Class1.cs generado automáticamente por Proxy.
3. Agrega las referencias de los proyectos SLC y Entities al proyecto NWindProxyService.
4. Modifica la definición de la clase Proxy para indicar que deseamos implementar la interface
IService.
public class Proxy:IService

{
}
5. Agrega el siguiente código para importar los espacios de nombres del contrato del Servicio y
el proyecto Entities.
using SLC;
using Entities;
Para consumir la Web API utilizaremos la clase HTTPClient y el paquete Newtonsoft.Json.
6. Agrega el paquete Newtonsoft.Json al proyecto NWindProxyService a través del

administrador de paquetes NuGet.
7. Agrega a la clase Proxy, una variable con la dirección base del servicio web.
public class Proxy : IService

{
string BaseAddress = "http://localhost:50508";
}
8. Agrega ahora el código que te permitirá enviar peticiones POST al servicio.
public async Task<T> SendPost<T, PostData>

(string requestURI, PostData data)
{
T Result = default(T);
using (var Client = new HttpClient())
{
try
{
// URL Absoluto
requestURI = BaseAddress + requestURI;
Client.DefaultRequestHeaders.Accept.Clear();
Client.DefaultRequestHeaders.Accept.Add
(new MediaTypeWithQualityHeaderValue("application/json"));
var JSONData = JsonConvert.SerializeObject(data);

HttpResponseMessage Response =
await Client.PostAsync(requestURI,
new StringContent(JSONData.ToString(),
Encoding.UTF8, "application/json"));
var ResultWebAPI = await Response.Content.ReadAsStringAsync();

Result = JsonConvert.DeserializeObject<T>(ResultWebAPI);
}
catch (Exception ex)
{
// Manejar la excepción
}
}
return Result;
}
9. Agrega los siguientes espacios de nombres al archivo Proxy.cs.
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
10. Agrega el método para enviar peticiones GET al servicio.
public async Task<T> SendGet<T>(string requestURI)

{
T Result = default(T);
using (var Client = new HttpClient())
{
try
{
requestURI = BaseAddress + requestURI; // URL Absoluto
Client.DefaultRequestHeaders.Accept.Clear();
Client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
var ResultJSON = await Client.GetStringAsync(requestURI);

Result = JsonConvert.DeserializeObject<T>(ResultJSON);
}
catch (Exception ex)
{
// Manejar la excepción
}
}
return Result;
}
11. Implementa contrato del servicio. Por cada método síncrono, se crea un método asíncrono. El
código es el siguiente.
public async Task<Product> CreateProductAsync(Product newProduct)

{
return await SendPost<Product, Product>
("/api/nwind/createproduct", newProduct);
}
public Product CreateProduct(Product newProduct)
{
// Ejecutar la tarea en un nuevo hilo
// para que no se bloquee el hilo síncrono
// con Wait esperamos la operación asíncrona
Task.Run(async () => Result =
await CreateProductAsync(newProduct)).Wait();
return Result;
}
public async Task<Product> RetrieveProductByIDAsync(int ID)

{
return await SendGet<Product>($"/api/nwind/RetrieveProductByID/{ID}");
}
public Product RetrieveProductByID(int ID)

{
Task.Run(async () =>
Result = await RetrieveProductByIDAsync(ID)).Wait();
return Result;
}
public async Task<bool> UpdateProductAsync(Product productToUpdate)

{
return await SendPost<bool, Product>
("/api/nwind/UpdateProduct", productToUpdate);
}
public bool UpdateProduct(Product productToUpdate)
{
Task.Run(async () => Result = await
UpdateProductAsync(productToUpdate)).Wait();
return Result;
}
public async Task<bool> DeleteProductAsync(int ID)

{
return await SendGet<bool>($"/api/nwind/DeleteProduct/{ID}");
}
public bool DeleteProduct(int ID)
{
Task.Run(async () => Result = await DeleteProductAsync(ID)).Wait();
return Result;
}
public async Task<List<Product>> FilterProductsByCategoryIDAsync(int ID)

{
return await SendGet<List<Product>>
($"/api/nwind/FilterProductsByCategoryID/{ID}");
}
public List<Product> FilterProductsByCategoryID(int ID)

{
List<Product> Result = null;
FilterProductsByCategoryIDAsync(ID)).Wait();
return Result;
}
public async Task<Category> CreateCategoryAsync(Category newCategory)

{
return await SendPost<Category, Category>
("/api/nwind/CreateCategory", newCategory);
}
public Category CreateCategory(Category newCategory)

{
Category Result = null;
CreateCategoryAsync(newCategory)).Wait();
return Result;
}
12. Compila la solución y verifica que compile correctamente.
En este momento ya podemos empezar a crear la capa de presentación de los distintos clientes que
consumirán el servicio.
Laboratorio
Creando una aplicación MVC
El Modelo Vista Controlador (Model View Controller - MVC) es un patrón de arquitectura de software
que separa la interfaz de usuario, esto es, la capa de presentación, de las demás capas como la capa
de datos, la capa de acceso a datos y la lógica de negocio o la capa de servicio.
Una aplicación MVC está compuesta por el Modelo (Model) que contiene los datos y la lógica de
negocio, la Vista (View) que genera la interfaz de usuario y el Controlador (Controller) que interactúa
con el usuario.
Según esto, el modelo de una aplicación MVC puede estar representado por la capa de servicio o bien
por la capa de lógica.
Veamos el primer caso donde el modelo está representado por la capa de servicio.
1. Agrega a la solución un nuevo proyecto de tipo ASP .NET Web Application (.NET Framework)
con el nombre de NWind.MVCPLS.
2. En la ventana New ASP.NET Web Application elige la plantilla Empty con la estructura de
folders MVC
3. Agrega la referencia de los proyectos NWindProxyService y Entities.
4. Instala el paquete NuGet Newtonsoft.Json. Este paquete es requerido por el Assembly

NWindProxyService.
5. Selecciona la opción Add > Controller… del menú contextual del nodo Controllers del proyecto
MVC.
6. En la ventana Add Scaffold selecciona la plantilla MVC 5 Controller - Empty.
7. Ingresa Home como nombre del controlador y haz clic en el botón Add.
La clase HomeController será agregada.
public class HomeController : Controller

{
// GET: Home
public ActionResult Index()
{
return View();
}
}
8. Agrega el siguiente código al inicio del archivo HomeController.cs para importar los espacios
de nombres NWindProxyService y Entities.
using NWindProxyService;
using Entities;
En la aplicación MVC agregaremos la funcionalidad para permitir al usuario buscar los

productos que pertenecen a una categoría especifica.
9. Haz clic con el botón derecho del mouse sobre el método Index para mostrar su menú
contextual.
10. Selecciona la opción Add View… para agregar una vista (View) para el método.
11. En la ventana Add View proporciona la información que se muestra en la siguiente imagen y
haz clic en Add para agregar la nueva vista.
El archivo Views\Home\Index.cshtml habrá sido creado.
12. Modifica el elemento <body> del archivo Index.cshtml con el siguiente código.
<body>
@using (Html.BeginForm())
{
<div>ID de categoría:</div>
<div><input type="text" name="id" /></div>
<div><input type="submit" value="Buscar" /></div>
}
</body>
Este código mostrará al usuario un formulario donde podrá proporcionar el ID de la categoría

a buscar.
13. Abre el archivo HomeController.cs y agrega el siguiente método de acción. Este método será
ejecutado cuando el usuario haga clic en el botón submit del formulario.
[HttpPost]
public ActionResult Index(int id)
{
// Obtener los productos de la categoría
var Proxy = new Proxy();
var Products =
Proxy.FilterProductsByCategoryID(id);
return View("ProductList", Products);
}
El código anterior devolverá la vista ProductList conteniendo la lista de productos de la

categoría solicitada.
14. Selecciona la opción Add View del menú contextual del método agregado en el paso anterior
para agregar una vista vacía con el nombre ProductList tal y como se muestra en la siguiente
imagen.
El archivo Views\Home\ProductList.cshtml será agregado.
15. Agrega el siguiente código al inicio del archivo ProductList.cshtml para definir el tipo de
modelo asociado a la vista. El modelo de la vista contiene los datos a ser mostrados por la vista.
@model List<Entities.Product>
16. Modifica el elemento <body> de la vista para generar una tabla con los elementos que reciba
en el modelo.
<body>
<table>
<tr>
<th>ID</th>
<th>Nombre</th>
<th>Precio unitario</th>
<th>Unidades en existencia</th>
</tr>
@foreach (var Product in Model)
{
<tr>
<td>@Product.ProductID</td>
<td>@Product.ProductName</td>
<td>@Product.UnitPrice</td>
<td>@Product.UnitsInStock</td>
</tr>
}
</table>
</body>
Para probar la aplicación, el Servicio debe estar en ejecución.
17. Selecciona la opción Properties del menú contextual de la solución.
18. En la ventana de propiedades selecciona la opción Multiple startup projects.
19. En la lista de proyectos establece la opción Start tanto en el Servicio como la aplicación MVC.
20. Haz clic en OK para cerrar la ventana de propiedades de la solución.
21. Ejecuta la aplicación haciendo clic en el botón Start en la barra de herramientas de Visual
Studio.
2 ventanas del navegador Web serán lanzadas. La del servicio mostrará un mensaje de error
ya que no tiene una interfaz de usuario a mostrar.
Y la de la aplicación MVC solicitando el ID de la categoría a buscar.
22. En la ventana de la aplicación MVC proporciona el ID de una categoría existente y haz clic en
el botón Buscar.
Se mostrará una página similar a la siguiente.
El siguiente paso será agregar la funcionalidad para permitirle al usuario ver el detalle de un
producto.
23. Abre el archivo ProductList.cshtml y modifica el código que muestra el ID del producto para
incluir un enlace de la siguiente manera.
<tr>
<td>@Html.ActionLink(Product.ProductID.ToString(), "Details",
new {id = Product.ProductID})
</td>
<td>@Product.ProductName</td>
<td>@Product.UnitPrice</td>
<td>@Product.UnitsInStock</td>
</tr>
Cuando el usuario haga clic en el ID del producto, se mostrará una nueva página Details con
los datos del producto.
24. Agrega el siguiente método de acción en el controlador HomeController.
[HttpGet]
public ActionResult Details(int id)
{
var Model = Proxy.RetrieveProductByID(id);
return View(Model);
}
El siguiente paso será crear la vista del método Details.
25. Genera la vista del método Details con la información que se muestra en la siguiente imagen.
El archivo Views\Home\Details.cshtml será creado.
26. Agrega el siguiente código al inicio del archivo Details.cshtml para definir el tipo del modelo
de la vista.
@model Entities.Product
27. Modifica el elemento <body> de la vista Details para mostrar los datos del producto. El código
es el siguiente.
<body>
<div>
ID: @Model.ProductID
</div>
<div>
Nombre: @Model.ProductName
</div>
<div>
Precio: @Model.UnitPrice
</div>
<div>
Existencia: @Model.UnitsInStock
</div>
</body>
28. Ejecuta la aplicación.
29. Ingresa el ID de una categoría existente y haz clic en el botón Buscar. Te será mostrada la
página con el resultado.
30. En la página con el resultado haz clic en el enlace del ID del producto para ver el detalle.
Se mostrará la página con el detalle del producto.
Implementemos ahora la funcionalidad para crear, actualizar y eliminar un producto.
31. Agrega el siguiente código en la clase HomeController para mostrar una página al usuario
donde podrá crear, modificar o eliminar un producto.
public ActionResult CUD(int id = 0)

{
var Model = new Product();
if (id != 0)
{
Model = Proxy.RetrieveProductByID(id);
}
return View(Model);
}
32. Agrega la vista que devolverá el método CUD utilizando los datos que se muestran en la
siguiente imagen.
33. Abre el archivo Views\Home\CUD.cshtml creado y agrega el siguiente código al inicio del
archivo para definir el tipo del modelo de la vista.
@model Entities.Product
34. Agrega el siguiente código dentro de la etiqueta <body> de la vista CUD.
@using (Html.BeginForm())
{
<div>ID: @Html.TextBoxFor(p => p.ProductID)</div>
<div>Nombre: @Html.TextBoxFor(p => p.ProductName)</div>
<div>Precio: @Html.TextBoxFor(p => p.UnitPrice)</div>
<div>Existencia: @Html.TextBoxFor(p => p.UnitsInStock)</div>
<div>Categoria: @Html.TextBoxFor(p => p.CategoryID)</div>

<div><input type="submit" name="CreateBtn" value="Crear" /></div>
<div><input type="submit" name="UpdateBtn" value="Actualizar" /></div>
<div><input type="submit" name="DeleteBtn" value="Eliminar" /></div>
}
Este código mostrará un formulario al usuario desplegando los datos de un producto y 3

botones que le permitirán Crear, Actualizar o Eliminar un producto.
35. Agrega el siguiente código al controlador Home para responder a la selección del usuario.
[HttpPost]
public ActionResult CUD(Product newProduct,
string CreateBtn, string UpdateBtn, string DeleteBtn)
{
Product Product;
ActionResult Result = View();
if (CreateBtn != null) // ¿Crear un producto?
{
Product = Proxy.CreateProduct(newProduct);
{
Result = RedirectToAction("CUD", new { id = Product.ProductID });
}
}
else if (UpdateBtn != null) // ¿Modificar un producto?
{
var IsUpdate = Proxy.UpdateProduct(newProduct);
if (IsUpdate)
{
Result = Content("El producto se ha actualizado");
}
}
else if (DeleteBtn != null) // ¿Eliminar un producto?
{
var DeletedProduct = Proxy.DeleteProduct(newProduct.ProductID);
if (DeletedProduct)
{
Result = Content("El producto se ha eliminado");
}
}
return Result;
}
36. Ejecuta nuevamente la aplicación e invoca al método de acción CUD.
Podrás ver el formulario con las 3 opciones disponibles.
37. Ingresa los datos de un nuevo producto y haz clic en el botón Crear para probar la funcionalidad
de creación de nuevos productos. No es necesario especificar el valor del ID, este es creado
por la capa de datos automáticamente.
La petición será procesada y se mostrará nuevamente esta página con los datos del nuevo
producto creado incluyendo el ID correspondiente.
38. Modifica los datos del producto y haz clic en el botón Actualizar.
Se mostrará un mensaje indicando que el producto ha sido actualizado.
39. Regresa a la página anterior.
40. Haz clic en el botón Eliminar para eliminar el producto.
Se mostrará un mensaje indicando que el producto ha sido eliminado.
Para consumir la capa de lógica en lugar de la capa de servicio es tan sencillo como agregar la
referencia al Assembly que contiene la capa de lógica.
41. Elimina la referencia al proyecto Service.
42. Elimina el código que importa el espacio de nombres NWindProxyService en el controlador

Home.
43. Compila la aplicación. Notarás que marca varios errores.
44. En el proyecto MVC, agrega la referencia al Assembly BLL que contiene la lógica de negocios.
45. Modifica el código del controlador Home para invocar directamente a los métodos de la capa
de negocios.
[HttpPost]
public ActionResult Index(int id)
{
// Obtener los productos de la categoría
var Proxy = new BLL.Products();
var Products =
Proxy.FilterByCategoryID(id);
return View("ProductList", Products);
}
[HttpGet]
public ActionResult Details(int id)
{
var Model = Proxy.RetrieveByID(id);
return View(Model);
}
public ActionResult CUD(int id = 0)

{
var Model = new Product();
if (id != 0)
{
Model = Proxy.RetrieveByID(id);
}
return View(Model);
}
[HttpPost]
public ActionResult CUD(Product newProduct,
string CreateBtn, string UpdateBtn, string DeleteBtn)
{
Product Product;
ActionResult Result = View();
if (CreateBtn != null) // ¿Crear un producto?
{
Product = Proxy.Create(newProduct);
{
Result = RedirectToAction("CUD", new { id = Product.ProductID });
}
}
else if (UpdateBtn != null) // ¿Modificar un producto?
{
var IsUpdate = Proxy.Update(newProduct);
if (IsUpdate)
{
Result = Content("El producto se ha actualizado");
}
}
else if (DeleteBtn != null) // ¿Eliminar un producto?
{
var DeletedProduct = Proxy.Delete(newProduct.ProductID);
if (DeletedProduct)
{
Result = Content("El producto se ha eliminado");
}
}
return Result;
}
46. Agrega la cadena de conexión que requiere Entity Framework copiándola del archivo
App.config del proyecto DAL hacia el archivo Web.config de la aplicación MVC.
47. Agrega el paquete NuGet EntitiyFramework al proyecto NWind.MVCPLS.
48. Prueba nuevamente la aplicación, todo debe funcionar sin problemas.
Laboratorio
Creando una aplicación WPF
Model-View-ViewModel (MVVM) es un patrón de arquitectura de software que también se
caracteriza por separar la interfaz de usuario de las demás capas como la capa de datos, la capa de
acceso a datos y la lógica de negocio o la capa de servicio.
Las aplicaciones WPF pueden ser diseñadas para implementar el patrón MVVM creando la interfaz de
usuario con código XAML e implementado un ViewModel para acceder a la lógica de negocios y acceso
a Datos.
En este ejercicio agregaremos una aplicación Windows Presentation Foundation para crear la
presentación muy similar a la aplicación MVC.
1. Agrega a la solución un proyecto de tipo WPF App (.NET Framework) con el nombre
NWind.WPF.
2. Agrega el paquete NuGet Newtonsoft.Json necesario para el assemby NWind.ProxyService.
Comencemos definiendo la interfaz gráfica de la aplicación. La primera pantalla permitirá al

usuario buscar los productos pertenecientes a una categoría, seleccionar un producto de la
lista y ver el detalle.
3. Abre el archivo MainWindows.xaml y modifica el elemento <Grid> con el siguiente código.
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0">
<StackPanel Orientation="Horizontal">
<Label Margin="10">Categoria:</Label>
<TextBox Width="50" Margin="10" Text="{Binding CategoryID}"/>
<Button Content="Buscar" Width="80" Margin="10"
Command="{Binding SearchProductsCommand}"/>
<Button Content="Ver Detalle" Margin="10" Width="100"
Command="{Binding SearchProductByCommand}"/>
</StackPanel>
<DataGrid ItemsSource="{Binding Path=Products}"
SelectedItem="{Binding ProductSelected}">
</DataGrid>
</StackPanel>
<StackPanel Margin="30,0,0,0" Grid.Column="1">
<Label HorizontalAlignment="Center">Detalle del Producto</Label>
<Label>ID:</Label>
<Label Content="{Binding ProductID}"/>
</StackPanel>
<Label>Nombre:</Label>
<Label Content="{Binding ProductName}"/>
</StackPanel>
<StackPanel Orientation="Horizontal"/>
<Label>Stock:</Label>
<Label Content="{Binding UnitsInStock}"/>
<Label>Precio:</Label>
<Label Content="{Binding Price}"/>
</StackPanel>
</StackPanel>
</Grid>
El código XAML permite enlazar los elementos de la interfaz de usuario al ViewModel a través
de una característica conocida como Data Binding o Enlace de datos. En el código anterior
puedes observar la extensión de marcado XAML Binding que permite establecer el enlace
entre una propiedad de un elemento XAML con una propiedad de un objeto C#.
Para que el usuario también pueda crear, actualizar y eliminar un producto, agregaremos una
nueva ventana.
4. Agrega un nuevo archivo XAML llamado CUD.xaml seleccionando la opción Add > Window…
del menú contextual del proyecto WPF.
5. Remplaza el elemento <Grid> del archivo CUD.xaml con el siguiente código.
<StackPanel Margin="10" >

<Label HorizontalAlignment="Center">Producto nuevo</Label>
<Label>ID:</Label>
<TextBox Text="{Binding ProductID, Mode=TwoWay}"
Width="100" IsReadOnly="True"/>
</StackPanel>
<TextBox Text="{Binding ProductName, Mode=TwoWay}"
Width="100"/>
</StackPanel>
<Label>ID de Categoria:</Label>
<TextBox Text="{Binding CategoryID, Mode=TwoWay}"

Width="100"/>
</StackPanel>
<TextBox Text="{Binding UnitsInStock, Mode=TwoWay}"
Width="100"/>
</StackPanel>
<TextBox Text="{Binding UnitPrice, Mode=TwoWay}"
Width="100"/>
</StackPanel>
<Button Content="Crear Producto" Width="100"
Command="{Binding CreateProductCommand}"/>
<Button Content="Actualizar Producto" Width="100" Margin="10"
Command="{Binding UpdateProductCommand}"/>
<Button Content="Eliminar Producto" Width="100" Margin="10"
Command="{Binding DeleteProductCommand}"/>
</StackPanel>
6. Compila la aplicación y verifica que compile correctamente.
En este momento la aplicación únicamente define la interfaz de usuario, en el siguiente ejercicio

crearemos el ViewModel para acceder a los datos.
Laboratorio
Creando el elemento ViewModel
Implementar el patrón MVVM nos permite separar las responsabilidades entre la vista y el modelo (la
lógica de negocios y de acceso a datos). En este momento tenemos únicamente las vistas en nuestra
aplicación WPF y el modelo estará representado por el objeto Proxy o Servicio.
El ViewModel nos permite enlazar a los elementos Vista y Modelo. El mismo ViewModel puede ser
utilizado en una aplicación WPF, pero también puede ser utilizado para una aplicación Xamarin.Forms
que también nos permite implementar el patrón MVVM. Pensando en la reutilización de código,
encapsularemos el ViewModel en otra capa.
1. Agrega a la solución un nuevo proyecto llamado NWind.ViewModel de tipo Class Library (.NET
Standard).
2. Agrega las referencias de los proyectos Entities y NWindProxyService al nuevo proyecto

NWind.ViewModel.
3. Agrega el paquete NuGet Newtonsoft.Json necesario para el Assembly NWindProxyService.
4. Renombra el archivo Class1.cs del nuevo proyecto con el nombre ViewModelBase.
5. Modifica el código de la clase ViewModelBase para implementar la interface

INotifyPropertyChanged.
public class ViewModelBase : INotifyPropertyChanged

{
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged
([CallerMemberName]string propertyName = null)
{
var Handler = PropertyChanged;
if (Handler != null)
{
Handler(this,
new PropertyChangedEventArgs(propertyName));
}
}
}
La clase ViewModelBase implementa la interface INotifyPropertyChanged cuya función

principal es la de notificar los cambios que sucedan en las propiedades del ViewModel para
que la vista pueda reflejar dichos cambios.
6. Agrega el siguiente código al inicio del archivo ViewModelBase.cs para importar el espacio
de nombres System.ComponentModel que define la interface INotifyPropertyChanged y
System.Runtime.CompilerServices que define el atributo CallerMemberName.
using System.ComponentModel;
using System.Runtime.CompilerServices;
7. Agrega un nuevo archivo de clase llamado CommandDelegate.cs al proyecto ViewModel.
8. Modifica la clase CommandDelegate para que sea similar a lo siguiente.
public class CommandDelegate : ICommand

{
Action<object> ExecuteDelegate;
Func<object, bool> CanExecuteDelegate;
public CommandDelegate(Func<object, bool> canExecuteDelegate,

Action<object> executeDelegate)
{
this.CanExecuteDelegate = canExecuteDelegate;
this.ExecuteDelegate = executeDelegate;
}
public event EventHandler CanExecuteChanged;
public void ChangeCanExecute()

{
var Handler = CanExecuteChanged;
Handler?.Invoke(this, EventArgs.Empty);
}
public bool CanExecute(object parameter)
{
var Handler = CanExecuteDelegate;
if (Handler != null)
{
Result = Handler(parameter);
}
return Result;
}
public void Execute(object parameter)

{
var Handler = ExecuteDelegate;
Handler?.Invoke(parameter);
}
}
La clase CommandDelegate implementa la interface ICommand que permite enlazar los

botones en la vista a métodos en el ViewModel. La interface ICommand define el método
CanExecute que es ejecutado para verificar si el comando puede ser ejecutado.
El método Execute contiene el código que será ejecutado por el comando.
El evento CanExecuteChanged permite notificar cuando hay un cambio que permita la

ejecución o no ejecución del método Execute.
9. Agrega el siguiente código al inicio del archivo CommandDelegate.cs para importar el espacio
de nombres que define a la interface ICommand.
using System.Windows.Input;
Ahora crearemos la clase que será el ViewModel para la pantalla principal de la aplicación.
10. Agrega un nuevo archivo de clase con el nombre Product.cs en el proyecto ViewModel.
11. Agrega el siguiente código al inicio del archivo Product.cs para importar el espacio de nombres
Entities.
using Entities;
12. Modifica el código de la clase Product para que sea similar al siguiente código.
public class Product : ViewModelBase

{
public Product()
{
InitializeViewModel();
}
void InitializeViewModel()
{
Products = new List<Entities.Product>();
SearchProductsCommand = new CommandDelegate
((o) => { return true; },
(o) =>
{
var Proxy = new NWindProxyService.Proxy();
Products = Proxy.FilterProductsByCategoryID(CategoryID);
});
SearchProductByCommand = new CommandDelegate
(o) =>
{
if (ProductSelected.ProductID != 0)
{
var p = Proxy.RetrieveProductByID(
ProductSelected.ProductID);
ProductName = p.ProductName;
ProductID = p.ProductID;
UnitsInStock = p.UnitsInStock;
Price = p.UnitPrice; ;
OnPropertyChanged("ProductID");
OnPropertyChanged("ProductName");
OnPropertyChanged("Price");
OnPropertyChanged("UnitsInStock");
}
});
}
#region Properties
private int CategoryID_BF;

public int CategoryID
{
get { return CategoryID_BF; }
set
{
CategoryID_BF = value;
OnPropertyChanged();
}
}
private List<Entities.Product> Products_BF;
public List<Entities.Product> Products
{
get { return Products_BF; }
set
{
Products_BF = value;
}
}
private Entities.Product ProductSelected_BF;
public Entities.Product ProductSelected
{
get { return ProductSelected_BF; }
set
{
ProductSelected_BF = value;
}
}
private string ProductName_BF;

public string ProductName
{
get { return ProductName_BF; }
set { ProductName_BF = value; }
}
private int ProductID_BF;

public int ProductID
{
get { return ProductID_BF; }
set { ProductID_BF = value; }
}
private decimal UnitsInStock_BF;

public decimal UnitsInStock
{
get { return UnitsInStock_BF; }
set { UnitsInStock_BF = value; }
}
private decimal Price_BF;

public decimal Price
{
get { return Price_BF; }
set { Price_BF = value; }

}
#endregion
public CommandDelegate SearchProductsCommand { get; set; }
public CommandDelegate SearchProductByCommand { get; set; }
A continuación, crearemos el ViewModel para la vista que nos permitirá crear, actualizar y
eliminar un producto.
13. Agrega un nuevo archivo de clase llamado CUD.cs al proyecto ViewModel.
14. Modifica el código de la clase para que sea similar a lo siguiente.
public class CUD : ViewModelBase

{
public CUD()
{
CreateProductCommand = new CommandDelegate

(o) =>
{
var NewProduct = new Entities.Product
{
ProductName = ProductName_BF,
CategoryID = CategoryID_BF,
UnitsInStock = UnitsInStock_BF,
UnitPrice = UnitPrice_BF
};
NewProduct = Proxy.CreateProduct(NewProduct);
ProductID = NewProduct.ProductID;
});
UpdateProductCommand = new CommandDelegate
(o) =>
{
var CurrentProduct = new Entities.Product
{
ProductID = ProductID_BF,
ProductName = ProductName_BF,
CategoryID = CategoryID_BF,
UnitsInStock = UnitsInStock_BF,
UnitPrice = UnitPrice_BF
};
var Modified = Proxy.UpdateProduct(CurrentProduct);
});
DeleteProductCommand = new CommandDelegate

(o) =>
{

var IsDeleted = Proxy.DeleteProduct(ProductID);
if (IsDeleted)
{
ProductID = 0;
ProductName = "";
CategoryID = 0;
UnitsInStock = 0;
UnitPrice = 0;
}
});
}
private int ProductID_BF;

public int ProductID
{
get { return ProductID_BF; }
set
{
if (ProductID_BF != value)
{
ProductID_BF = value;
}
}
}
private string ProductName_BF;

public string ProductName
{
get { return ProductName_BF; }
set
{
if (ProductName_BF != value)
{
ProductName_BF = value;
}
}
}
private int CategoryID_BF;

public int CategoryID
{
get { return CategoryID_BF; }
set
{
if (CategoryID_BF != value)
{
CategoryID_BF = value;
}
}
}
private decimal UnitsInStock_BF;

public decimal UnitsInStock
{
get { return UnitsInStock_BF; }
set
{
if (UnitsInStock_BF != value)
{
UnitsInStock_BF = value;
}
}
}
private decimal UnitPrice_BF;

public decimal UnitPrice
{
get { return UnitPrice_BF; }
set
{
if (UnitPrice_BF != value)
{
UnitPrice_BF = value;
}
}
}
public CommandDelegate CreateProductCommand { get; set; }

public CommandDelegate UpdateProductCommand { get; set; }
public CommandDelegate DeleteProductCommand { get; set; }
}
En este momento, el ViewModel está listo para ser utilizado por la Vista. En el siguiente ejercicio
aprenderás a enlazar el ViewModel con la interfaz de usuario.
Laboratorio
Probando la aplicación WPF
Una vez que tenemos el ViewModel listo, es momento de enlazarlo con la interfaz de usuario para
probar que la aplicación funcione correctamente. Para ello es necesario establecer el Contexto de
datos en la aplicación WPF.
1. En el proyecto NWind.WPF agrega la referencia al Assembly NWind.ViewModel.
2. Abre el archivo MainWindow.xaml del proyecto NWind.WPF.
3. Agrega el siguiente código dentro del elemento Window para definir el espacio de nombres
XML que hace referencia al espacio de nombres .NET NWind.ViewModel del Assembly
NWind.ViewModel.
<Window x:Class="NWind.WPF.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:NWind.WPF"
xmlns:vm="clr-namespace:NWind.ViewModel;assembly=NWind.ViewModel"
mc:Ignorable="d"
Title="MainWindow" Height="450" Width="800">
4. Agrega el siguiente elemento de propiedad Window.DataContext para establecer la clase

Product del ViewModel como el contexto de datos para la ventana MainWindow.
Title="MainWindow" Height="450" Width="800">

<Window.DataContext>
<vm:Product/>
</Window.DataContext>
<Grid>
5. Abre el archivo CUD.xaml.
6. De la misma forma que en un paso anterior, agrega el siguiente código dentro del elemento
Window para definir el espacio de nombres XML que hace referencia al espacio de nombres
.NET NWind.ViewModel del Assembly NWind.ViewModel.
xmlns:vm="clr-namespace:NWind.ViewModel;assembly=NWind.ViewModel"
7. Agrega el siguiente elemento de propiedad Window.DataContext para establecer la clase CUD

del ViewModel como el contexto de datos para la ventana CUD.
<Window.DataContext>
<vm:CUD/>
</Window.DataContext>
8. Compila la aplicación y verifica que no haya errores.
9. Configura las propiedades de la solución para que únicamente los proyectos Service y
NWind.WPF sean los proyectos de inicio.
10. Ejecuta la aplicación haciendo clic en el botón Start de la barra de herramientas de Visual
Studio.
11. En la aplicación WPF, ingresa el ID de una categoría existente y haz clic en el botón Buscar.
Puedes ver que se muestra el resultado en la parte inferior.
12. Selecciona un producto del resultado mostrado y haz clic en el botón Ver Detalle para ver el
detalle del producto seleccionado.
Ahora podemos probar la funcionalidad de la ventana CUD.xaml.
13. Regresa a Visual Studio y detén la ejecución de la aplicación.
14. Abre el archivo App.xaml del proyecto WPF.
15. Modifica la propiedad StartupUri para especificar el archivo CUD.xaml como el archivo que
tiene la ventana de inicio de la aplicación.
StartupUri="CUD.xaml"
16. Ejecuta nuevamente la aplicación.
17. Ingresa los datos necesarios para crear un nuevo producto y haz clic en el botón Crear.
Como resultado, la aplicación muestra el ID del producto creado.
18. Modifica el producto actual cambiando algunos datos y haz clic en el botón Actualizar
Producto.
Si observas en la base de datos, el producto habrá sido actualizado y como tiene una existencia
de 0, el producto puede ser eliminado.
19. Haz clic en el botón Eliminar Producto. Los datos del producto serán eliminados.
Como recomendación, al probar la funcionalidad de crear, actualizar o eliminar, puedes

examinar la tabla Products en la base de datos NWind.
Laboratorio
Creando una aplicación Xamarin.Forms
Un principio clave de la creación de aplicaciones multiplataforma es crear una arquitectura que
maximice la compartición de código a través de las distintas plataformas. La adhesión a los siguientes
principios de programación orientados a objetos ayuda a diseñar una buena arquitectura de una
aplicación:
• Encapsulación. Garantiza que las clases e incluso las capas de la arquitectura sólo exponen una
API mínima que realiza las funciones requeridas y oculta los detalles de la implementación. A
nivel de clase, esto significa que los objetos se comportan como "cajas negras" y que el código
que las consume no necesita saber cómo realizan sus tareas. A nivel de arquitectura, esto
sugiere implementar patrones como Facade que fomenta una API simplificada que orquesta
interacciones más complejas en lugar del código ubicado en las capas más abstractas. Por
ejemplo, esto significa que el código de la interfaz de usuario sólo debe ser responsable de
mostrar pantallas y aceptar la entrada de usuario, pero nunca debería interactuar con la base
de datos directamente. Del mismo modo, el código de acceso a datos sólo debería leer y
escribir en la base de datos, pero nunca interactuar directamente con botones o etiquetas de
la interfaz de usuario.
• Separación de responsabilidades. Debemos asegurarnos de que cada componente (tanto a

nivel de arquitectura como de clase) tenga un propósito claro y bien definido. Cada
componente debe realizar sólo sus tareas definidas y exponer esa funcionalidad a través de
una API que sea accesible a las otras clases que necesitan utilizarlo.
• Polimorfismo. La programación para una interface (o clase abstracta) que soporte múltiples
implementaciones permite que el código núcleo pueda ser escrito y compartido entre
plataformas al mismo tiempo que también pueda interactuar con características específicas
de la plataforma.
Separar el código en capas hace que las aplicaciones sean más fáciles de entender, probar y mantener.
Se recomienda que el código de cada capa esté físicamente separado (ya sea en directorios o incluso
proyectos independientes para aplicaciones muy grandes), así como lógicamente separado (usando
espacios de nombres).
Patrones de software comunes para desarrollo móvil

Los patrones son una forma establecida para aplicar soluciones recurrentes a problemas comunes.
Existen algunos patrones clave que son útiles para entender la creación de aplicaciones móviles que
puedan ser de fácil mantenimiento y de fácil entendimiento.
• Model, View, ViewModel (MVVM). El patrón Model-View-ViewModel es muy popular con los
Frameworks que soportan la vinculación de datos (data-binding), tal como Xamarin.Forms. Fue
popularizado por SDKs habilitados para XAML como Windows Presentation Foundation (WPF)
y Silverlight donde el ViewModel actúa como un intermediario entre los datos (Model) y la
interfaz de usuario (View) a través de enlace de datos y comandos.
• Model, View, Controller (MVC). Un patrón común y a menudo incomprendido, MVC se utiliza
con mayor frecuencia cuando se crean interfaces de usuario y se requiere una separación entre
la definición de una pantalla de interfaz de usuario (View), el motor detrás de él que maneja
la interacción (Controller) y los datos que lo alimentan (Model). El modelo es una pieza
opcional y, por lo tanto, el núcleo de la comprensión de este patrón se encuentra en la Vista y
el Controlador. MVC es un enfoque popular para aplicaciones iOS.
• Business Facade. También conocido como Manager Pattern, proporciona un punto de entrada
simplificado para trabajos complejos. Por ejemplo, en una aplicación de seguimiento de tareas,
podríamos tener una clase TaskManager con métodos como GetAllTasks(), GetTask(taskID),
SaveTask(task), etc. La clase TaskManager proporciona una fachada al funcionamiento interno
de guardar/recuperar objetos que representan las tareas.
• Singleton. El patrón Singleton proporciona una forma en la que sólo una sola instancia de un
objeto en particular puede existir. Por ejemplo, al utilizar SQLite en aplicaciones móviles, sólo
desearíamos tener una única instancia de la base de datos. El uso del patrón Singleton es una
forma sencilla de garantizar esto.
• Provider. Un patrón acuñado por Microsoft (posiblemente similar al patrón Strategy, o al

patrón Dependency Injection) para fomentar la reutilización de código a través de aplicaciones
Silverlight, WPF y WinForms. El código compartido se puede escribir implementando una
interface o una clase abstracta, y las implementaciones concretas específicas de la plataforma
se escriben y pasan cuando se usa el código.
• Async. No se debe confundir con la palabra clave Async. El patrón Async se utiliza cuando se
necesita ejecutar un trabajo de larga ejecución sin congelar la interfaz de usuario o el
procesamiento actual. En su forma más simple, el patrón Async simplemente describe que las
tareas de larga duración deberían iniciarse en otro subproceso (Thread) mientras el
subproceso actual sigue procesando y esperando una respuesta del proceso en segundo plano
para posteriormente actualizar la interfaz de usuario cuando se devuelven datos y/o estado.
En este laboratorio crearás la arquitectura típica de una solución Xamarin con Visual Studio. La
arquitectura que crearás es solo un ejemplo de la forma en que puede ser estructurada una aplicación
Xamarin multiplataforma, sin embargo, la arquitectura en una aplicación real puede variar
dependiendo de los requerimientos de la aplicación.
La interfaz de usuario para la aplicación Xamarin.Forms será similar a la interfaz de la aplicación WPF,
proporcionándole al usuario la opción de buscar los productos correspondientes de una categoría, ver
el detalle de un producto, así como crear, actualizar y eliminar un producto.
1. Agrega un nuevo proyecto a la solución de tipo Mobile App (Xamarin.Forms) con el nombre
de NWind.Xamarin.
2. En la ventana New Cross Platform App, elije la plantilla Blank App, En la sección plataformas
selecciona al menos una de las plataformas. Como estrategia para compartir código selecciona
la opción .NET Standard.
Observa que en la solución se han agregados 4 proyectos (o menos dependiendo de las

plataformas que hayas seleccionado), uno por cada plataforma seleccionada más uno que
contiene el código compartido por las plataformas.
3. En el proyecto NWind.Xamarin agrega la referencia al proyecto NWind.ViewModel.
4. Agrega el paquete NuGet Newtonsoft.Json al proyecto NWind.Xamarin.
Diseñaremos ahora la vista que permitirá listar los productos de una categoría.
5. Abre el archivo MainPage.xaml y agrega el espacio de nombres del ViewModel al elemento

ContentPage.
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:local="clr-namespace:NWind.Xamarin"
x:Class="NWind.Xamarin.MainPage"
xmlns:vm="clr-namespace:NWind.ViewModel;assembly=NWind.ViewModel">
6. Agrega la clase Product como contexto de datos para esta ventana.
<ContentPage.BindingContext>
<vm:Product/>
</ContentPage.BindingContext>
7. Modifica el elemento <StackLayout> con el siguiente código.
<StackLayout>
<StackLayout>
<StackLayout Orientation="Horizontal">
<Label Margin="10">Categoria:</Label>
<Entry WidthRequest="50" Text="{Binding CategoryID}"/>
<Button Text="Buscar" Margin="10"
Command="{Binding SearchProductsCommand}"/>
<Button Text="Ver Detalle" Margin="10" WidthRequest="100"
Command="{Binding SearchProductByCommand}"/>
</StackLayout>
<ListView ItemsSource="{Binding Path=Products}"
SelectedItem="{Binding ProductSelected}">
<ListView.ItemTemplate>
<DataTemplate>
<ViewCell>
<ViewCell.View>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="1*"/>
</Grid.ColumnDefinitions>
<Label Grid.Column="0"
Text="{Binding ProductID}"/>
Text="{Binding ProductName}"/>
Text="{Binding CategoryID}"/>
Text="{Binding UnitPrice}"/>
</Grid>
</ViewCell.View>
</ViewCell>
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
</StackLayout>
<StackLayout Margin="30,0,0,0" Grid.Column="1">
<Label>Detalle del Producto</Label>
<Label>ID:</Label>
<Label Text="{Binding ProductID}"/>
</StackLayout>
<Label Text="{Binding ProductName}"/>
</StackLayout>
<Label Text="{Binding Price}"/>
</StackLayout>
</StackLayout>
</StackLayout>
El siguiente paso será agregar la vista que permitirá crear, actualizar y eliminar un producto.
8. Agrega al proyecto Xamarin un nuevo elemento de tipo ContentPage con el nombre

CUD.xaml.
9. Agrega el espacio de nombres del proyecto NWind.ViewModel en el elemento ContentPage

del archivo CUD.xaml.
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
x:Class="NWind.Xamarin.CUD"
xmlns:vm="clr-namespace:NWind.ViewModel;assembly=NWind.ViewModel">
10. Establece como Contexto de datos a la clase CUD.
<ContentPage.BindingContext>
<vm:CUD/>
</ContentPage.BindingContext>
11. Sustituye el código dentro del elemento ContentPage.Content por el siguiente.
<ContentPage.Content>
<StackLayout Margin="10" >
<Label >Producto nuevo</Label>
<Label>ID:</Label>
<Entry Text="{Binding ProductID}"
WidthRequest="100"/>
</StackLayout>
<Entry Text="{Binding ProductName}"
</StackLayout>
<Label>ID de Categoria:</Label>
<Entry Text="{Binding CategoryID}"
</StackLayout>
<Entry Text="{Binding UnitsInStock}"
</StackLayout>
<Entry Text="{Binding UnitPrice}"
</StackLayout>
<Button Text="Crear Producto"
Command="{Binding CreateProductCommand}"/>
<Button Text="Actualizar Producto"
Command="{Binding UpdateProductCommand}"/>
<Button Text="Eliminar Producto"
Command="{Binding DeleteProductCommand}"/>
</StackLayout>
</ContentPage.Content>
12. Compila la aplicación y verifica que no haya errores.
En este ejercicio creaste la interfaz de usuario utilizando Xamarin Forms utilizando el mismo
ViewModel realizado para la aplicación WPF.
Laboratorio
Configurando el servicio
De manera predeterminada, Visual Studio utiliza IIS Express para alojar las aplicaciones Web. La
aplicación Web es hospedada en el servidor localhost que es nuestro equipo de desarrollo. Para
probar desde otros equipos o desde emulares iOS o Android, necesitamos una dirección accesible
distinta a localhost. Lo clientes Microsoft ubicados en el mismo equipo de desarrollo pueden acceder
directamente a localhost por lo que no es necesario realizar ninguna configuración al proyecto del
servicio Web API.
Veamos como configurar el proyecto para que el servicio Web API sea hospedado en una dirección
accesible por clientes iOS y Android.
1. Abre con Visual Studio el archivo de configuración de la instancia IIS Express que hospeda el
servicio Web API. Este archivo se encuentra ubicado en la carpeta de la solución, por ejemplo
NWind\.vs\Config\applicationhost.config.
Es importante mencionar que el directorio .vs es un directorio oculto.
2. Localiza el elemento configuration/system.applicationHost/sites/<site name=”Service”.
3. Modifica el elemento binding cambiando localhost por la dirección IP de tu equipo.
<binding protocol="http" bindingInformation="*:50508:{IP de tu equipo}" />
Por ejemplo:
<binding protocol="http" bindingInformation="*:50508:192.168.1.11" />
Es importante mencionar que la dirección y puerto asignados deben estar disponibles para los
clientes remotos por lo que probablemente se deba configurar el FireWall para abrir el puerto
especificado.
4. Guarda los cambios y cierra el archivo.
5. Abre la ventana de propiedades del proyecto Service.
6. En la sección Web modifica el URL del proyecto con la nueva dirección y puerto.
7. Haz clic en el botón Create Virtual Directory.
Te será mostrado un cuadro de diálogo indicándote que el directorio virtual fue creado.
8. Guarda los cambios y ejecuta el Servicio. Puedes notar que ahora la aplicación Web API es
accesible mediante una dirección distinta a localhost.
En este momento el Servicio está listo para poder realizar pruebas de funcionalidad en nuestro
ambiente de desarrollo.
Laboratorio
Probando la Aplicación Xamarin.Forms
Una vez que se ha terminado de configurar el servicio, es posible realizar las pruebas de funcionalidad
de la aplicación Xamarin.Forms.
1. Abre la clase Proxy.cs en el proyecto NWindProxyService.
2. Modifica el valor la variable BaseAddress con la nueva URL del Servicio.
string BaseAddress = "http://192.168.1.11:50508";
Recuerda colocar la IP de tu equipo de desarrollo.
3. Guarda los cambios y compila la Solución.
4. Configura la solución para que únicamente el proyecto Service y el proyecto

NWind.Xamarin.Android sean iniciados al ejecutar la aplicación. (Si lo deseas, puedes probar
con el proyecto de otra plataforma, por ejemplo, iOS o UWP).
5. Ejecuta la aplicación haciendo clic en el botón Start de la barra de herramientas de Visual

Studio.
6. Proporciona un ID de categoría y toca el botón Buscar. Puedes observar el resultado en la parte

inferior.
7. Selecciona un elemento de la lista y toca el botón Ver detalle. Podrás ver el detalle del
producto en la parte inferior de la pantalla.
8. Regresa a Visual Studio y detén la ejecución.
9. Abre el archivo App.xaml.cs del proyecto Xamarin y cambia el valor de la variable MainPage
para establecer una nueva página de inicio.
MainPage = new CUD();
10. Guarda los cambios y ejecuta nuevamente la aplicación.
11. Proporciona los datos de un nuevo producto y toca el botón Crear producto. Podrás observar
que se muestra el ID del nuevo producto.
12. Establece la existencia del producto a 0 y toca el botón Actualizar producto.
13. Finalmente, toca el botón Eliminar producto. Podrás notar que el producto ha sido eliminado.
Es recomendable que por cada operación que hagas (crear, modificar o eliminar) puedas
verificar los datos directamente en la base de datos.
14. Prueba la funcionalidad de la aplicación con las demás plataformas.
Resumen
En este entrenamiento mostramos una forma sencilla de implementar la arquitectura N-Capas (N-
Layers) y N-Niveles (N-Tiers) utilizando herramientas y tecnologías Microsoft.
Las capas que mostramos en este entrenamiento pueden ser más o pueden ser menos dependiendo
de las necesidades en un caso real o incluso dependiendo del arquitecto de software que implemente
la solución.
Con la estructura actual de la aplicación que creamos, podemos subir la capa de datos al servicio SQL
Database de Azure o el servicio Web API lo podemos hospedar en el servicio App Service de Azure para
distribuir nuestra aplicación N-Capas en N-Niveles.
El siguiente paso será poner en práctica lo aprendido.

Freddy Alday Sfarcic-Ncapas

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Freddy Alday Sfarcic-Ncapas

Cargado por

Copyright:

Formatos disponibles

Introducción al desarrollo de aplicaciones

N-Capas con tecnologías Microsoft

Freddy Alday Sfarcic

Objetivos de la lección .................................................................................................................. 67

Acerca del curso

• Definir los conceptos N-Capas (N-Layers) y N-Niveles (N-Tiers).

• Aplicar el modelo N-Capas para el desarrollo de diferentes tipos de aplicaciones.

• Visual Studio 2017.

Contenido del curso

Módulo 1. La Arquitectura N-Capas

Al finalizar este módulo, los participantes podrán:

• Describir los conceptos N-Capas y N-Niveles.

El tema que forma parte de este módulo es:

• Lección 1: Definición de conceptos.

Módulo 2. Desarrollando una aplicación N-Capas

Al finalizar este módulo, los participantes podrán:

• Crear la capa de origen de datos utilizando Microsoft SQL Server.

• Crear la capa de Acceso a datos utilizando Entity Framework.

Los temas que forman parte de este módulo son:

• Lección 1: Creando la capa de datos con SQL Server.

Acerca del módulo

El tema que se cubre en este módulo es:

• Describir los conceptos N-Capas y N-Niveles.

Arquitectura basada en capas

1. La capa de presentación solicita el ID del producto que el usuario desea comprar y se lo

5. La capa de presentación muestra al usuario la respuesta que la capa de lógica le ha

Objetivo de la Arquitectura basada en capas

Comunicación entre las capas de la arquitectura N-Capas

Capa de Acceso a Datos

La función principal de la Capa de Servicio es la de exponer la funcionalidad de la Capa de Lógica de

La función principal de la capa de presentación es la de implementar la funcionalidad requerida para

Beneficios de la Arquitectura N-Capas

Capas Vs Niveles (Layers Vs Tiers)

El Cliente interactúa con el software de la aplicación implementada sobre un servidor independiente

Microsoft Application Architecture Guide, 2nd Edition

Acerca del módulo

Para el ambiente gráfico de Windows, construiremos una aplicación Windows Presentation

• Crear la capa de origen de datos utilizando Microsoft SQL Server.

Los temas que forman parte de este módulo son:

• Lección 1: Creando la capa de datos con SQL Server.

• Crear la capa de datos utilizando Microsoft SQL Server.

Empecemos con SQL Server Management Studio.

1. Abre la aplicación Microsoft SQL Server Management Studio.

2. En la ventana Connect to Server selecciona Database Engine como tipo de servidor.

3. Introduce o selecciona el nombre del servidor SQL Server.

4. Selecciona Windows Authentication como el tipo de autenticación. Sí lo prefieres puedes

5. Haz clic en el botón Connect para realizar la conexión.

Después de realizar la conexión te será mostrada la ventana Object Explorer.

9. En la ventana de diseño de la tabla, registra la siguiente información

Columna Tipo Acepta Valores

12. Guarda la tabla con el nombre Categories.

1. Ejecuta Visual Studio en contexto de Administrador.

3. En la ventana Server Explorer selecciona el icono Connect to Database.

Si la conexión es correcta, te será mostrado un cuadro de diálogo similar al siguiente.

6. Haz clic en el botón OK para cerrar el cuadro de diálogo.

7. Haz clic en el botón OK de la ventana Add Connection para continuar.

En la ventana Server Explorer se habrá agregado la nueva conexión.

8. Expande el contenido de la conexión. Verás una estructura similar a la siguiente.

Crearemos ahora la tabla Products.

Columna Tipo Acepta Valores

12. Establece el campo Is Identity con el valor True.

De manera predeterminada el campo ProductID está marcado como llave primaria, de