Desarrollo en Capas .Net (Parte 2) - Capa de Datos

domingo, 21 de octubre de 2012

En el articulo anterior  creamos nuestro modelo EDMX de nuestra base de datos y también creamos nuestras clases entidades  y las dividimos en una capa aparte llamada Entities.

Pueden ver el primer articulo aquí.
Desarrollo en Capas .Net(Parte 1)

 Pues bien en este segundo articulo desarrollaremos el código que tendrá nuestra capa de datos(DataAcces).

En la capa de datos(DataAcces) es donde tendremos todas las query a nuestra base de datos.

Antes de empezar a programar en nuestra capa de datos  primero agregaremos una clase llamada NotaAlumno en nuestra capa Entities(ya veremos para que nos servira).
   
public class NotaAlumno
{
    public int NotId { get; set; }
    public string AluNombre { get; set; }
    public string MatNombre { get; set; }
    public decimal NotNota { get; set; }
}
Entonces nuestra capa Entities nos quedara de la siguiente manera.

Entities


Como pueden observar nuestra capa Entities tendrá nuestras clases entidades que generamos en el articulo anterior y la nueva clase que acabamos de agregar.

Ahora si empecemos con el código que tendrá nuestra capa de datos(DataAcces) lo que aremos es que por cada clase entidad agregaremos una clase a nuestra capa de datos(DataAcces)  y dentro de estas tendremos las diferentes query a nuestra base de datos.

Agreguemos la primera clase que se llamara AlumnoDAL.
    public class AlumnoDAL
    {
        public static List<Alumno> CargarAlumnos()
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                return bd.Alumno.ToList();
            }
        }

        public static bool Existe(int id)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from al in bd.Alumno where al.AluId == id select al).Count();
                if (query == 0)
                    return false;
                else
                    return true;
            }
        }

        public static Alumno IdAlumno(int id)
        {
            Alumno alum = new Alumno();
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from al in bd.Alumno
                             where al.AluId == id
                             select al).Single();

                alum.AluId = query.AluId;
                alum.AluNombre = query.AluNombre;
                alum.AluApellido = query.AluApellido;
                alum.AluEdad = query.AluEdad;
                alum.AluDireccion = query.AluDireccion;
            }
            return alum;
        }

        public static Alumno CreateAlumno(Alumno alum)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                Alumno al = new Alumno();
                al.AluNombre = alum.AluNombre;
                al.AluApellido = alum.AluApellido;
                al.AluEdad = alum.AluEdad;
                al.AluDireccion = alum.AluDireccion;
                bd.Alumno.Add(al);
                bd.SaveChanges();
                alum.AluId = al.AluId;
            }
            return alum;
        }

        public static Alumno UpdateAlumno(Alumno alum)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from al in bd.Alumno
                             where al.AluId == alum.AluId
                             select al).Single();

                query.AluNombre = alum.AluNombre;
                query.AluApellido = alum.AluApellido;
                query.AluEdad = alum.AluEdad;
                query.AluDireccion = alum.AluDireccion;
                bd.SaveChanges();
            }
            return alum;
        }
        
    }
Dentro de esta clase tenemos una serie de métodos que ahorita explicare.
CargarAlumnos() Este método lo único que hace es retornar todos los registros de la tabla Alumno.
Existe() Este método se encarga de comprobar si un alumno existe por medio del id retorna false si no existe y true si ya existe.
IdAlumno() Este método lo que hace es retornar los datos de un alumno también por medio del id.
CreateAlumno() Este método agrega un nuevo alumno a nuestra base de datos y luego de agregarlo retornamos la entidad osea el alumno agregado.
UpdateAlumno() Este método actualiza un alumno utilizamos el id para actualizar los datos y luego también retornamos la entidad osea el alumno actualizado.

