Improving performance of linq query

Question

I'm optimizing a method with a number of Linq queries. So far the execution time is around 3 seconds and I'm trying to reduce it. There is quite a lot of operations and calculations happening in the method, but nothing too complex.

I will appreciate any suggections and ideas how the performance can be improved and code optimized.

---

The whole code of the method(Below I'll point where I have the biggest delay):

public ActionResult DataRead([DataSourceRequest] DataSourceRequest request)
{
    CTX.Configuration.AutoDetectChangesEnabled = false;

    var repoKomfortaktion = new KomfortaktionRepository();
    var komfortaktionen = CTX.Komfortaktionen.ToList();

    var result = new List<AqGeplantViewModel>();

    var gruppen = new HashSet<Guid?>(komfortaktionen.Select(c => c.KomfortaktionsGruppeId).ToList());

    var hochgeladeneKomplettabzuege = CTX.Komplettabzug.Where(c => gruppen.Contains(c.KomfortaktionsGruppeId)).GroupBy(c => new { c.BetriebId, c.KomfortaktionsGruppeId }).Select(x => new { data = x.Key }).ToList();
    var teilnehmendeBetriebe = repoKomfortaktion.GetTeilnehmendeBetriebe(CTX, gruppen);
    var hochgeladeneSperrlistenPlz = CTX.SperrlistePlz.Where(c => gruppen.Contains(c.KomfortaktionsGruppeId) && c.AktionsKuerzel != null)
                                                                        .GroupBy(c => new { c.AktionsKuerzel, c.BetriebId, c.KomfortaktionsGruppeId }).Select(x => new { data = x.Key }).ToList();

    var hochgeladeneSperrlistenKdnr = CTX.SperrlisteKdnr.Where(c => gruppen.Contains(c.KomfortaktionsGruppeId) && c.AktionsKuerzel != null)
                                                                        .GroupBy(c => new { c.AktionsKuerzel, c.BetriebId, c.KomfortaktionsGruppeId }).Select(x => new { data = x.Key }).ToList();

    var konfigsProAktion = CTX.Order.GroupBy(c => new { c.Vfnr, c.AktionsId }).Select(c => new { count = c.Count(), c.Key.AktionsId, data = c.Key }).ToList();
    foreach (var komfortaktion in komfortaktionen)
    {
        var item = new AqGeplantViewModel();

        var zentraleTeilnehmer = teilnehmendeBetriebe.Where(c => c.TeilnahmeStatus.Any(x => x.KomfortaktionId == komfortaktion.Id && x.AktionsTypeId == 1)).ToList();
        var lokaleTeilnehmer = teilnehmendeBetriebe.Where(c => c.TeilnahmeStatus.Any(x => x.KomfortaktionId == komfortaktion.Id && x.AktionsTypeId == 2)).ToList();

        var hochgeladeneSperrlistenGesamt =
                hochgeladeneSperrlistenPlz.Count(c => c.data.AktionsKuerzel == komfortaktion.Kuerzel && c.data.KomfortaktionsGruppeId == komfortaktion.KomfortaktionsGruppeId) +
                hochgeladeneSperrlistenKdnr.Count(c => c.data.AktionsKuerzel == komfortaktion.Kuerzel && c.data.KomfortaktionsGruppeId == komfortaktion.KomfortaktionsGruppeId);

        item.KomfortaktionId = komfortaktion.KomfortaktionId;
        item.KomfortaktionName = komfortaktion.Aktionsname;
        item.Start = komfortaktion.KomfortaktionsGruppe.StartAdressQualifizierung.HasValue ? komfortaktion.KomfortaktionsGruppe.StartAdressQualifizierung.Value.ToString("dd.MM.yyyy") : string.Empty;
        item.LokalAngemeldet = lokaleTeilnehmer.Count();
        item.ZentralAngemeldet = zentraleTeilnehmer.Count();

        var anzHochgelandenerKomplettabzuege = hochgeladeneKomplettabzuege.Count(c => zentraleTeilnehmer.Count(x => x.BetriebId == c.data.BetriebId) == 1) +
                                               hochgeladeneKomplettabzuege.Count(c => lokaleTeilnehmer.Count(x => x.BetriebId == c.data.BetriebId) == 1);

        item.KomplettabzugOffen = (zentraleTeilnehmer.Count() + lokaleTeilnehmer.Count()) - anzHochgelandenerKomplettabzuege;

        item.SperrlisteOffen = (zentraleTeilnehmer.Count() + lokaleTeilnehmer.Count()) - hochgeladeneSperrlistenGesamt;

        item.KonfigurationOffen = zentraleTeilnehmer.Count() - konfigsProAktion.Count(c => c.AktionsId == komfortaktion.KomfortaktionId && zentraleTeilnehmer.Any(x => x.Betrieb.Vfnr == c.data.Vfnr));

        item.KomfortaktionsGruppeId = komfortaktion.KomfortaktionsGruppeId;
        result.Add(item);
    }

    return Json(result.ToDataSourceResult(request));
}

The first half (before foreach) takes half a second which is okay. The biggest delay is inside foreach statement in the first iteration and in particular in these lines, execution of zentraleTeilnehmer takes 1.5 second for the first time.

var zentraleTeilnehmer = teilnehmendeBetriebe.Where(c => c.TeilnahmeStatus.Any(x => x.KomfortaktionId == komfortaktion.Id && x.AktionsTypeId == 1)).ToList();
var lokaleTeilnehmer = teilnehmendeBetriebe.Where(c => c.TeilnahmeStatus.Any(x => x.KomfortaktionId == komfortaktion.Id && x.AktionsTypeId == 2)).ToList();

TeilnehmendeBetriebe has over 800 lines, where TeilnahmeStatus property has normally around 4 items. So, maximum 800*4 iterations, which is not a huge number afterall...

Thus, I'm mostly interected in optimizing these lines, hoping to reduce execution time to half a second or so.

What I tried:

1. Rewrite Linq to foreach: didn't help, same time... probably not surprising, but was worth a try.

   foreach (var tb in teilnehmendeBetriebe) //836 items
   {
       foreach (var ts in tb.TeilnahmeStatus) //3377 items
       {
           if (ts.KomfortaktionId == komfortaktion.Id && ts.AktionsTypeId == 1)
           {
               testResult.Add(tb);
               break;
           }
       }
   }
   

2. Selecting particular columns for teilnehmendeBetriebe with .Select(). Didn't help either.

Neither helped other small manipulations I tried.

What is interesting - while the first iteration of foreach can take up to 2 seconds, the second and further take just milisecons, so .net is capable of optimizing or reusing calculation data.

Any advice on what can be changed in order to improve performance is very welcome!

Edit:
TeilnahmeBetriebKomfortaktion.TeilnahmeStatus is loaded eagerly in the method GetTeilnehmendeBetriebe:

    public List<TeilnahmeBetriebKomfortaktion> GetTeilnehmendeBetriebe(Connection ctx, HashSet<Guid?> gruppen)
    {
        return ctx.TeilnahmeBetriebKomfortaktion.Include(
                                        c => c.TeilnahmeStatus).ToList();
    }

Edit2: The query which is sent when executing GetTeilnehmendeBetriebe:

    SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent1].[BetriebId] AS [BetriebId], 
    [Extent1].[MandantenId] AS [MandantenId], 
    [Extent1].[CreatedUser] AS [CreatedUser], 
    [Extent1].[UpdatedUser] AS [UpdatedUser], 
    [Extent1].[CreatedDate] AS [CreatedDate], 
    [Extent1].[UpdatedDate] AS [UpdatedDate], 
    [Extent1].[IsDeleted] AS [IsDeleted]
    FROM [Semas].[TeilnahmeBetriebKomfortaktion] AS [Extent1]
    WHERE [Extent1].[IsDeleted] <> cast(1 as bit)

Answer 1

My assumption is that TeilnahmeBetriebKomfortaktion.TeilnahmeStatus is a lazy loaded collection, resulting in the N + 1 problem. You should eagerly fetch that collection to improve your performance.

The following iterations of the foreach loop are fast, because after the first iteration those objects are no longer requested from the database server but are server from memory.