如何在EF4中为多个ObjectContext实现单个SQL事务

Question

I have a fairly big database with tables created for different business modules.

We decided to create different edmx-files for different modules respectively.

However, how can I prevent the usage of MSDTC when trying to implement a TransactionScope for a logical action that will incur writing to multiple tables in different edmx? Again, the underlying database is the same, I wouldn't want to use MSDTC for this scenario.

Is there any way to pass in an opened SQL connection with active transaction?

Thanks for help in advance.

Regards, William

Answer 1

TransactionScope enlists the MSDTC when the databases are different and/or the connection strings are different.

Rick Strahl has a great article on this (his perspective is LINQ to SQL, but it's applicable to EF). The money paragraphs:

TransactionScope is a high level Transaction wrapper that makes it real easy to wrap any code into a transaction without having to track transactions manually. Traditionally TransactionScope was a .NET wrapper around the Distributed Transaction Coordinator (DTC) but it's functionality has expanded somewhat. One concern is that the DTC is rather expensive in terms of resource usage and it requires that the DTC service is actually running on the machine (yet another service which is especially bothersome on a client installation).

However, recent updates to TransactionScope and the SQL Server Client drivers make it possible to use TransactionScope class and the ease of use it provides without requiring DTC as long as you are running against a single database and with a single consistent connection string. In the example above, since the transaction works with a single instance of a DataContext, the transaction actually works without involving DTC. This is in SQL Server 2008.

See also this SO question/answer where I found the link to Rick's blog.

So if you're connecting to the same database and are using the same connection string, the DTC should not be involved.

Answer 2

thanks for all replies above!

by the way, just managed to find a solution which is to use EntityConnection and EntityTransaction explicitly. A sample is like this:

    string theSqlConnStr = "data source=TheSource;initial catalog=TheCatalog;persist security info=True;user id=TheUserId;password=ThePassword";

    EntityConnectionStringBuilder theEntyConnectionBuilder = new EntityConnectionStringBuilder();
    theEntyConnectionBuilder.Provider = "System.Data.SqlClient";
    theEntyConnectionBuilder.ProviderConnectionString = theConnectionString;
    theEntyConnectionBuilder.Metadata = @"res://*/";

    using (EntityConnection theConnection = new EntityConnection(theEntyConnectionBuilder.ToString()))
    {
        theConnection.Open();
        theET = null;

        try
        {
            theET = theConnection.BeginTransaction();

            DataEntities1 DE1 = new DataEntities1(theConnection);
            //DE1 do somethings...

            DataEntities2 DE2 = new DataEntities2(theConnection);
            //DE2 do somethings...

            DataEntities3 DE3 = new DataEntities3(theConnection);
            //DE3 do somethings...

            theET.Commit();
        }
        catch (Exception ex)
        {
            if (theET != null) { theET.Rollback(); }
        }
        finally
        {
            theConnection.Close();
        }
    }

with explicit use of EntityConnection & EntityTransaction, I can achieve the sharing of single connection and transaction for multiple ObjectContexts for a single database, yet without the need to incur the usage of MSDTC.

Hope this info is helpful. Gd luck!!