交易目的

Question

我讀了這麼多關於這個話題的文章，我還有一些重要和基本的問題。 如果事務不用於SQL，交易的目的是什麼？它在wcf中如何幫助我？ 這篇文章顯示了使用簡單的交易的例子：

http://msdn.microsoft.com/en-us/library/ms172152(v=vs.90).aspx

這是什麼下面的代碼，如果它不是用於回滾他們試圖挽回的情況下，該代碼失敗什麼都的目的是什麼？

void RootMethod() 
{ 
    using(TransactionScope scope = new TransactionScope()) 
    { 
      /* Perform transactional work here */ 
      SomeMethod(); 
      scope.Complete(); 
    } 
} 

void SomeMethod() 
{ 
    using(TransactionScope scope = new TransactionScope()) 
    { 
      /* Perform transactional work here */ 
      scope.Complete(); 
    } 
} 

Answer 1

只有支持事務的資源參與事務。通常，這只是SQL Server。消息隊列還支持事務。

如果您不使用任何啓用事務的資源（如正常變量...），則這將不會執行任何操作。

Answer 2

這裏有一個很好的例子

http://msdn.microsoft.com/en-us/library/system.transactions.transactionscope(v=vs.90).aspx#Y500

在該示例中（上面的鏈接，下面的代碼）的SQL的連接對象將自動參與事務 - 因此這些SQL命令將不會前犯交易完成（scope.Complete）。通過這種方式，只有在發生其他事件時，兩個服務器纔會發生。任何異常都會導致回滾。

你的例子並不清楚，因爲它只是在該頁面的上下文中描述嵌套的作用域。這個例子展示了一些可以被認爲是嵌套的東西，而不是一些會做任何有用的代碼。

下面是微軟的示例代碼，我認爲是很清楚的：

// This function takes arguments for 2 connection strings and commands to create a transaction 
// involving two SQL Servers. It returns a value > 0 if the transaction is committed, 0 if the 
// transaction is rolled back. To test this code, you can connect to two different databases 
// on the same server by altering the connection string, or to another 3rd party RDBMS by 
// altering the code in the connection2 code block. 
static public int CreateTransactionScope(
    string connectString1, string connectString2, 
    string commandText1, string commandText2) 
{ 
    // Initialize the return value to zero and create a StringWriter to display results. 
    int returnValue = 0; 
    System.IO.StringWriter writer = new System.IO.StringWriter(); 

    try 
    { 
     // Create the TransactionScope to execute the commands, guaranteeing 
     // that both commands can commit or roll back as a single unit of work. 
     using (TransactionScope scope = new TransactionScope()) 
     { 
      using (SqlConnection connection1 = new SqlConnection(connectString1)) 
      { 
       // Opening the connection automatically enlists it in the 
       // TransactionScope as a lightweight transaction. 
       connection1.Open(); 

       // Create the SqlCommand object and execute the first command. 
       SqlCommand command1 = new SqlCommand(commandText1, connection1); 
       returnValue = command1.ExecuteNonQuery(); 
       writer.WriteLine("Rows to be affected by command1: {0}", returnValue); 

       // If you get here, this means that command1 succeeded. By nesting 
       // the using block for connection2 inside that of connection1, you 
       // conserve server and network resources as connection2 is opened 
       // only when there is a chance that the transaction can commit. 
       using (SqlConnection connection2 = new SqlConnection(connectString2)) 
       { 
        // The transaction is escalated to a full distributed 
        // transaction when connection2 is opened. 
        connection2.Open(); 

        // Execute the second command in the second database. 
        returnValue = 0; 
        SqlCommand command2 = new SqlCommand(commandText2, connection2); 
        returnValue = command2.ExecuteNonQuery(); 
        writer.WriteLine("Rows to be affected by command2: {0}", returnValue); 
       } 
      } 

      // The Complete method commits the transaction. If an exception has been thrown, 
      // Complete is not called and the transaction is rolled back. 
      scope.Complete(); 

     } 

    } 
    catch (TransactionAbortedException ex) 
    { 
     writer.WriteLine("TransactionAbortedException Message: {0}", ex.Message); 
    } 
    catch (ApplicationException ex) 
    { 
     writer.WriteLine("ApplicationException Message: {0}", ex.Message); 
    } 

    // Display messages. 
    Console.WriteLine(writer.ToString()); 

    return returnValue; 
}