Mini Proyecto de ejemplo usando Entity Framework en una Arquitectura n-

Layer – Parte 1

Asesor e Instructor: Nelson López Hidalgo

Email: nelson.hidalgo@misena.edu.co

En este ejemplo, vamos a trabajar en el desarrollo de una “mini” aplicación que

administra los casos de uso de n empresas – al menos desarrollar un poquito de
funcionalidad de la aplicación para ilustrar los conceptos expuestos.

La Base de Datos

El primer paso es crear una base de datos para persistir la información de los
proyectos. Vamos a crear una base de datos utilizando SQLServer 2005/2008. Esta
base de datos se llamará UseCases. El diagrama inicial de la base de datos es el
siguiente.

En este caso, vamos a decir que una empresa puede tener varios proyectos, y que cada
proyecto tiene muchos casos de uso. Cada caso de uso tiene un historial de acciones
que se graba cada vez que se realiza un cambio en el caso de uso ( esto suponiendo
una base de datos completa, en donde se guardan los diferentes flujos del caso de uso,

1
sus actores, etc). Por último, cada registro del historial de cambios tiene un usuario
asociado que es precisamente el que realizó el cambio.

Desarrollando la Solución

Para el desarrollo de la solución vamos a utilizar Visual Studio 2010. El primer paso es
crear una solución vacía para ir agregando los diversos proyectos que vamos a ir
requiriendo en el desarrollo de la aplicación. Para crear una solución vacía
seleccionamos: new project –> visual studiosolutions –>BlankSolution.

Creando la capa de Acceso a Datos

Una vez que tenemos la solución, vamos a crear la CAPA DE ACCESO A DATOS (que
por lo general es el primer bloque que se crea cuando se realiza un proyecto con
arquitectura n-layer). Para agregar el proyecto, seleccionamos con el botón derecho
del mouse la solución recién creada y seleccionamos del menú contextual agregar
nuevo proyecto.

2
Cuando aparece la opción de seleccionar el tipo de proyecto deseado seleccionamos la
opción de classlibrary en el tipo de proyecto Windows bajo C#. Al proyecto le vamos a
poner de nombre CapaDeAccesoADatos.

Después de creada la capa de acceso a datos – al menos el proyecto – procedemos a

agregar el modelo del entitiyframework. Debemos recordar que el EF sustituye a la
capa de acceso a datos. Por esta razón en este componente de acceso a datos,
solamente vamos a tener el modelo generado por el EF.

Para crear un modelo de entidades le damos clic y botón derecho al proyecto recién
creado y seleccionamos agregar nuevo ítem.

3
En el diálogo de seleccionar ítem escogemos la opción ADO.NET EntityModel. Le
vamos a llamar UseCasesModel.

Cuando inicia el “wizard” del EF en el primer paso seleccionamos la opción generar

desde base de datos. Seguidamente creamos una nueva conexión a la base de datos
que recién acabamos de crear; le decimos además al wizard que agregue el string de
conexión al archivo app.config con el nombre UseCasesEntities.

4
Seleccionamos Next y procedemos a seleccionar las tablas que vamos a utilizar en
nuestro modelo. En este caso, vamos a mapear en el modelo, todas las tablas creadas
en el diseño de la base de datos hecha en SQLServer.

El modelo generado es el siguiente

5
En el paso que estamos, la solución debería lucir de la siguiente manera:

En este momento solo tenemos una librería – dll – que va a convertirse en mi capa de
acceso a datos. En el próximo post, vamos a desarrollar la capa de lógica de negocios.

6
 El Entity Framework en una Arquitectura n-layer – Parte 2

La CAPA DE NEGOCIOSes la capa en la cual vamos a crear los métodos unitarios que
llevan a cabo las tareas correspondientes de cada una de las entidades. Estas tareas
incluyen desde las operaciones CRUD – create, retrieve, update, delete – hasta
procesos de negocios más elaborados.

Para crear esta capa de negocios, vamos a crear una librería utilizando los mismos
pasos que hicimos en el post anterior, pero vamos a llamar la libreria como
LogicaDeNegocios.

Al igual que hicimos en la librería de la capa de acceso a datos, vamos a eliminar la

clase que es creada por defecto cuando creamos el componente. La solución ahora
debería lucir así:

7
Seguidamente vamos a crear las clases de lógica de negocios para poder llevar a cabo
operaciones que se requieran para cada entidad. En este caso, vamos a crear la clase
de lógica de negocios para la entidad Usuario. Para crear esta clase, le damos click
derecho sobre el proyecto de lógica de negocios y seleccionamos agregar nuevo ítem –
> Agregar Clase.

En el diálogo de agregar clase escribimos UsuarioBL como nombre de la clase, para

