EF queries to different DB contexts seem to cache after the first call

Question

I have a database with three tables and I am making a program that will select and need to display results from all three at the same time.

In order to speed up the getting of records I decided to make the requests async so that they can happen at the same time.
Since you cannot perform more than one concurrent operation on the same DB context, I just instantiate three contexts, in total, and start a Linq query "ToListAsync()" on each one.

But something weird (for me) happens - the async version wasn't any faster than the sync version. Whether I get the results asynchroniously with ".ToListAsync()" or synchronously with ".ToList()" they take the same amount of time. With the sync version, the first operation takes ~2s to complete while the second ~170ms and the third ~90ms. I suppose some sort of execution plan or caching or establishing the connection is what makes the first request take a lot of time while the others complete almost instanteniously but I'd like to know WHY exactly this happens and if there is a way to make it faster.
Forgot to mention the async version takes the same amount of time - 2s.

Relevant code:

        int maxRecords = 10;
        var resultsTableOne = dbContext.tableOne.Where(log =>
                                            log.DateUtc >= dateFrom || dateFrom == null)
                                        && (log.DateUtc <= dateTo || dateTo == null))
                                            .OrderByDescending(log => log.Id).Take(maxRecords).ToList();
        var resultsTableTwo = dbContext.tableTwo.Where(log =>
                                            log.DateUtc >= dateFrom || dateFrom == null)
                                        && (log.DateUtc <= dateTo || dateTo == null))
                                            .OrderByDescending(log => log.Id).Take(maxRecords).ToList();
        var resultsTableThree = dbContext.tableThree.Where(log =>
                                            log.DateUtc >= dateFrom || dateFrom == null)
                                        && (log.DateUtc <= dateTo || dateTo == null))
                                            .OrderByDescending(log => log.Id).Take(maxRecords).ToList();

The select conditions are simplified here. For the async version, the "ToList" is replaced with "ToListAsync", which returns a task on which "GetAwaiter().GetResult()" is called after the code shown here (and the "dbContext" is replaced with three separate instances).

P.S.
The results for the sync version are the same with one and three DbContexts. I.e. it takes the same amount of time whether all three operations are performed on the same instance or each on its own instance.

Answer 1

In order to speed up the getting of records I decided to make the requests async so that they can happen at the same time.

This isn't what the async/await pattern does. What you seem to want to do is parallelization, which you can use async methods and their associated Task, however this requires 3 distinct instances of a DbContext. As a very bare-bones example relative to the code you had:

using (var context1 = new AppDbContext())
{
    using (var context2 = new AppDbContext())
    {
        using (var context3 = new AppDbContext())
        {
            var table1Task = context1.tableOne
                .Where(log =>
                    log.DateUtc >= dateFrom || dateFrom == null)
                    && (log.DateUtc <= dateTo || dateTo == null))
                .OrderByDescending(log => log.Id)
                .Take(maxRecords).ToListAsync();
            var table2Task = context2.tableTwo
                .Where(log =>
                    log.DateUtc >= dateFrom || dateFrom == null)
                    && (log.DateUtc <= dateTo || dateTo == null))
                .OrderByDescending(log => log.Id)
                .Take(maxRecords).ToListAsync();
            var table3Task = context3.tableThree
                .Where(log =>
                    log.DateUtc >= dateFrom || dateFrom == null)
                    && (log.DateUtc <= dateTo || dateTo == null))
                .OrderByDescending(log => log.Id)
                .Take(maxRecords).ToListAsync();
           var resultTask = Task.WhenAll(table1Task, table2Task, table3Task);
           try
           {
               resultTask.Wait();
               var result1 = table1Task.Result;
               var result2 = table2Task.Result;
               var result3 = table3Task.Result;
               // Use your 3 lists.
           }
           catch(Exception ex)
           {// Handle any exception when running.
           }
        }
    }
}

Each query must run on a separate DbContext as the DbContext is not thread safe.

As mentioned in the comments, there are far better things to be looking into for improving performance including indexing and using projection rather than returning entire entities. If Table1 rows are quite large with many large fields that aren't needed by the resulting code, projecting with Select to get just the columns you need can help deliver far more performant code. Parallelism is only something I would consider when faced with running several queries where one or more might take a substantial amount of time and the results from each are completely independent.