Handle Entity Framework Transactions

Introduction

In this article, we will learn Entity Framework Transactions.

So, Let's get started.

Understanding Transactions

Transactions ensure data integrity by treating multiple operations as a single unit.
They are essential for maintaining consistency, especially in complex applications.

Built-in Transaction Management

Entity Framework (EF) provides built-in transaction management through the DbContext.
EF automatically handles transactions for single SaveChanges calls.

using (var context = new AppDbContext())
  {
	 // Operations 
	 context.SaveChanges(); // EF handles transaction automatically
  }

Handling Multiple Operations as a Unit

Transactions are crucial for ensuring data integrity when performing multiple related operations. For instance, transferring money between accounts involves debiting one account and crediting another. Both operations should be part of a single transaction.

Example

using (var context = new AppDbContext())
  {
	 using (var transaction  = context.Database.BeginTransaction()) 
	   {
	     try 
	      {	         
	         // Debit one account
	         // Credit another account 
	        
	         context.SaveChanges();
	         transaction.commit();
	      }
	     catch(Exception ex)
	      {
	        transaction.Rollback();
	        // Handle the exception
	      }
	   }
   }

Rollback Strategies

Rollbacks revert all changes if any operation fails.
Essential for maintaining data integrity in case of errors.

using (var context = new AppDbContext())
  {
	 using (var transaction  = context.Database.BeginTransaction()) 
	   {
	     try 
	      {
	        // Operations
	        transaction.commit();
	      }
	     catch(Exception ex)
	      {
	        transaction.Rollback();
	      }
	   }
  }

Commit Strategies

Use Commit to finalize transactions after successful operations.
Always wrap Commit within a try catch block to handle exception.

using (var context = new AppDbContext())
  {
	 using (var transaction  = context.Database.BeginTransaction()) 
	   {
	     try 
	      {
	        // Operations
	        transaction.commit();
	      }
	     catch(Exception ex)
	      {
	        transaction.Rollback();
            // Log or Handle the exception
	      }
	   }
  }

Combining Explicit Transactions with Multiple Contexts

Handle transactions across multiple DbContext instances.
Ensure consistency across different data sources.

using (var context1 = new AppDbContext1())
using (var context2 = new AppDbContext2())
 {
	using (var transaction  = context1.Database.BeginTransaction()) 
	 {
  	    try 
  	     {
  	        // Operations on context1
  	        context1.SaveChanges();
  	         
  	        // Operations on context2
  	        context2.Database.UseTransaction(transaction.GetDbTransation());
  	        context2.SaveChanges();
  	         
  	        transaction.commit();
  	     }
  	    catch(Exception ex)
  	     {
  	        transaction.Rollback();
  	     }
     }
 }

Points to be taken

Transactions are critical for data integrity.
EF provides built-in and explicit transaction management.
Rollbacks and commits ensure consistency and handle errors effectively.

Conclusion

In this article, I have tried to cover how to handle Entity Framework Transactions.