poder identificar la clase de lógica de negocio para el usuario en las capas de
presentación que vayamos a crear o incluso en la capa de servicios si deseamos crear
una para permitir que nuestra funcionalidad de negocios se pueda acceder a través de
servicios.

El siguiente paso es agregar una referencia a la capa de acceso a datos para así poder
tener visibilidad de las operaciones existentes dentro del modelo de entidades creado
en esa librería. Para lograr esto, le damos click derecho al proyecto de lógica de
negocios y seleccionamos la opción agregar referencia del menu contextual. En el
dialogo de agregar referencias seleccionamos la cejilla de proyectos y escogemos el
proyecto para capa de acceso a datos.

8
La referencia debe poder verse en la carpeta de referencias del proyecto como se
muestra a continuación.

Una vez agregada la referencia, procedemos a agregar el uso de la librería en la clase

recién creada. Esto se logra a través de la instrucción using, seguidamente creamos
una propiedad automática para tener acceso al modelo de entitdades que creamos
anteriormente en la capa de acceso a datos.

Como se puede ver en la figura anterior, es requerido agregar la librería

System.Data.Entities para poder hacer uso de las entidades presentes en la capa de
acceso a datos. En post posteriores vamos a analizar con un poco más de profundidad
el entityframework y estos detalles. Para agregar esta librería seguimos el mismo
proceso que llevamos a cabo anteriormente para agregar la referencia a la capa de
acceso a datos, solo que esta vez vamos a buscar la librería en la cejilla de .NET.

9
Una vez agregada esta referencia, la clase actual para manejar la lógica de de negocios
del usuario ya compila.

Un aspecto a destacar, es que agregamos una propiedad dinámica para tener acceso al
modelo de entidades que acabamos de agregar desde la capa de acceso a datos, y
además instanciamos el modelo de entidades generado desde el constructor de la
clase. Este comportamiento puede no ser el deseado ya que puede producirnos
trabajo extra a la hora de agregar relaciones que se obtienen desde otras clases de
lógica de negocios por que cada clase va a venir de diferentes instancias del modelo, es
decir desde diferentes contextos. En el post de como extender y mejorar el EF en una
arquitectura n-layer vamos a ver cuáles pueden ser las posibles soluciones para
manejar estos casos.

10
Seguidamente procedemos a crear los métodos principales de CRUD en la lógica de
negocios. Primeramente vamos a crear el método para agregar un usuario.Este
método recibe una entidad del tipo Usuario, y la agrega al contexto instanciado
utilizando el método generado AddToUsuario. Finalmente, procedemos a persistir los
cambios en la base de datos utilizando el métodoSaveChanges.

En muchas ocasiones surge la pregunta, ¿por qué recibir un usuario y no los campos
para agregar a la entidad? La respuesta está relacionada con la adaptabilidad al
cambio de parte de la aplicación.

Puede ser que en un futuro se requiera quitar o agregar campos a la entidad usuario;
si estamos utilizando los campos en lugar de una entidad, vamos a tener que modificar
todos los métodos donde interactuamos con la entidad para modificar, actualizar,
seleccionar, etc. Sin embargo, si utilizamos una entidad, los puntos que varían son la
entidad, el UI en donde construimos la entidad y la capa de acceso a datos donde
agregamos los campos al repositorios – si estamos usando el EF, no se requieren
cambios en la capa de acceso a datos ya que el EF actualiza los métodos desde el
modelo – con lo que nuestra aplicación es más fácil para modificar.

Seguidamente procedemos a crear los métodos necesarios para obtener todos los
usuarios que existen en la base de datos, y el método que me retorna un usuario en
específico.

Inicialmente agregamos la referencia a la librería System.Linq, esto para tener acceso

a los métodos de extensión

usingSystem.Collections.Generic;
usingCapaDeAccesoADatos;
usingSystem.Linq;

11
Seguidamente creamos los métodos mencionados anteriormente. En este caso vamos
a utilizar la sintaxis del EF para acceder a los datos. En artículos posteriores vamos a
utilizar LinqToEntities para llevar a cabo las mismas tareas.

publicList<Usuario>ObtenerUsuarios( )
{
varusuarios = ModeloEntidades.Usuario;
returnusuarios.ToList( );
}

publicUsuario ObtenerUsuario( intid )

{
varusuario = ModeloEntidades.Usuario.Where(u =>u.Id == id).FirstOrDefault( );
returnusuario;
}

Con estos métodos ya tenemos un conjunto de funcionalidad suficiente para poder

trabajar con nuestra capa de UI. Digo suficiente porque por supuesto faltan los
métodos para actualizar y borrar usuarios, además los correspondientes métodos
para asociar los usuarios a las entidades correspondientes. Estos métodos deberán ser
realizados por los estudiantes.

