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í.
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
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.
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.
Si quieren descargar el codigo de esta segunda parte del proyecto pueden hacerlo desde mi blog.
En el próximo articulo desarrollaremos el código de nuestra capa de negocio(BussinesLayer).
Si quieres estar pendiente de la siguiente parte del ejemplo o te gustaría ver mis demás artículos sígueme en mi blog. http://cristiantorresalfaro.blogspot.com/