/// <summary>
///
/// </summary>
/// <param name="contextoAcessoDado"></param>
/// <param name="comm"></param>
/// <returns></returns>
public static DbDataAdapter CriarDataAdapterParaContexto(ContextoAcessoDado contextoAcessoDado, DbCommand comm)
{
if (contextoAcessoDado == null)
throw new NullReferenceException("Nao existe uma escopo para a criacao do DbDataAdapter");
DbDataAdapter dataAdapter;
dataAdapter = contextoAcessoDado.ProviderFactory.CreateDataAdapter();
dataAdapter.SelectCommand = comm;
return dataAdapter;
}
/// <summary>
///
/// </summary>
/// <param name="contextoAcessoDado"></param>
/// <param name="commandText"></param>
/// <param name="commandType"></param>
/// <param name="commandTimeout"></param>
/// <returns></returns>
public static DbCommand CriarCommandParaContexto(ContextoAcessoDado contextoAcessoDado, string commandText, CommandType commandType, int commandTimeout)
{
if (contextoAcessoDado == null)
throw new NullReferenceException("Nao existe um escopo para a criacao do DbCommand");
DbCommand command = contextoAcessoDado.ProviderFactory.CreateCommand();
command.Connection = contextoAcessoDado.Connection;
command.CommandText = commandText;
command.CommandType = commandType;
command.CommandTimeout = commandTimeout;
if (contextoAcessoDado.Transaction != null)
{
command.Transaction = contextoAcessoDado.Transaction;
}
return command;
}
public DbCommand ObterCommand(ContextoAcessoDado contextoAcessoDado)
{
ChecarDisposed();
if (_Command == null)
{
_Command = BdUtil.CriarCommandParaContexto(contextoAcessoDado, _CommandText, _CommandType, _CommandTimeout);
}
return _Command;
}
private void InicializarEscopo(OpcaoEscopo opcaoEscopo, string nomeConfigConexao, OpcaoTransacao opcaoTransacao)
{
// nos precisamos mudar _Atual?
bool precisaMudarEscopo;
VerificarMudancaEscopo(opcaoEscopo, nomeConfigConexao, out precisaMudarEscopo);
//this.InicializarEscopo(opcaoEscopo, );
if (precisaMudarEscopo)
{
// Inicializando apenas se um novo escopo vai ser criado
_ContextoAcessoDado = new ContextoAcessoDado(nomeConfigConexao);
_ContextoAutenticacao = new ContextoAutenticacao();
AtribuirEscopoAtual();
// Uma transacao nunca é iniciada em um escopo que nao inciou transacional
ConfigurarTransacao(opcaoTransacao);
}
}
private void InicializarEscopo(ContextoAcessoDado acessoDado)
{
bool precisaMudarEscopo;
VerificarMudancaEscopo(OpcaoEscopo.RequerNovo, String.Empty, out precisaMudarEscopo);
if (precisaMudarEscopo)
{
// Inicializando apenas se um novo escopo vai ser criado
_ContextoAcessoDado = acessoDado;
AtribuirEscopoAtual();
}
}
/// <summary>
/// Faz Commit na transacao se for necessario e chama <see cref="Acontep.Dado.ContextoAcessoDado.Dispose"/>
/// </summary>
/// <param name="contextoAcessoDado">Valor a sofrer o processo de finalizacao</param>
/// <param name="marcadoComoCompleto"></param>
private void FinalizarContextoAcessoDado(ContextoAcessoDado contextoAcessoDado, bool marcadoComoCompleto)
{
if (contextoAcessoDado != null)
{
try
{
// Se o escopo foi marcado como terminado entao faz um commit na transacao
if (marcadoComoCompleto && contextoAcessoDado.Transaction != null)
contextoAcessoDado.Transaction.Commit();
}
finally
{
contextoAcessoDado.Dispose();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="disposing"></param>
protected override void Dispose(bool disposing)
{
bool possoFinalizar = !EstaFinalizado && disposing && --(Atual.ContadorEscopo) < 1;
if (possoFinalizar)
{
bool marcadoComoCompleto = MarcadoComoCompleto;
// Primeiro, remover esta instancia da fila (mas, apenas se nos somos o atual da fila e se nosso
// contador de escopos indicar que somos o primeiro criado)
// Nota: Thread-local _Atual, e requerimento de que o escopo nao sofra dispose em outras threads
// significam que podemos dispensar o lock.
if (_Atual == this)
{
// Caso o usuario tenha chamado dispose fora de ordem, retorna na fila
// ate encontrar objetos que nao tenham sido finalizados (chamada a dispose).
Escopo anterior = _EscopoAnterior;
while (anterior != null && anterior.EstaFinalizado)
{
anterior = anterior._EscopoAnterior;
}
_Atual = anterior;
}
// segundo, marcar nosso estado interno como finalizado
ContextoAcessoDado contextoAcessoDado = _ContextoAcessoDado;
_ContextoAcessoDado = null;
// Por ultimo, limpar os escopos de dados mantidos por mim
FinalizarContextoAcessoDado(contextoAcessoDado, marcadoComoCompleto);
}
base.Dispose(disposing);
}
/// <summary>
/// Inicia um novo escopo de execução com <paramref name="acessoDado"/>
/// </summary>
/// <param name="acessoDado">Inicia um escopo com este contexto de acesso a dado</param>
public Escopo(ContextoAcessoDado acessoDado)
{
InicializarEscopo(acessoDado);
}
/// <summary>
///
/// </summary>
/// <param name="contextoAcessoDado"></param>
/// <param name="commandWrappers"></param>
/// <returns></returns>
internal static DbDataAdapter CriarDataAdapterDeCommandWrappers(ContextoAcessoDado contextoAcessoDado, Dictionary<TipoCommandDataAdapter, CommandWrapper> commandWrappers)
{
if (contextoAcessoDado == null)
throw new NullReferenceException("Nao existe uma escopo para a criacao do DbDataAdapter");
DbCommand selectCommand = ObterCommand(contextoAcessoDado, TipoCommandDataAdapter.Select, commandWrappers);
if (selectCommand == null)
throw new NullReferenceException("A lista de CommandWrappers deve conter no minimo um command de select para que um DbDataAdapter seja criado");
DbDataAdapter dataAdapter;
dataAdapter = contextoAcessoDado.ProviderFactory.CreateDataAdapter();
dataAdapter.SelectCommand = selectCommand;
dataAdapter.InsertCommand = ObterCommand(contextoAcessoDado, TipoCommandDataAdapter.Insert, commandWrappers);
dataAdapter.UpdateCommand = ObterCommand(contextoAcessoDado, TipoCommandDataAdapter.Update, commandWrappers);
dataAdapter.DeleteCommand = ObterCommand(contextoAcessoDado, TipoCommandDataAdapter.Delete, commandWrappers);
return dataAdapter;
}
/// <summary>
/// Extrair <see cref="DbCommand"/> de uma lista de <see cref="CommandWrapper"/>s através do <see cref="TipoCommandDataAdapter"/>
/// </summary>
/// <param name="contextoAcessoDado"></param>
/// <param name="tipoCommandDataAdapter"></param>
/// <param name="commandWrappersDataAdapter"></param>
/// <returns></returns>
internal static DbCommand ObterCommand(ContextoAcessoDado contextoAcessoDado, TipoCommandDataAdapter tipoCommandDataAdapter, Dictionary<TipoCommandDataAdapter, CommandWrapper> commandWrappersDataAdapter)
{
if (commandWrappersDataAdapter.ContainsKey(tipoCommandDataAdapter))
{
CommandWrapper commandWrapper = commandWrappersDataAdapter[tipoCommandDataAdapter];
return commandWrapper.ObterCommand(contextoAcessoDado);
}
else
{
return null;
}
}