交易目的

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; 
}