La solución de la aplicación debe de lucir de la siguiente manera:

12
 El Entity Framework en una Arquitectura n-layer – Parte 3

Ya habiendo creados las capa para la lógica de negocios y la capa de acceso a

datos utilizando el entityframework. En esta parte, vamos a crear la capa de
presentación de la aplicación de ejemplo utilizando ASP.NET.

El primer paso es crear un nuevo proyecto dentro de la solución en la cual hemos

venido trabajando. El proyecto a crear es una aplicación ASP.NET (C#).

Le ponemos de nombre mini-proyecto

Seguidamente, creamos un formulario, Para agregar un usuario, un usuario tiene

básicamente los siguientes campos:

13
 Id
 Nombre
 Apellido1
 Apellido2
 Email
 Activo.

De estos campos, el Id es autogenerado y el campo de activo es para borrado lógico

por lo que en la inserción por defecto, el campo se guarda con un valor de “Y”.

La pantalla que vamos a crear por lo tanto deberá lucir como se ve en la siguiente
figura:

Seguidamente vamos a agregar el código necesario para agregar la entidad ingresada

en el formulario, pero antes de esto, debemos agregar una referencia a la capa de
lógica de negocios y a la capa de acceso a datos. A esta última la tenemos que agregar
por que las entidades son el “medio de transporte” entre las capas, y como no tenemos
una capa de entidades separada, entonces tenemos que agregarla desde la capa de
acceso a datos. Además se debe de agregar una referencia a la librería
System.Data.Entity. El código lucirá de la siguiente forma:

usingSystem.Windows;
usingCapaDeAccesoADatos;
usingLogicaDeNegocios;

namespaceMiniProyecto
14
{
publicpartialclassDetalleUsuario
{
publicDetalleUsuario( )
{
InitializeComponent( );
}
privatevoidbtnOk_Click( objectsender, RoutedEventArgse )
{
Usuario usuario = new Usuario( );
usuario.Nombre = txtNombre.Text;
usuario.Apellido1 = txtApellido1.Text;
usuario.Apellido2 = txtApellido2.Text;
usuario.Email = txtEmail.Text;
usuario.Activo = "Y";
UsuarioBL usuarioBL = new UsuarioBL( );
usuarioBL.AgregarUsuario(usuario);
}
}
}

Como podemos ver, lo único que hacemos es crear una entidad, crear una instancia de
la clase usuario de la lógica de negocios e invocar el método agregar usuario pasando
de parámetro la entidad del usuario recién creada. Este código, además de simple, es
sencillo de mantener y permite que todos los desarrolladores que estén trabajando en
el proyecto, tengan un estilo similar para programar, lo que facilita el hecho de que
una persona no esté disponible para modificar o agregar funcionalidad a una pantalla.

Si ejecutamos la pantalla anterior, veremos la siguiente pantalla en ejecución:

Si ingresamos datos, y le damos ok, vamos a recibir el siguiente error de parte del
entityframework:

15
Thespecifiednamedconnectioniseithernotfound in theconfiguration, notintendedto be
usedwiththeEntityClientprovider, ornotvalid.

Esto quiere decir que el entityframework no está encontrando el conectionstring para

pegarse a la base de datos. Este connectionstring se encuentra en el archivo app.config
de la librería de acceso a datos; pero en este caso, como no tenemos configurada la
salida de todos los proyectos al mismo directorio – algo de lo que vamos a ir
conversando en post posteriores – entonces la aplicación no lo logra localizar. Para
solucionar este problema de forma rápida – y temporal - debemos simplemente
agregar un archivo app.config al proyecto del cliente WPF y copiar el connectionstring
desde el app.config de la capa de acceso a datos.

El primer paso es agregar el archivo config al cliente de WPF.

Seguidamente copiamos desde el archivo app.config de la capa de acceso a datos, el

string de conexión al archivo recién creado

<connectionStrings>
<addname="UseCasesEntities"
connectionString="metadata=res://*/UseCasesModel.csdl|res://*/UseCasesModel.ss
dl|res://*/UseCasesModel.msl;provider=System.Data.SqlClient;provider
connectionstring=&quot;DataSource=diego-pc\sqlserver2008;Initial
Catalog=UseCases;Integrated Security=True;MultipleActiveResultSets=True&quot;"
providerName="System.Data.EntityClient" />
</connectionStrings>

Seguidamente, procedemos a ejecutar la aplicación y a insertar los usuarios que

vayamos a necesitar.

Asesor e Instructor: Nelson López Hidalgo

Email: nelson.hidalgo@misena.edu.co

16