<< Regresar al Indice del Artículo
Esta capa tiene la función de relizar los accesos hacia la base de datos (SQLServer2000 en este caso) para la persistencia de la información asi como tambien para las consultas de la misma.
Utiliza como metodo de acceso a la base de datos (SqlServer 2000) la herramienta de microsoft AutoSproc la cual nos facilita la llamada a procedimientos almacenados de SQLServer2000.
A continuación, comentaremos algunos de los métodos mas importantes de la clase de la Capa de Acceso a Datos :
Sin duda los mas importante de esta capa es la persistencia de datos, esto lo logramos a traves del metodo public string Guardar(ref Entity.ListaEntidades listaEntidades) que se muestra a continuacion.
/// Obtiene un System.string que indica la respuesta de la aplicación del método al almacenar la información en la base de datos
/// </summary>
/// <param name=»listaEntidades»>Entity.ListaEntidades representa los elementos a guardar</param>
/// <returns>System.string</returns>
public string Guardar(ref Entity.ListaEntidades listaEntidades)
{
try
{
if(listaEntidades.HasDeleted())
{
this.Borrar(listaEntidades);
}
foreach(Entity.Entidad elemento in listaEntidades)
{
int codigo;
int ultimaActualizacion;
if(elemento.HasChanges())
{
codigo=elemento.Estado;
ultimaActualizacion = elemento.UltimaActualizacion;
proc.Entidad_Save(ref codigo, elemento.Pais.PaisId, elemento.Descripcion, ref ultimaActualizacion);
elemento.Estado = codigo;
elemento.UltimaActualizacion = ultimaActualizacion;
}
}
listaEntidades.AcceptChanges();
}
catch(Exception ex)
{
Entity.LogController.Instance().AgregarMensaje(ex);
throw;
}
return «ok»;
}
Lo primero que podemos observar es que la lista que entra por parámetro, esta por referencia. Esto es por que al dar de alta un registro en la base de datos, es muy común que la misma base de datos nos asigne la llave primaria, ya sea un maximo de un campo + 1, o un uniqueidentifier generado en el procedimiento de guardar. Asi como tambien la UltimaActualizacion comentada el la parte I del manejo de Entidades, donde manejamos la version del registro. De esta forma, cuando se haga persistente la entidad que se tenian en memoria, por referencia le asignamos su llave primaria y su version de registro, para simular que se ubiera cargado la entidad para modificarla por el metodo traer comentado mas abajo, esto por que la instancia todavia esta en memoria en el programa cliente (interfas de usuario) y podría volverse a mandarla guardar, y en ese caso ya se trata como un cambio, ya que tiene versión de registro y llave primaria, cosa que no existia la primera vez que lo mandaron guardar.
Otra cosa que podemos apreciar es el metodo HasDeleted() de la lista, el cual lo tiene la Clase base de colecciones, comentada tambien en la parte I. Este metodo regresa una lista del mismo tipo de la coleccion. En esta lista estan todos los elementos que se desean borrar. ¿Como se llena esta lista?, se llena cada vez que utilizan el metodo Remove(IEntityBase entityBase), el cual quita ese elemento de la colección y lo almacena en otra lista interna del mismo tipo, y en esta parte de la capa de Acceso a Datos se utiliza como vemos a continuación:
/// Elimina los elementos representados en la lista de la base de datos
/// </summary>
/// <param name = «listaEntidades»>Entity.ListaEntidades representa los elementos a eliminar</param>
private void Borrar(Entity.ListaEntidades listaEntidades)
{
try
{
Entity.ListaEntidades listaBorrados = new Entity.ListaEntidades();
listaBorrados = (Entity.ListaEntidades)listaEntidades.GetDeleted();
foreach(Entity.Entidad elemento in listaBorrados)
{
proc.Entidad_Delete(elemento.Estado);
}
}
catch(Exception ex)
{
Entity.LogController.Instance().AgregarMensaje(ex);
throw;
}
}
Tambien podemos ver el uso del método HasChanges() dentro del ciclo foreach, esto es para saber si la entidad tubo modificaciones, si fue asi se mandara llamar el procedimeinto para almacenas los datos, de lo contrario simplemente se ignora ese elemento. Esto es para evitar llamadas en vano hacia la base de datos. Tambien se puede ver el uso del método AcceptChanges(), el cual nos sirve para inicializar el estatus de la entidad a «Sin cambios», para que de ahi en adelante cualquier dato que se mueva se vaya controlando el estado de la misma.
Bueno, pasando a la parte de las consultas, aqui de entrada se manejan 2 metodos, uno para traer todos los registros de la tabla en cuestion y pasarlos a una coleccion que se regresara como resultado del metodo hacia la interfas de usuario, y otro método por llave primaria que regresara un entidad hacia la aplicación cliente, recordemos que tanto las colecciones como las entidades son seriabilizables para que puedan viajar a traves de .net remoting hacia la aplicacion cliente, ya sea como parametros o como resultados de la llamada a un método. Echemos un vistazo a estos 2 metodos:
/// Obtiene una Entity.ListaEntidades
/// </summary>
/// <returns>una entidad Entity.ListaEntidades</returns>
public Entity.ListaEntidades TraerEntidades()
{
Entity.ListaEntidades l w Entity.ListaEntidades();
try
{
Entity.ListaPaises listaPaises=new mobileDAL.Pais().TraerPaises();
DataSet dsEntidades = proc.Entidad_Select();
Entity.Entidad elemento;
foreach(DataRow ren in dsEntidades.Tables[0].Rows)
{
elemento = new Entity.Entidad();
elemento.Estado = int.Parse(ren[«entidad»].ToString());
elemento.Pais = listaPaises.FindByPrimaryKey(int.Parse(ren[«pais»].ToString()));
elemento.Descripcion = ren[«descripcion»].ToString();
elemento.UltimaActualizacion = int.Parse(ren[«ultimaAct»].ToString());
listaEntidades.Add(elemento);
}
}
catch(Exception ex)
{
Entity.LogController.Instance().AgregarMensaje(ex);
throw;
}
listaEntidades.AcceptChanges();
return listaEntidades;
}
/// <summary>
/// Obtiene una Entity.Entidad según el parámetro recibido
/// </summary>
/// <param name=»entidadId»>System.String representa la Entidad</param>
/// <returns>una entidad Entity.Entidad</returns>
public Entity.Entidad TraerEntidades(int entidadId)
{
Entity.Entidad elemento=null;
DataSet dsElementos=null;
Entity.ListaPaises listaPaises=new mobileDAL.Pais().TraerPaises();
try
{
dsElementos=proc.Entidad_Select(entidadId);
foreach(System.Data.DataRow row in dsElementos.Tables[0].Rows)
{
elemento = new Entity.Entidad();
elemento.Estado = int.Parse(row[«entidad»].ToString());
elemento.Pais = listaPaises.FindByPrimaryKey(int.Parse(row[«pais»].ToString()));
elemento.Descripcion = row[«descripcion»].ToString();
elemento.UltimaActualizacion = int.Parse(row[«UltimaAct»].ToString());
elemento.AcceptChanges();
}
}
catch(Exception ex)
{
Entity.LogController.Instance().AgregarMensaje(ex);
throw;
}
return elemento;
}
Como podemos ver, en estos métodos también utilizamos en método AcceptChanges() al final de la cargada de los datos en las entidades o colecciones. Esto es para que de ahi en adelante empieze a controlarse lo que se haga con ellas, cambios, remove, etc.. Estas entidades, tanto la colección como la entidad individual, se pasaran hasta la aplicacion cliente, ellos podran trabajar con estas instancias y regresarlas al servidor de componentes por el método Guardar que expone la fachada (que se comentara en la parte IV). Y como ya tenemos el control del estatus de la entidad, tomamos la desición correcta, ya sea llamar el Borrar o el Guardar o simplemente no hacer nada, con esto logramos darle «Vida propia» a las entidades, aunque esten fuera del dominio del servidor.
Ir a parte IV: Capa de Reglas de Negocios y Fachadas
<< Regresar al Indice del Artículo
Espacios de nombres usados en el código de este artículo:
using AutoSproc;
using System.Data;
using System.Data.SqlClient;
using System;
using System.Xml;
