Integration testing with Events - Exceptions when running multiple tests at the same time

I am using a shared database fixture for my tests, but when running multiple tests at the same time, I get the following error message:

System.InvalidOperationException: A second operation was started on this context before a previous operation completed. This is usually caused by different threads concurrently using the same instance of DbContext. For more information on how to avoid threading issues with DbContext, see https://go.microsoft.com/fwlink/?linkid=2097913.

This is my code of my Fixture:

public class SharedDatabaseFixture : IDisposable
{
    public static readonly object _lock = new object();
    private static bool _databaseInitialized;

    private const string postgresConnectionString = "Host=localhost;Database=IntegrationTests; Username=postgres;Password=password";

    public SharedDatabaseFixture()
    {
        Connection = new NpgsqlConnection(postgresConnectionString);

        Seed();

        Connection.Open();
    }

    public DbConnection Connection { get; }

    public AppDbContext CreateContext(DbTransaction transaction = null!)
    {
        var serviceProvider = new ServiceCollection()
            .AddEntityFrameworkNpgsql()
            .AddMediatR(typeof(IAggregateRoot).Assembly)
            .AddScoped(typeof(IAsyncRepository<>), typeof(EfRepository<>))
            .AddDbContext<AppDbContext>(options => options.UseNpgsql(Connection))
            .BuildServiceProvider();

        ServiceLocator.SetLocatorProvider(serviceProvider);
        DomainEvents.Mediator = () => ServiceLocator.Current.GetInstance<IMediator>();

        var builder = new DbContextOptionsBuilder<AppDbContext>();
        builder.UseNpgsql(Connection).UseInternalServiceProvider(serviceProvider);

        var context = new AppDbContext(builder.Options);

        if (transaction != null)
        {
            context.Database.UseTransaction(transaction);
        }

        return context;
    }

    private void Seed()
    {
        lock (_lock)
        {
            if (!_databaseInitialized)
            {
                using (var context = CreateContext())
                {
                    context.Database.EnsureDeleted();
                    context.Database.EnsureCreated();

                    var appDbContextSeed = new AppDbContextSeed(context);
                    appDbContextSeed.SeedAsync().Wait();
                }

                _databaseInitialized = true;
            }
        }
    }

    public void Dispose() => Connection.Dispose();
}

The code I am testing uses events and those events do queries to the database. Therefore, I am registering some services and also a DbContext.

The problem is, when I run multiple tests at the same time, events are raised at the same time as well and because they are all using the same DbContext, it throws an exception when two handlers try to use the DbContext at the same time.

So, my question is: how can I instantiate a DbContext for each test (but using the same connection) or prevent it from using the DbContext at the same time?

An Example of one of my tests:

public class Project_Create : IClassFixture<SharedDatabaseFixture>
{
    public SharedDatabaseFixture Fixture { get; }
    public Project_Create(SharedDatabaseFixture fixture) => Fixture = fixture;

    [Fact]
    public void Creates_succesfully()
    {
        var project = new Project(SeedConstants.TEST_COMPANY_ID, "ABC", "Hallo123", "2018-123");

        Assert.Equal(SeedConstants.TEST_COMPANY_ID, project.CompanyId);
        Assert.Equal("ABC", project.Code);
        Assert.Equal("Hallo123", project.Description);
        Assert.Equal("2018-123", project.Number);
    }
}

Project.cs:

public class Project : BaseEntity<Guid, ProjectValidator, Project>, IAggregateRoot
{
    public Guid CompanyId { get; private set; }

    public string Code {  get; private set; }

    public string Description { get; private set; }

    public string Number {  get; private set; }

    public Project(Guid companyId, string code, string description, string number)
    {
        CompanyId = companyId;
        Code = code;
        Description = description;
        Number = number;

        Validate(this);
        DomainEvents.Raise(new SetCompanyIdEvent(companyId)).GetAwaiter().GetResult();
    }
}

As you can see, this project class raises an event. This event has a handler and looks like this:

public class CheckIfProjectIdExistsHandler : INotificationHandler<SetProjectIdEvent>
{
    private readonly IAsyncRepository<Project> _projectRepository;

    public CheckIfProjectIdExistsHandler(IAsyncRepository<Project> projectRepository)
    {
        _projectRepository = projectRepository;
    }

    public async Task Handle(SetProjectIdEvent notification, CancellationToken cancellationToken)
    {
        var project = await _projectRepository.GetByIdAsync(notification.ProjectId, cancellationToken);

        if (project == null)
        {
            throw new ProjectDoesNotExistsException($"The project with ID {notification.ProjectId} does not exist.");
        }
    }
}

I hope this illustrates what I am testing