Maestro Detalle con el Entity Framework 4.0

Quizás la tarea más común a la hora de desarrollar un software de negocios es el uso de maestros detalles en nuestra aplicación, es decir una entidad padre con varios hijos que la complementan. Esto conlleva a que se de una pregunta entre los desarrolladores con mucha frecuencia: ¿cómo funciona un maestro detalle con el Entity Framework? En este post vamos a solucionar este problema.

Foreign Keys en el Entity Framework 4.0

En el EF 4 se creo una nueva forma de manipular asociaciones a través de las llaves foráneas de las tablas asociadas. Esta forma de relación se le llama “Asociación de FK”. Esto permite incluir las columnas de la llave foránea como propiedades en las entidades con lo cual el manejo de las relaciones es mucho más sencillo a la hora de llevar a cabo operaciones del CRUD – Create – Retrieve – Update – Delete. Por ejemplo, a la hora de crear un producto podemos hacer la asociación entre las clases de la forma que se presenta a continuación.

using (var context = new Context()) 
    { 
        Product p = new Product 
        { 
            ID = 1, 
            Name = "Papas Fritas Congeladas", 
            Category = context.Categories 
                        .Single(c => c.Name == "Comida") 
        }; 
        context.SaveChanges(); 
    } 

Ejemplo

Como de costumbre, vamos a ilustrar el concepto a través de un ejemplo desarrollado en .NET. En este caso vamos a tener una base de datos con el siguiente esquema.

Cabe resaltar que los campos Id de cada una de las tablas son AutoIdentity y que la relación del esquema se hace entre el campo OrdenId de la tabla detalle y el campo Id de la tabla Orden. Luego procedemos a crear un proyecto de Tipo Librería de Windows – dll y generamos el esquema se genera automáticamente para el EntityFramework.

Como podemos ver en la figura anterior aunque se genera la relación para navegar entre ambas clases, la propiedad IdOrden que relaciona la Orden con el detalle se genera para que podamos utilizarla vía código. Luego procedemos a crear la capa de lógica de negocios, en la cual solo vamos a crear una clase para el manejo de las órdenes y el método que me permite agregar una orden y sus respectivos detalles.

using DAL;

namespace BL
{
    public class Orden_BL
    {
        public int AgregarOrden( Orden pOrden, List<Detalle> pDetalle )
        {
            foreach (Detalle d in pDetalle)
            {
                pOrden.Detalle.Add(d);
            }

            Common.ObtenerContexto().Ordenes.AddObject( pOrden );

            return Common.ObtenerContexto().SaveChanges();
        }
    }
}

En este caso procedemos a recibir dos parámetros a la hora de ingresar la orden a la base de datos: La orden y la lista de detalles que le vamos a asociar a la orden. Seguidamente recorremos la lista de detalles y los vamos agregando uno a uno. Por último agregamos la nueva orden al contexto del esquema del entity framework y procedemos a salvarlo en la base de datos. El código del método ObtenerContexto es el siguiente:

using DAL;

namespace BL
{
    public class Common
    {
        private static Ejemplos_BlogEntities _contexto;
        public static Ejemplos_BlogEntities ObtenerContexto( )
        {
            if (_contexto == null)
                _contexto = new Ejemplos_BlogEntities();
            return _contexto;
        }
    }
}

Por último creamos el UI. Esta parte es un poco más simple ya que solamente tenemos que interactuar con la lista de detalles y la orden que vamos a crear. En primera instancia vamos a crear una variable del tipo Lista de detalle para almacenar todos los detalles que vamos creando:

private List<Detalle> _detalles = new List<Detalle>();

public List<Detalle> Detalles
{
    get { return _detalles; }
    set { _detalles = value; }
}

Seguidamente creamos un botón para agregar detalles a la orden que queremos crear y en este evento procedemos a agregar el nuevo detalle a la colección de detalles y a refrescar el Grid de detalles.

private void btnAgregar_Click( object sender, EventArgs e )
{
    Detalle _detalle = new Detalle();
    _detalle.Producto = txtProducto.Text;
    _detalle.Cantidad = Convert.ToDecimal( txtCantidad.Text );

    Detalles.Add( _detalle );

    dgvProductos.DataSource = null;
    dgvProductos.DataSource = Detalles;
}

Nótese que hasta el momento no existe ningún tipo de interacción con la clase Orden. Esta se lleva a cabo cuando el usuario del sistema decide guardar la orden; es en este momento en donde se procede a crear una instancia de la orden y a invocar el método de la lógica de negocios que hace la inserción de la orden con sus respectivos detalles.

private void btnTerminar_Click( object sender, EventArgs e )
       {
           Orden _orden = new Orden();
           _orden.Cliente = txtCliente.Text;
           _orden.Fecha = DateTime.Now;
           _orden.Numero = txtNumeroDeOrden.Text;

           Orden_BL _ordenBL = new Orden_BL();
           _ordenBL.AgregarOrden( _orden, Detalles );
       }

La pantalla que estamos utilizando – advirtiendo que yo por lo general hago pantalla muy desagradables – es la siguiente:

Si revisamos la tabla de órdenes vemos que la consulta nos retorna el siguiente resultado:

Vale la pena recalcar el hecho de que el Id autogenerado de la orden es 1. Ahora veamos la consulta a la tabla de detalles:

Nótese el hecho de que la relación de llave foránea con la orden se hizo de forma automática ya que en ninguna parte del código procedimos a asignar directamente el Id de la llave foránea, simplemente asignamos cada uno de los detalles a la lista de detalles de la orden en la capa de negocios.

Es importante de hacer notar a los que nos leen que no se utiliza ningun esquema de transaccionabilidad en este modelo, ya que no es necesario hacer rollback o commit de la operación en algún momento dado porque el esquema lo estamos asociando en memoria y antes de enviarlo a la base de datos, por lo que al final es una sola operación la que se ejecuta contra la base de datos.

Technorati Tags: C#,EntityFramework