Entity Framework mit einbeziehen und wählen zusammen

Question

Ich habe die folgenden Einheiten (Pseudo-Code um Speicherplatz zu sparen)

Program [ int Id, 
      string Name, 
      List<ProgramFoodType> ProgramFoodTypes, 
      List<ProgramFood> ProgramFoods] 

ProgramFoodType[ int Id, int ProgramId, int Type, bool IsActive] 
ProgramFood [ int Id, int ProgramId, Food Food, FoodType FoodType] 
Food [int Id, string Name] 
FoodType [int Id, string Name] 

meine Aufgabe ist, einzelne Program mit ihm verbundenen ProgramFoodTypes mit Bedingung ProgramFoodType bekommen sollte mit entsprechenden aktiven und ProgramFoods sein Einheiten Food und FoodType

I verwendet werden rufen Sie die folgende bisher

1- die folgenden Abfrage die Details ProgramFoodTypes und ProgramFoods aber es werden alle aktiven und inaktiven bringen ProgramFoodTypes

var program = mEntities.Programs 
          .Include(p =>p.ProgramFoodTypes) 
          .Include(p =>p.ProgramFoods.Select(f =>f.Food)) 
          .InClude(p =>p.ProgramFoods.Select(f =>f.FoodType)) 
          .Where(m =>m.Id== Id); 

2- die folgenden Abfrage die Daten werden abgerufen, aber die Food und FoodType

var program = (from p in mEntities.Programs 
       where p.Id ==Id 
       select new { 
       Program = p, 
       ProgramFoodTypes = from pf in p.ProgramFoodTypes 
            where pf.IsActive 
            select pf,     
       ProgramFoods = p.ProgramFoods // here i can't add include statement 
       }).ToArray().Select(m => m.Program); 

, wie man schließen die Lebensmittel und Lebensmitteltyp fehlt in die zweite Abfrage?

Answer 1

können sein:

var program = (from p in mEntities.Programs 
      where p.Id ==Id 
      select new { 
      Program = p, 
      ProgramFoodTypes = from pf in p.ProgramFoodTypes 
           where pf.IsActive 
           select pf,     
      ProgramFoods = p.ProgramFoods.Select(y => new { 
       Food = y.Food, 
       Type = y.FoodType 
      }) 
      }).ToArray().Select(m => m.Program); 

Answer 2

Try this:

var program = mEntities.Programs 
         .Include(p => p.ProgramFoodTypes) 
         .Include(p => p.ProgramFoods.Select(f => f.Food)) 
         .InClude(p => p.ProgramFoods.Select(f => f.FoodType)) 
         .SingleOrDefault(m => m.Id == Id && m.ProgramFoodTypes.All(t => t.IsActive)); 

Answer 3

Für Ihre zweite Lösung, ich denke, Sie verwenden können:

var program = (from p in mEntities.Programs 
         .Include(p => p.ProgramFoods.Select(f => f.Food)) 
         .InClude(p => p.ProgramFoods.Select(f => f.FoodType)) 
      where p.Id ==Id 
      select new { 
      Program = p, 
      ProgramFoodTypes = from pf in p.ProgramFoodTypes 
           where pf.IsActive 
           select pf,     
      ProgramFoods = p.ProgramFoods 
      }).ToArray().Select(m => m.Program); 

Update: Da Sie in Ihrer Linq-Abfrage anonymen Typ verwenden, Include statements are dismissed.
Sie müssten alle zugehörigen ProgramFoodTypes auf Client-Seite laden, und dann die Filterung:

var program = mEntities.Programs 
        .Include(p => p.ProgramFoodTypes) 
        .Include(p => p.ProgramFoods.Select(f => f.Food)) 
        .InClude(p => p.ProgramFoods.Select(f => f.FoodType)) 
        .SingleOrDefault(m => m.Id == Id); 
program.ProgramFoodTypes = program.ProgramFoodTypes.Where(pft => pft.IsActive); 

Sie können AsNoTracking() verwenden oder das zurück Program Objekt in einem neuen Objekt in Fall klonen Sie Ihre Daten sicherstellen möchten, dass auf db-Seite intakt sein wird.