C# Лямбда / методы расширения сглаживают результаты между 4 объектами?

Question

У меня есть Tag сущность в EF6, которая имеет отношение один ко многим с 3 другими сущностями:

              Tag
          /    |      \
Definition   Variant   Machine  

Tag
{
    Id : 1,
    Name : New York,
    Definition
    {
        Id : 1,
        Title: EquipA
    },
    Definition
    {
        Id : 2,
        Title: EquipB
    },
    Variant
    {
        Id : 1,
        Name: EquipA11
    },
    Variant
    {
        Id : 2,
        Name: EquipB11
    },
    Machine
    {
        Id : 1,
        Plant : New York,
        Line : 1A
    }
    Machine
    {
        Id : 2,
        Plant : New York,
        Line : 2B
    }
}

Я хочу вернуть сведенные результаты для всех 4 сущностей, чтобы получить результаты например:

Tag.Id, Tag.Name, Tag.Definition.Id, Tag.Definition.Title, Tag.Variant.Id, Tag.Variant.Name, Tag.Machine.Id, Tag.Machine.Plant, Tag.Machine.Line

1, New York, 1, EquipA, 1, EquipA11, 1, New York, 1A
1, New York, 1, EquipA, 1, EquipA11, 2, New York, 2B
1, New York, 1, EquipA, 2, EquipB11, 1, New York, 1A
1, New York, 1, EquipA, 2, EquipB11, 2, New York, 2B
1, New York, 2, EquipB, 1, EquipA11, 1, New York, 1A
1, New York, 2, EquipB, 1, EquipA11, 2, New York, 2B
1, New York, 2, EquipB, 2, EquipB11, 1, New York, 1A
1, New York, 2, EquipB, 2, EquipB11, 2, New York, 2B  

Я могу это сделать, но могу получить только определения, не зная, как выбрать из всех 4 сущностей:

var temp = db.Tags.Include(c => c.Definition)
              .Include(v => v.Variant)
              .Include(p => p.PaperMachine)
              .SelectMany(t => t.Definition)
              .Select(t => new { t.Id, t.Title } )
              //.SelectMany(c => c.Definition, v => v.Variant,  )
              //.SelectMany(v => v.)
              .ToList();

Answer 1

Звучит так, будто вы хотите произвести декартово для всех связанных сущностей.

Примерно так должно net результаты, которые вы ищете:

var temp = db.Tags
    .SelectMany(t => t.Definitions
        .SelectMany(d => d.Tag.Variants
            .SelectMany(v => v.Tag.PaperMachines
                .Select(p => new 
                {
                   TagId = t.Id, 
                   TagName = t.Name,
                   DefinitionId = d.Id,
                   DefinitionName = d.Name,
                   VariantId = v.Id,
                   VariantName = v.Name,
                   PaperMachineId = p.Id,
                   PaperMachineName = p.Name
                })))).ToList();

Это заполняет анонимный тип с запрошенными данными. Вы можете определить DTO / ViewModel для заполнения и возврата, если для этого нужно go назад к вызывающей стороне / представлению. Это требует двунаправленных навигационных свойств для перехода от тега к каждому дочернему элементу и обратно к тегу. В качестве альтернативы вы можете использовать Join, хотя я подозреваю, что читать будет немного сложнее.

Может быть более краткий способ получить его. Обычно я помогаю людям избегать декартов, а не целенаправленно делать их. :)

Редактировать: Для отношения «многие ко многим» вы можете использовать вышеуказанный запрос без свойства обратной навигации ...

var temp = db.Tags
    .SelectMany(t => t.Definitions
        .SelectMany(d => t.Variants
            .SelectMany(v => t.PaperMachines
                .Select(p => new 
                {
                   TagId = t.Id, 
                   TagName = t.Name,
                   DefinitionId = d.Id,
                   DefinitionName = d.Name,
                   VariantId = v.Id,
                   VariantName = v.Name,
                   PaperMachineId = p.Id,
                   PaperMachineName = p.Name
                })))).ToList();

Это выглядит немного странно, но выглядит сделать трюк. Обратите внимание, что для объединений SelectMany мы присоединяемся к ссылкам t., но это позволяет нам по-прежнему объединять комбинации наших (t) ag, (d) определений, (v) ariant и (p) aperMachine Ссылка в финале Выбрать.

Будьте осторожны, потому что это будет экспоненциально больше и дороже с большим количеством комбинаций, которые вы вводите.