Database.BeginTransaction vs Transactions.TransactionScope

The accepted and popular answer is misleading. Both Database.BeginTransaction() and System.Transactions.TransactionScope are for DB operations.

The main differences between Database.BeginTransaction() and System.Transactions.TransactionScope:

Style

• With TransactionScope you set the transactions implicitly in the background (by wrapping all transactional actions with a starting using scope = new TransactionScope and an ending scope.Complete(); to commit.
• With Database.BeginTransaction the transaction is set explicitly by writing sqlCommand.Transaction = sqlTxn; and context.Database.UseTransaction(sqlTxn);

Distributed Transactions

• TransactionScope supports both distributed transactions (where multiple DB involved in a single transaction) and non-distributed transactions.
• Database.BeginTransaction only supports non-distributed transactions (a local transaction where all actions are done within a single DB).

MSDN do state that with the new Database.BeginTransaction() and Database.UseTransaction() APIs, the TransactionScope approach is no longer necessary for most users.

Advantages and disadvantages of TransactionScope:

Disadvantages of TransactionScope:

• Requires .NET 4.5.1 or greater to work with asynchronous methods.
• It cannot be used in cloud scenarios unless you are sure you have one and only one connection (cloud scenarios do not support distributed transactions).
• It cannot be combined with the Database.UseTransaction() approach of the previous sections.
• It will throw exceptions if you issue any DDL and have not enabled distributed transactions through the MSDTC Service.

Advantages of TransactionScope:

• It will automatically upgrade a local transaction to a distributed transaction if you make more than one connection to a given database or combine a connection to one database with a connection to a different database within the same transaction (note: you must have the MSDTC service configured to allow distributed transactions for this to work).
• Ease of coding. If you prefer the transaction to be ambient and dealt with implicitly in the background rather than explicitly under you control then the TransactionScope approach may suit you better.

Based on this MSDN article.

I found out the answer in Entity Framework 6's documentation:

With the introduction of EF6, Microsoft recommends to use new API methods: Database.BeginTransaction() and Database.UseTransaction(). Although System.Transactions.TransactionScope is still very well supported, it is no longer necessary for most users of EF6.

While Database.BeginTransaction() is used only for database related operations transaction, System.Transactions.TransactionScope, in addition to that, makes it possible for 'plain C# code' to also be transactional.

Hence, use Database.BeginTransaction() where ever doing only db related operations in a transaction in EF6 otherwise use System.Transactions.TransactionScope for mixing db operations and C# code together in a transaction.

For those who still prefer the TransactionScope approach, it is recommended they checkout its limitations, especially in cloud scenarios (cloud scenarios do not support distributed transactions).

Further information can be found here