Transações em .net

Question

O que são as melhores práticas para fazer transações em C # .Net 2.0. Quais são as classes que devem ser usados? Quais são as armadilhas de olhar para fora etc. Todos os que cometem e coisas reversão. Eu estou apenas começando um projeto onde eu poderia precisar de fazer algumas transações ao inserir dados no DB. Quaisquer respostas ou links para até mesmo coisas básicas sobre transações são bem-vindos.

Answer 1

Existem 2 tipos principais de transações; operações de ligação e transacções ambiente. Uma transação de conexão (como SqlTransaction) está ligada diretamente à conexão db (como SqlConnection), o que significa que você tem que manter transmitindo a conexão ao redor - OK, em alguns casos, mas não permite "criar / utilização / release" uso, e não permitir que o trabalho cross-db. Um exemplo (formatado para o espaço):

using (IDbTransaction tran = conn.BeginTransaction()) {
    try {
        // your code
        tran.Commit();
    }  catch {
        tran.Rollback();
        throw;
    }
}

Não muito confuso, mas limitado a nossa ligação "conn". Se queremos chamar a diferentes métodos, precisamos agora de passar "conn" ao redor.

A alternativa é uma transação de ambiente; novo em .NET 2.0, o href="http://msdn.microsoft.com/en-us/library/system.transactions.transactionscope.aspx" rel="noreferrer"> TransactionScope objecto

Por exemplo:

using(TransactionScope tran = new TransactionScope()) {
    CallAMethodThatDoesSomeWork();
    CallAMethodThatDoesSomeMoreWork();
    tran.Complete();
}

Note aqui que os dois métodos pode lidar com suas próprias conexões (/ uso abrir / fechar / eliminar), ainda que silenciosamente se tornará parte da transação de ambiente sem nós ter que passar nada em.

Se os seus erros de código, Dispose () será chamado sem Completo (), por isso vai ser revertida. O esperado nidificação etc é suportado, embora você não pode roll-back de uma transação interna ainda completar a transação externa:. Se alguém está infeliz, a transação é abortada

A outra vantagem de TransactionScope é que ele não está vinculado apenas a bases de dados; qualquer provedor de transação-aware pode usá-lo. WCF, por exemplo. Ou há mesmo alguns modelos TransactionScope compatível objeto em torno de (i NET classes com capacidade de reversão - talvez mais fácil do que uma lembrança, embora eu nunca usei essa abordagem eu)

.

Ao todo, um objeto muito, muito útil.

Algumas advertências:

• No SQL Server 2000, um TransactionScope irá imediatamente para DTC; este é corrigido no SQL Server 2005 e acima, ele pode usar o LTM (muito menos sobrecarga) até você falar com 2 fontes, etc, quando é elevada a DTC.
• Há um falha isso significa que você pode precisar de ajustar sua seqüência de conexão

Answer 2

protected void Button1_Click(object sender, EventArgs e)
   {


       using (SqlConnection connection1 = new SqlConnection("Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Database.mdf;Integrated Security=True;User Instance=True"))
       {
           connection1.Open();

           // Start a local transaction.
           SqlTransaction sqlTran = connection1.BeginTransaction();

           // Enlist a command in the current transaction.
           SqlCommand command = connection1.CreateCommand();
           command.Transaction = sqlTran;

           try
           {
               // Execute two separate commands.
               command.CommandText =
                "insert into [doctor](drname,drspecialization,drday) values ('a','b','c')";
               command.ExecuteNonQuery();
               command.CommandText =
                "insert into [doctor](drname,drspecialization,drday) values ('x','y','z')";
               command.ExecuteNonQuery();

               // Commit the transaction.
               sqlTran.Commit();
               Label3.Text = "Both records were written to database.";
           }
           catch (Exception ex)
           {
               // Handle the exception if the transaction fails to commit.
               Label4.Text = ex.Message;


               try
               {
                   // Attempt to roll back the transaction.
                   sqlTran.Rollback();
               }
               catch (Exception exRollback)
               {
                   // Throws an InvalidOperationException if the connection 
                   // is closed or the transaction has already been rolled 
                   // back on the server.
                   Label5.Text = exRollback.Message;

               }
           }
       }


   }

Answer 3

Você também poderia envolver a transação-se nele é procedimento armazenado própria e manipulá-lo dessa forma em vez de fazer transações em C # si.

Answer 4

Se você só precisa dele para coisas db-relacionadas, algumas ou Mappers (por exemplo, NHibernate) apoio transactinos fora da caixa por padrão.

Answer 5

Ele também depende do que você precisa. Para transações SQL básicas que você poderia tentar fazer transações TSQL usando BEGIN TRANS e COMMIT TRANS em seu código. Essa é a maneira mais fácil, mas ele tem complexidade e você tem que ter cuidado para cometer corretamente (e rollback).

Gostaria de usar algo como

SQLTransaction trans = null;
using(trans = new SqlTransaction)
{
    ...
    Do SQL stuff here passing my trans into my various SQL executers
    ...
    trans.Commit  // May not be quite right
}

Qualquer falha irá aparecer-lhe a direita fora da using ea transação será sempre confirmação ou reversão (dependendo do que você diga a ele para fazer). O maior problema que enfrentamos foi ter certeza que ele sempre comprometida. Os garante que usam o escopo da transação é limitado.