İlgili Verilerin Hevesle Yüklenmesi

Etraflı yükleme

sorgu sonuçlarına Include eklenecek ilgili verileri belirtmek için yöntemini kullanabilirsiniz. Aşağıdaki örnekte, sonuçlarda Posts döndürülen blogların özellikleri ilgili gönderilerle doldurulur.

using (var context = new BloggingContext())
{
    var blogs = context.Blogs
        .Include(blog => blog.Posts)
        .ToList();
}

Bahşiş

Entity Framework Core, daha önce bağlam örneğine yüklenmiş olan diğer varlıklara gezinti özelliklerini otomatik olarak düzeltir. Bu nedenle, bir gezinti özelliğinin verilerini açıkça dahil etmeseniz bile, ilgili varlıkların bir kısmı veya tümü daha önce yüklenmişse özellik yine de doldurulabilir.

Birden çok ilişkideki ilgili verileri tek bir sorguya ekleyebilirsiniz.

using (var context = new BloggingContext())
{
    var blogs = context.Blogs
        .Include(blog => blog.Posts)
        .Include(blog => blog.Owner)
        .ToList();
}

Dikkat

Tek bir sorguda koleksiyon gezintisi yüklemek, performans sorunlarına neden olabilir. Daha fazla bilgi için bkz . Tek ve bölünmüş sorgular.

Birden çok düzey dahil

yöntemini kullanarak birden çok ilişkili veri düzeyi eklemek için ilişkilerde detaya ThenInclude gidebilirsiniz. Aşağıdaki örnek tüm blogları, ilgili gönderilerini ve her gönderinin yazarını yükler.

using (var context = new BloggingContext())
{
    var blogs = context.Blogs
        .Include(blog => blog.Posts)
        .ThenInclude(post => post.Author)
        .ToList();
}

daha fazla ilgili veri düzeyi dahil olmak üzere devam etmek için ThenInclude birden çok çağrıyı zincirleyebilirsiniz.

using (var context = new BloggingContext())
{
    var blogs = context.Blogs
        .Include(blog => blog.Posts)
        .ThenInclude(post => post.Author)
        .ThenInclude(author => author.Photo)
        .ToList();
}

Birden çok düzeyden ve birden çok kökten gelen ilgili verileri aynı sorguya eklemek için tüm çağrıları birleştirebilirsiniz.

using (var context = new BloggingContext())
{
    var blogs = context.Blogs
        .Include(blog => blog.Posts)
        .ThenInclude(post => post.Author)
        .ThenInclude(author => author.Photo)
        .Include(blog => blog.Owner)
        .ThenInclude(owner => owner.Photo)
        .ToList();
}

Dahil edilen varlıklardan biri için birden çok ilgili varlık eklemek isteyebilirsiniz. Örneğin, sorgularken Blogshem ve TagsPostshem de Author öğesini dahil Posts etmek istersiniz. Her ikisini de eklemek için kökte başlayan her ekleme yolunu belirtmeniz gerekir. Örneğin Blog -> Posts -> Author ve Blog -> Posts -> Tags. Bu, yedekli birleşimler elde ettiğiniz anlamına gelmez; çoğu durumda EF, SQL oluştururken birleştirmeleri birleştirir.

using (var context = new BloggingContext())
{
    var blogs = context.Blogs
        .Include(blog => blog.Posts)
        .ThenInclude(post => post.Author)
        .Include(blog => blog.Posts)
        .ThenInclude(post => post.Tags)
        .ToList();
}

Bahşiş

Tek bir Include yöntem kullanarak birden çok gezintiyi de yükleyebilirsiniz. Bu, tüm başvurular olan veya tek bir koleksiyonla biten gezinti "zincirleri" için mümkündür.

using (var context = new BloggingContext())
{
    var blogs = context.Blogs
        .Include(blog => blog.Owner.AuthoredPosts)
        .ThenInclude(post => post.Blog.Owner.Photo)
        .ToList();
}

Filtrelenmiş ekleme

İlgili verileri yüklemek için Dahil Et'i uygularken, eklenen koleksiyon gezintisine belirli numaralandırılabilir işlemler ekleyebilirsiniz. Bu işlem sonuçları filtrelemeye ve sıralamaya olanak tanır.

Desteklenen işlemler şunlardır: Where, OrderBy, OrderByDescending, ThenBy, ThenByDescending, , Skipve Take.

Bu tür işlemler, aşağıda gösterildiği gibi Include yöntemine geçirilen lambda koleksiyon gezintisine uygulanmalıdır:

using (var context = new BloggingContext())
{
    var filteredBlogs = context.Blogs
        .Include(
            blog => blog.Posts
                .Where(post => post.BlogId == 1)
                .OrderByDescending(post => post.Title)
                .Take(5))
        .ToList();
}

Eklenen her gezinti yalnızca bir benzersiz filtre işlemi kümesine izin verir. Belirli bir koleksiyon gezintisi için birden çok Include işleminin uygulandığı durumlarda (blog.Posts aşağıdaki örneklerde), filtre işlemleri yalnızca bunlardan birinde belirtilebilir:

using (var context = new BloggingContext())
{
    var filteredBlogs = context.Blogs
        .Include(blog => blog.Posts.Where(post => post.BlogId == 1))
        .ThenInclude(post => post.Author)
        .Include(blog => blog.Posts)
        .ThenInclude(post => post.Tags.OrderBy(postTag => postTag.TagId).Skip(3))
        .ToList();
}

