using System;

using System.Threading;

using System.Threading.Tasks;

using Microsoft.EntityFrameworkCore;

using System.Transactions;

​

public class Program

{

    public static async Task Main()

    {

        //var contextOptions = new DbContextOptionsBuilder<MyDbContext>().UseInMemoryDatabase("MyDbContext") //.ConfigureWarnings(b => b.Ignore(InMemoryEventId.TransactionIgnoredWarning))

        //.Options;

        using var context = Helper.GenerateDbContext(); //new MyDbContext(contextOptions);

        context.Database.EnsureDeleted();

        context.Database.EnsureCreated();

        // DbContext is ready!

        var svcB = new ServiceB(context, false);

        var svcA = new ServiceA(context, svcB);

        // Act!

        try

        {

            await svcA.Save(new ClassA());

        }

        catch (Exception ex)

        {

            Console.WriteLine("\n----------======== Caught! ========----------\n");

            Console.WriteLine(ex);

        }

​

        await Write(context);

    }

​

    public static async Task Write(MyDbContext context)

    {

        Console.WriteLine("----------======== Write context! ========----------");

        var listOfA = await context.As.ToListAsync();

        var listOfB = await context.Bs.ToListAsync();

        foreach (var a in listOfA)

            Console.WriteLine($"a: {a.Id}");

        foreach (var b in listOfB)

            Console.WriteLine($"b: {b.Id}");

        Console.WriteLine("----------======== Done! ========----------");

    }

}

​

public class ServiceA

{

    private readonly MyDbContext _dbContext;

    private readonly IServiceB _serviceB;

    public ServiceA(MyDbContext dbContext, IServiceB serviceB)

    {

        _dbContext = dbContext;

        _serviceB = serviceB;

    }

​

    public async Task Save(ClassA a)

    {

        //using var transaction = new TransactionScope(); //TransactionScopeAsyncFlowOption.Enabled);

        using var transaction = await _dbContext.Database.BeginTransactionAsync();

        try

        {

            _dbContext.Add(a);

            var b = new ClassB();

            await _serviceB.Save(b);

            _dbContext.Add(new ClassA { Id = b.Id + 100 });

            await _dbContext.SaveChangesAsync(CancellationToken.None);

            //transaction.Complete();

            await transaction.CommitAsync();

        }

        catch (Exception)

        {

            await transaction.RollbackAsync();

            // Handle the exception as needed

            throw;

        }

    }

}

​

public class ServiceB : IServiceB

{

    private readonly MyDbContext _dbContext;

    private readonly bool _throwException;

    public ServiceB(MyDbContext dbContext, bool throwException)

    {

        _dbContext = dbContext;

        _throwException = throwException;

    }

​

    public async Task Save(ClassB b)

    {

        _dbContext.Add(b);

        await _dbContext.SaveChangesAsync(CancellationToken.None);

        if (_throwException)

            throw new Exception("ServiceB.Save() induced exception!");

    }

}

​

public interface IServiceB

{

    Task Save(ClassB b);

}

​

public class MyDbContext : DbContext

{

    public MyDbContext(DbContextOptions options) : base(options)

    {

    }

​

    public DbSet<ClassA> As { get; set; }

    public DbSet<ClassB> Bs { get; set; }

​

    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken)

    {

        return await base.SaveChangesAsync(cancellationToken);

    }

​

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)

    {

    //optionsBuilder.LogTo(Console.WriteLine);

    }

}

​

public class ClassA

{

    public int Id { get; set; }

}

​

public class ClassB

{

    public int Id { get; set; }

}

​

public static class Helper

{

    public static MyDbContext GenerateDbContext()

    {

        var connection = new Microsoft.Data.Sqlite.SqliteConnection("Filename=:memory:");

        connection.Open();

        // These options will be used by the context instances in this test suite, including the connection opened above.

        var contextOptions = new DbContextOptionsBuilder<MyDbContext>().UseSqlite(connection).Options;

        return new MyDbContext(contextOptions);

    }

}