Continuando a construção da classe DAL Genérica.
A seguir
veremos os métodos privados que irão realizar as operações de BD.
Inicialmente veremos os métodos que farão chamadas à Stored Procedures:
#region private Execute Procs Methods
private void ExecProc(T pObj, ProcedureTypes pProcType)
{
object[] atributos = null;
AttParamProcDB attProcDB = null;
IDbCommand command = null;
IDbDataParameter param = null;
bool flagHasParamOut = false;
try
{
//Valida o uso dos atributos
this.ValidateUsageCustomAttributes();
if (pProcType != ProcedureTypes.SelectFilter &&
pProcType != ProcedureTypes.SelectNoFilter)
{
if (this._dbManager == null || this._dbManager.Conn == null)
{
throw new GenericDALException("Utilize um dos métodos 'TransactionScope' para setar o escopo da transacao atual");
}
foreach (PropertyInfo piInfo in pObj.GetType().GetProperties())
{
atributos = piInfo.GetCustomAttributes(false);
if (atributos != null && atributos.Length > 0)
{
foreach (object att in atributos)
{
if (att is AttParamProcDB)
{
attProcDB = (AttParamProcDB)att;
if (attProcDB.TipoProcedure == pProcType)
{
if (command == null || String.IsNullOrEmpty(command.CommandText))
{
command = this._dbManager.Conn.CreateCommand(); //this._conn.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = attProcDB.ProcName;
command.Transaction = this._dbManager.Trans; // this._transaction;
}
if (command != null)
{
param = command.CreateParameter();
param.ParameterName = attProcDB.ParamName;
param.DbType = attProcDB.DbType;
param.Direction = attProcDB.Direction;
if (attProcDB.Direction == ParameterDirection.Input)
{
param.Value = piInfo.GetValue(pObj, null);
}
else
{
flagHasParamOut = true;
piInfo.SetValue(pObj, param.Value, null);
param.Size = attProcDB.ParamSize;
}
command.Parameters.Add(param);
}
}
}
}
}
}
/*---------Preenche Outputs----------*/
if (command.Parameters != null)
{
command.ExecuteNonQuery();
if (flagHasParamOut)
{
foreach (IDataParameter paramAx in command.Parameters)
{
foreach (PropertyInfo piAux in pObj.GetType().GetProperties())
{
foreach (object attObj in piAux.GetCustomAttributes(false))
{
if (attObj is AttParamProcDB)
{
if (((AttParamProcDB)attObj).TipoProcedure == pProcType &&
((AttParamProcDB)attObj).Direction == ParameterDirection.Output )
{
if (paramAx.ParameterName.ToLower() ==
((AttParamProcDB)attObj).ParamName.ToLower())
{
if (paramAx.Value != null)
{
piAux.SetValue(pObj, paramAx.Value, null);
}
}
}
}
}
}
}
}
}
}
}
catch (Exception ex)
{
this._dbManager.Dispose();
throw ex;
}
finally
{
atributos = null;
attProcDB = null;
command = null;
param = null;
}
}
private List ExecProcSelectFilter(T pObj)
{
object[] atributos = null;
AttParamProcDB attProcDB = null;
IDbCommand command = null;
IDbDataParameter param = null;
IDbDataAdapter adp = null;
List retorno = null;
DataSet ds = null;
try
{
this.ValidateUsageCustomAttributes();
if (this._dbManager == null || this._dbManager.Conn == null)
{
throw new GenericDALException("Utilize um dos métodos 'TransactionScope' para setar o escopo da transacao atual");
}
foreach (PropertyInfo piInfo in pObj.GetType().GetProperties())
{
atributos = piInfo.GetCustomAttributes(false);
if (atributos != null && atributos.Length > 0)
{
foreach (object att in atributos)
{
if (att is AttParamProcDB)
{
attProcDB = (AttParamProcDB)att;
if (attProcDB.TipoProcedure == ProcedureTypes.SelectFilter)
{
if (command == null || String.IsNullOrEmpty(command.CommandText))
{
command = this._dbManager.Conn.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = attProcDB.ProcName;
command.Transaction = this._dbManager.Trans;
}
if (command != null && attProcDB.TipoProcedure != ProcedureTypes.SelectNoFilter)
{
param = command.CreateParameter();
param.ParameterName = attProcDB.ParamName;
param.DbType = attProcDB.DbType;
param.Direction = attProcDB.Direction;
if (attProcDB.Direction == ParameterDirection.Input)
{
param.Value = piInfo.GetValue(pObj, null);
}
else
{
piInfo.SetValue(pObj, param.Value, null);
param.Size = 1000;
}
command.Parameters.Add(param);
}
}
}
}
}
}
adp = this._dbManager.Adp;
adp.SelectCommand = command;
ds = new DataSet();
adp.Fill(ds);
retorno = this.DataSetToList(ds);
}
catch (Exception ex)
{
this._dbManager.Trans.Rollback();
this._dbManager.Conn.Close();
throw ex;
}
finally
{
atributos = null;
attProcDB = null;
command = null;
param = null;
adp = null;
ds = null;
}
return retorno;
}
private List ExecProcSelectNoFilter()
{
IDbCommand command = null;
IDbDataAdapter adp = null;
bool flagIsTrans = true;
List retorno = null;
DataSet ds = null;
string procName = "";
T Obj = new T();
AttProcNameSelectNoFilter attribute = null;
try
{
this.ValidateUsageCustomAttributes();
if (this._dbManager == null)
{
throw new GenericDALException("Utilize um dos métodos 'TransactionScope' para setar o escopo da transacao atual");
}
if (Obj.GetType().GetCustomAttributes(typeof(AttProcNameSelectNoFilter), false)[0] != null)
{
attribute = (AttProcNameSelectNoFilter)Obj.GetType().GetCustomAttributes(typeof(AttProcNameSelectNoFilter), false)[0];
procName = attribute.ProcName;
if (!String.IsNullOrEmpty(procName))
{
if (command == null || String.IsNullOrEmpty(command.CommandText))
{
command = this._dbManager.Conn.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = procName;
command.Transaction = this._dbManager.Trans;
adp = this._dbManager.Adp;
adp.SelectCommand = command;
ds = new DataSet();
adp.Fill(ds);
retorno = this.DataSetToList(ds);
}
}
}
}
catch (Exception ex)
{
this._dbManager.Trans.Rollback();
this._dbManager.Conn.Close();
throw ex;
}
finally
{
command = null;
adp = null;
ds = null;
procName = null;
Obj = default(T);
attribute = null;
}
return retorno;
}
#endregion
Podemos
verificar que todos esses três métodos utilizam o método privado this.ValidateUsageCustomAttributes(). Isso nos garante que os métodos só
serão executados caso o uso dos nossos atributos seja validado.
O método “ExecProc” percorre as propriedades da
classe model corrente
para
pegar os valores de suas propriedades e os valores de seus atributos
customizados. Com esses valores obtidos, ele realiza a chamada à stored
procedure.
Esse
método é utilizado para procedures do tipo Insert, Update e Delete e recebe um
tipo que será uma instancia da classe model corrente e um enum que reflete o
tipo de procedure a ser chamada.
O método “ExecProcSelectFilter” Percorre o
objeto model corrente (
O método “ExecProcSelectNoFilter” Lê o atributo
“AttProcNameSelectNoFilter” para saber qual é a SP que fará um select sem filtro.
Após o acionamento da SP, o método retorna um List.
Pronto.
Com todos estes métodos podemos definir os nossos métodos que serão acessados
pelas classes Business. Vale lembrar que precisamos proteger nossos métodos,
mantendo eles acessíveis somente a membros de nossa classe DAL genérica e às
classes que a herdarem. Então vamos lá:
#region Protected Execute Procedures Methods
protected List ExecuteProcSelectFilter(T pObj)
{
return this.ExecProcSelectFilter(pObj);
}
protected List ExecuteProcSelectNoFilter()
{
return this.ExecProcSelectNoFilter();
}
protected void ExecuteProcInsert(T pObj)
{
this.ExecProc(pObj, ProcedureTypes.Insert);
}
protected void ExecuteProcDelete(T pObj)
{
this.ExecProc(pObj, ProcedureTypes.Delete);
}
protected void ExecuteProcUpdate(T pObj)
{
this.ExecProc(pObj, ProcedureTypes.Update);
}
#endregion
Utilizamos o modificador de acesso “protected”, que atende a nossa necessidade de proteger nossos métodos. Vemos aqui que esses métodos apenas fazem chamadas a alguns dos nossos métodos privados.
Bom temos
agora nossa classe pronta para ser usada.
Na próxima parte do artigo, disponibilizaremos o código completo da classe DAL.
Obrigado.
