DBContext System.ObjectDisposed Exception con .NET Entity Framework Core, Iniezione delle dipendenze e threading

Non sono sicuro se lo sto affrontando correttamente.

Contesto: ho un'azione del controller GET foo () come esempio. Questo foo () deve andare e chiamare bar (), e bar () potrebbe richiedere molto tempo. Quindi, ho bisogno di foo () per rispondere con "OK" prima (o indipendentemente da quando) la barra () completa .

Una leggera complessità è che bar () deve accedere a DBContext e recuperare alcuni dati dal DB. Con la mia attuale implementazione, ottengo un'eccezione "DBContext System.ObjectDisposed" quando provo ad accedere al db tramite barra. Qualche idea sul perché e come posso aggirare questo per favore? Sono davvero nuovo ai thread e ai compiti, quindi potrei sbagliare completamente!

Uso l'iniezione di dipendenza per fornire il contesto DB all'avvio

     services.AddEntityFrameworkNpgsql()
        .AddDbContext<MyDBContext>()
        .BuildServiceProvider();

Quindi faccio call a foo () che a sua volta chiama bar () usando un nuovo thread (forse sto sbagliando?):

    public async Task<string> foo(string msg)
    {

        Thread x = new  Thread(async () =>
        {
            await bar(msg);
        });

        x.IsBackground = true;
        x.Start();

        return "OK.";
    }

Quindi la barra tenta immediatamente di accedere a DBContext per afferrare alcune entità e genera l'eccezione!

Eccezione non gestita: System.ObjectDisposedException: impossibile accedere a un oggetto eliminato. Una causa comune di questo errore è l'eliminazione di un contesto che è stato risolto dall'iniezione delle dipendenze e successivamente il tentativo di utilizzare la stessa istanza di contesto altrove nell'applicazione. Ciò può verificarsi se si chiama Dispose () sul contesto o si avvolge il contesto in un'istruzione using. Se si utilizza l'iniezione di dipendenza, è necessario lasciare che il contenitore di iniezione di dipendenza si occupi di eliminare le istanze di contesto. Nome oggetto: "MyDBContext".

Se tolgo bar () dal thread, va bene ma ovviamente "OK" non viene restituito fino a quando la barra non ha terminato il suo processo molto lungo, che è il problema che devo risolvere.

Mille grazie per qualche consiglio, per favore.

MODIFICA con il codice in esecuzione MA è ancora in attesa del completamento di Task.Run prima di restituire "OK". (quasi lì?)

public async Task<string> SendBigFile(byte[] fileBytes)
{
    ServerLogger.Info("SendBigFile called.");

    var task = Task.Run(async () =>
    {
        using (var scope = _serviceScopeFactory.CreateScope())
        {
            var someProvider = scope.ServiceProvider.GetService<ISomeProvider>();
            var fileProvider = scope.ServiceProvider.GetService<IFileProvider>();

            await GoOffAndSend(someProvider, fileProvider, fileBytes);
        }
    });

    ServerLogger.Info("Hello World, this should print and not wait for Task.Run."); //Unfortunately this is waiting even though GoOffAndSend takes at least 1 minute.

    return "Ok";  //This is not returned until Task.Run finishes unfortunately... how do I "skip" to this immediately?
}

private async Task GoOffAndSend(ISomeProvider s, IFileProvider f, byte[] bytes)
{
    // Some really long task that can take up to 1 minute that involves finding the file, doing weird stuff to it and then
    using (var client = new HttpClient())
    {
        var response = await client.PostAsync("http://abcdef/somewhere", someContent);
    }
}