同じフィールドをエンティティのフレームワークに2回含む場合の動作linq

Question

同じフィールドを2回含めると何が起こるのですか？つまり、エンティティをdbから取り、EF .includeオプションを使用します。私は何を意味することはこれです：私が持っている
：

.Include(x => x.Student) 
.Include(x => x.Car) 
.Include(x => x.Student) 

これはモデルです：ので、学生二回（私の人はONLY学生を持っているので）（誤って）を含むことにより、

Person has a Student 
Person has a car 

、問題はありますか？
P.私はそれが一度含まれてほしい！私は1人の学生しかいないからです。 これについてefが文句を言っていますか？私はそれを試してみたが、それは大丈夫だったようだが、私はこのことの意味を知らない。誰も説明することができます/精巧？少しは検索しましたが、問題を特定できませんでした。

Answer 1

は、このサンプルを取る：

public class RentContext : DbContext 
{ 
    public DbSet<Student> Students { get; set; } 

    public DbSet<Rent> Rents { get; set; } 

    public DbSet<Car> Cars { get; set; } 
} 

public class Car 
{ 
    public int Id { get; set; } 

    public string Model { get; set; } 

    public double Price { get; set; } 
} 

public class Rent 
{ 
    public int Id { get; set; } 

    public Student Student { get; set; } 

    public Car Car { get; set; } 
} 

public class Student 
{ 
    public int Id { get; set; } 

    public string Name { get; set; } 

    public int Year { get; set; } 
} 

家賃は学生や車が含まれています。

var rents = ctx.Rents 
    .Include(x => x.Student) 
    .Include(x => x.Car) 
    //.Include(x => x.Student) 
    .ToList(); 

これで生成されたSQL：：

SELECT 
[Extent1].[Id] AS [Id], 
[Extent2].[Id] AS [Id1], 
[Extent2].[Name] AS [Name], 
[Extent2].[Year] AS [Year], 
[Extent3].[Id] AS [Id2], 
[Extent3].[Model] AS [Model], 
[Extent3].[Price] AS [Price] 
FROM [dbo].[Rents] AS [Extent1] 
LEFT OUTER JOIN [dbo].[Students] AS [Extent2] ON [Extent1].[Student_Id] = [Extent2].[Id] 
LEFT OUTER JOIN [dbo].[Cars] AS [Extent3] ON [Extent1].[Car_Id] = [Extent3].[Id] 

のは、複製クエリがインクルードしてみましょう：

var rents = ctx.Rents 
    .Include(x => x.Student) 
    .Include(x => x.Car) 
    .Include(x => x.Student) 
    .ToList(); 

あなた」

はユニークな句を含めると、クエリを作ることができますこのSQLを取得します：

SELECT 
[Extent1].[Id] AS [Id], 
[Extent2].[Id] AS [Id1], 
[Extent2].[Name] AS [Name], 
[Extent2].[Year] AS [Year], 
[Extent3].[Id] AS [Id2], 
[Extent3].[Model] AS [Model], 
[Extent3].[Price] AS [Price] 
FROM [dbo].[Rents] AS [Extent1] 
LEFT OUTER JOIN [dbo].[Students] AS [Extent2] ON [Extent1].[Student_Id] = [Extent2].[Id] 
LEFT OUTER JOIN [dbo].[Cars] AS [Extent3] ON [Extent1].[Car_Id] = [Extent3].[Id] 

EFは、インクルードを複数回指定しても同じSQLを生成できるほどスマートです。

UPDATE：繰り返し（何度も）が含ま

のは、これを試してみましょう：繰り返し

var rents = ctx.Rents 
    .Include(x => x.Student) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Car) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .Include(x => x.Student) 
    .ToList(); 

が含まれ、いくつかの回。そして、生成されたSQLは次のとおりです。

SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent2].[Id] AS [Id1], 
    [Extent2].[Name] AS [Name], 
    [Extent2].[Year] AS [Year], 
    [Extent3].[Id] AS [Id2], 
    [Extent3].[Model] AS [Model], 
    [Extent3].[Price] AS [Price] 
    FROM [dbo].[Rents] AS [Extent1] 
    LEFT OUTER JOIN [dbo].[Students] AS [Extent2] ON [Extent1].[Student_Id] = [Extent2].[Id] 
    LEFT OUTER JOIN [dbo].[Cars] AS [Extent3] ON [Extent1].[Car_Id] = [Extent3].[Id] 

もう一度同じコードを再度入力します。あ、はい。ちょっと変わったことはありますが、それは大丈夫でしょう。

希望すると便利です。

Answer 2

これを2回呼び出すと、同じクエリが生成されます。同じ結果、このような何か

SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent1].[Title] AS [Title], 
    [Extent1].[PersonId] AS [PersonId], 
    [Extent2].[Id] AS [Id1], 
    [Extent2].[Name] AS [Name] 
    FROM [dbo].[Books] AS [Extent1] 
    INNER JOIN [dbo].[People] AS [Extent2] ON [Extent1].[PersonId] = [Extent2].[Id] 

Answer 3

これは完全に有効で、とにかくEFを上回らないでしょう。 Studentのような参照を取り除く追加の参照とコレクションをどのように含めるかを検討してください。このように書くかもしれません。あなたが提案したことは、以下の例よりもEFを混乱させることはありません。

.Include(x => x.Student.Teacher) 
.Include(x => x.Car) 
.Include(x => x.Student.DrivingLog)