Bunun yerine, birden çok kez dahil edilen her gezinti için aynı işlemler uygulanabilir:

using (var context = new BloggingContext())
{
    var filteredBlogs = context.Blogs
        .Include(blog => blog.Posts.Where(post => post.BlogId == 1))
        .ThenInclude(post => post.Author)
        .Include(blog => blog.Posts.Where(post => post.BlogId == 1))
        .ThenInclude(post => post.Tags.OrderBy(postTag => postTag.TagId).Skip(3))
        .ToList();
}

Dikkat

Sorguları izleme durumunda, gezinti düzeltmesi nedeniyle Filtrelenmiş Dahil Et'in sonuçları beklenmeyen olabilir. Daha önce sorgulanmış ve Değişiklik İzleyicisi'nde depolanmış olan tüm ilgili varlıklar, filtrenin gereksinimlerini karşılamasalar bile Filtrelenmiş Dahil Et sorgusunun sonuçlarında bulunur. Bu durumlarda Filtrelenmiş Ekle'yi kullanırken sorguları kullanmayı NoTracking veya DbContext'i yeniden oluşturmayı göz önünde bulundurun.

Örnek:

var orders = context.Orders.Where(o => o.Id > 1000).ToList();

// customer entities will have references to all orders where Id > 1000, rather than > 5000
var filtered = context.Customers.Include(c => c.Orders.Where(o => o.Id > 5000)).ToList();

Dekont

Sorguları izleme durumunda, filtrelenmiş eklemenin uygulandığı gezintinin yüklendiği kabul edilir. Bu, bazı öğeler eksik olsa bile EF Core'un açık yükleme veya gecikmeli yükleme kullanarak değerlerini yeniden yüklemeye çalışmayacağı anlamına gelir.

Türetilmiş türlere ekle

ve kullanarak IncludeThenIncludeyalnızca türetilmiş bir türe tanımlanan gezintiden ilgili verileri ekleyebilirsiniz.

Aşağıdaki model göz önünde bulundurulduğunda:

public class SchoolContext : DbContext
{
    public DbSet<Person> People { get; set; }
    public DbSet<School> Schools { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<School>().HasMany(s => s.Students).WithOne(s => s.School);
    }
}

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Student : Person
{
    public School School { get; set; }
}

public class School
{
    public int Id { get; set; }
    public string Name { get; set; }

    public List<Student> Students { get; set; }
}

School Öğrenciler olan tüm Kişiler gezinti içeriği birçok desen kullanılarak hevesle yüklenebilir:

• Atamayı kullanma

  context.People.Include(person => ((Student)person).School).ToList()
  

• İşleci kullanma as

  context.People.Include(person => (person as Student).School).ToList()
  

• Bunun aşırı yüklenmesi, Include tür parametresini alır string

  context.People.Include("School").ToList()
  

Otomatik ekleme gezintileri için model yapılandırması

Yöntem kullanarak AutoInclude varlık veritabanından her yüklendiğinde dahil edilecek modelde bir gezinti yapılandırabilirsiniz. Sonuçlarda varlık türünün döndürüldüğü her sorguda gezinti ile belirtmeyle Include aynı etkiye sahiptir. Aşağıdaki örnekte bir gezintinin otomatik olarak dahil edilecek şekilde nasıl yapılandırılacağı gösterilmektedir.

modelBuilder.Entity<Theme>().Navigation(e => e.ColorScheme).AutoInclude();

Yukarıdaki yapılandırmadan sonra aşağıdaki gibi bir sorgu çalıştırıldıktan sonra sonuçlardaki tüm temalar için gezinti yüklenir ColorScheme .

using (var context = new BloggingContext())
{
    var themes = context.Themes.ToList();
}

Bu yapılandırma, sonuçlarda nasıl görünürse görünsün sonuçta döndürülen her varlığa uygulanır. Başka bir deyişle, bir varlık gezinti kullanımı nedeniyle, başka bir varlık türü veya otomatik ekleme yapılandırması kullanılarak Include elde edilirse, bu varlık için otomatik olarak eklenen tüm gezintileri yükler. Aynı kural, varlığın türetilmiş türüne otomatik olarak eklenmiş olarak yapılandırılan gezintilere de genişletilir.

Belirli bir sorgu için, model düzeyinde otomatik olarak dahil edilecek şekilde yapılandırılmış bir gezinti aracılığıyla ilgili verileri yüklemek istemiyorsanız, sorgunuzda yöntemini kullanabilirsiniz IgnoreAutoIncludes . Bu yöntemin kullanılması, kullanıcı tarafından otomatik ekleme olarak yapılandırılan tüm gezintilerin yüklenmesini durdurur. Aşağıdaki gibi bir sorgu çalıştırıldığında veritabanındaki tüm temalar geri alınır, ancak otomatik olarak eklenen gezinti olarak yapılandırılmış olsa bile yüklenmez ColorScheme .

using (var context = new BloggingContext())
{
    var themes = context.Themes.IgnoreAutoIncludes().ToList();
}

Dekont

Sahip olunan türlere yönelik gezintiler de kural tarafından otomatik olarak dahil edilmiş olarak yapılandırılır ve API'nin kullanılması IgnoreAutoIncludes bunların dahil edilmelerini engellemez. Bunlar sorgu sonuçlarına dahil edilmeye devam eder.