Ускоряемся в Entity Framework Core

Что насчет асинхронности?
Да! Используем ее где только можно!

Аргументируйте. В том смысле, что докажите, вот этот код (ваш пример):

public void Do()
{
    var myTask = GetFederalDistrictsAsync ();
    foreach (var item in myTask.Result)
    {
         //Ваш код
    }
}

public async Task<List<FederalDistrict>> GetFederalDistrictsAsync()
{
    var conn = configurationRoot.GetConnectionString("EFCoreTestContext");
    optionsBuilder.UseSqlServer(conn);
    using var context = new EFCoreTestContext(optionsBuilder.Options);
    return await context.FederalDistricts.ToListAsync();
}

быстрее, чем вот этот:

public void Do()
{
    foreach (var item in GetFederalDistricts())
    {
         //Ваш код
    }
}

public List<FederalDistrict> GetFederalDistricts()
{
    var conn = configurationRoot.GetConnectionString("EFCoreTestContext");
    optionsBuilder.UseSqlServer(conn);
    using var context = new EFCoreTestContext(optionsBuilder.Options);
    return context.FederalDistricts.ToList();
}

Не говоря уже о том, что вот так:

var myTask = GetFederalDistrictsAsync ();
foreach (var item in myTask.Result)

делать без веских причин не надо.

Статья в принципе не особо высокого уровня, каких-то кардинально новых вещей не увидел, хотя и хотелось. (Но всё равно статье плюс, в целом сгодится хотя бы как "повторение — мать учения").

Не хватает конкретики, на сколько можно разогнаться тем или иным способом.
Например, насколько я помню, майкрософт в одном из документов приводила цифры про ускорение при помощи .AsNoTracking и там были цифры порядка 15-20% (документ 2005 — 2008 года, его уже на офсайте найти весьма проблематично), новых исследований для core я к сожалению не видел, поэтому просто полагаюсь что по-прежнему даёт довольно существенный прирост.

Также было бы неплохо вот тут проиллюстрировать хотя простым тестом:

Если вставляемые записи одинаковые имеет смысл использовать одну операцию сохранения на все записи. Если контекст транзакции сложный, то есть состоит из нескольких независимых операций, то можно выполнять сохранение после выполнения каждой операции. А еще правильней использовать асинхронное сохранение в транзакции.

Можно было бы создать таблицу на 10-15 полей без ключей к другим таблицам и показать на сколько примерно возрастёт скорость. Даже семейство графиков построить: если таблица на 5 полей, на 10, на сто. Или померять как влияют самые типовые поля типа строк или чисел.

А что вы знаете про компилированные запросы LINQ?

Да и вот тут пример с цифрами не помешал бы. Я не знаю, насколько большие цифры будут, мне кажется, что не особо большие — потому что в .net первый раз компиляция происходит довольно медленно, но за счёт того, что повторно код заново не компилируется — то на второй и последующие разы эффект уже не особо сильный. Ошибаюсь? Нет? Вот не знаю, хотелось бы видеть цифры.

AsQueryable
Принимает параметр: Expression<Func <TSource, bool>

Что я только что прочитал?

var blogs = context.Blogs.AsEnumerable().Where(blog => StandardizeUrl(blog.Url).Contains("dotnet")).ToList();

Если ты хочешь все запараллелить чтобы ускориться, то обломись

public async Task<List<Blog>> GetBlogsAsync()
{
    using (var context = new BloggingContext())
    using (var context2 = new BloggingContext())
    {
         // parallel queries
    }
}