Ahora agreguemos una clase llamada NotaDal.
    public class NotaDal
    {
        public static bool Existe(int idalum, int idmat)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from not in bd.Nota where not.AluId == idalum && not.MatId == idmat select not).Count();
                if (query == 0)
                    return false;
                else
                    return true;
            }
        }

        public static Nota IdNota(int id)
        {
            Nota not = new Nota();
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from n in bd.Nota
                             where n.NotId == id 
                             select n).Single();

                not.NotId = query.NotId;
                not.AluId = query.AluId;
                not.MatId = query.MatId;
                not.NotNota = query.NotNota;
            }
            return not;
        }

        public static Nota CreateNota(Nota not)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                Nota n = new Nota();
                n.AluId = not.AluId;
                n.MatId = not.MatId;
                n.NotNota = not.NotNota;
                bd.Nota.Add(n);
                bd.SaveChanges();
                not.NotId = n.NotId;
            }
            return not;
        }

        public static Nota UpdateNota(Nota not)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from n in bd.Nota
                             where n.NotId == not.NotId 
                             select n).Single();

                query.AluId = not.AluId;
                query.MatId = not.MatId;
                query.NotNota = not.NotNota;
                bd.SaveChanges();
            }
            return not;
        }
    }
Dentro de esta clase encontramos los siguientes métodos.
Existe() Este método se encargara de comprobar si una nota ya existe por medio del id del alumno y el id de la materia este método nos ayudara para que un alumno solo pueda agregar una nota por materia.
IdNota() Este método lo que hace es retornar los datos datos de un registro por medio del id.
CreateNota()  Este método agrega un registro a la tabla nota  y luego  retornamos la entidad osea el registro agregado.
UpdateNota() Este método actualiza una nota utilizamos el id para actualizar los datos y luego también retornamos la entidad osea el registro actualizado.

Ahora agreguemos una clase llamada MateriaDal.
.
    public class MateriaDal
    {
        public static List<Materia> CargarMaterias()
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                return bd.Materia.ToList();
            }
        }
    }
Dentro de esta clase solo tenemos un método CargarMaterias() que lo único que hace es retornar todos los registros de la tabla materia.

Ahora agreguemos una clase llamada NotaAlumnoDal.
    public class NotaAlumnoDal
    {
        public static List<NotaAlumno> CargarNotas()
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = from not in bd.Nota
                            select new NotaAlumno
                            {
                                NotId = not.NotId,
                                AluNombre = not.Alumno.AluNombre,
                                MatNombre = not.Materia.MatNombre,
                                NotNota = not.NotNota
                            };
                return query.ToList();
            }
        }

        public static List<NotaAlumno> NotasAlumno(int id)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = from not in bd.Nota
                            where not.AluId == id
                            select new NotaAlumno
                            {
                                NotId = not.NotId,
                                AluNombre = not.Alumno.AluNombre,
                                MatNombre = not.Materia.MatNombre,
                                NotNota = not.NotNota
                            };

                return query.ToList();
            }
        }
    }
Dentro de esta clase encontramos los siguientes métodos.
CargarNotas() este método retorna todos los registros de la tabla nota.
NotasAlumno() este método retorna todas las notas de un alumno es por eso que hacemos uso del id del alumno para solo devolver solo las notas de un alumno.
En esta clase  hicimos uso de la clase que agregamos a nuestra capa Entities llamada NotaAlumno si se fijan en la query que hacemos a la tabla nota hacemos uso de las propiedades de la clase para en vez de que nos muestre el id del alumno y la materia nos muestre el nombre del alumno y de la materia, haciendo también uso de las propiedades de navegación que existen ente las tablas.

Importante que dentro de cada clase que agregamos a nuestra capa de datos(DataAcces) necesitamos el espacio de nombres Entities para poder hacer uso de nuestras clases entidades.
using Entities;

Eso seria todo en nuestra capa de datos, al final nuestro proyecto nos quedara de la siguiente manera.

Proyecto

Resumiendo lo que hicimos agregamos 4 clases(DAL) a nuestra capa de datos(DataAcces) una por cada clase entidad y dentro de estas tenemos las diferentes query hacia la base de datos.

Descargar Proyecto C#

Descargar Proyecto VB.Net

En el próximo articulo desarrollaremos el código de nuestra capa de negocio(BussinesLayer).
Desarrollo en Capas .Net (Parte 3) - Capa de Negocio

0 comentarios:

Publicar un comentario en la entrada

Nota: solo los miembros de este blog pueden publicar comentarios.