Entity Framework
Verwandte Entitäten laden

Bemerkungen

public class Company
{
    public int Id { get; set; }
    public string FullName { get; set; }
    public string ShortName { get; set; }

    // Navigation properties
    public virtual Person Founder { get; set; }
    public virtual ICollection<Address> Addresses { get; set; }
}

public class Address 
{        
    public int Id { get; set; }
    public int CompanyId { get; set; }
    public int CountryId { get; set; }
    public int CityId { get; set; }
    public string Street { get; set; }

    // Navigation properties
    public virtual Company Company { get; set; }
    public virtual Country Country { get; set; }
    public virtual City City { get; set; }
}

Faules Laden

Lazy Loading ist standardmäßig aktiviert. Lazy Loading wird durch das Erstellen abgeleiteter Proxy-Klassen und das Überschreiben von virtuellen Navigationsrechten erreicht. Beim erstmaligen Zugriff auf die Eigenschaft wird faul geladen.

int companyId = ...;
Company company = context.Companies
    .First(m => m.Id == companyId);
Person founder = company.Founder; // Founder is loaded
foreach (Address address in company.Addresses)
{
    // Address details are loaded one by one.        
}

Um das Lazy-Laden für bestimmte Navigationseigenschaften zu deaktivieren, entfernen Sie einfach das virtuelle Schlüsselwort aus der Deklaration der Eigenschaften:

public Person Founder { get; set; } // "virtual" keyword has been removed

Wenn Sie das Lazy-Laden vollständig deaktivieren möchten, müssen Sie die Konfiguration beispielsweise im Kontext-Konstruktor ändern:

public class MyContext : DbContext        
{
    public MyContext(): base("Name=ConnectionString")
    {
        this.Configuration.LazyLoadingEnabled = false;
    }
}

Hinweis: Denken Sie daran, Lazy Loading auszuschalten, wenn Sie die Serialisierung verwenden. Da die Serialisierer auf jede Eigenschaft zugreifen, laden Sie sie alle aus der Datenbank. Darüber hinaus können Sie eine Schleife zwischen den Navigationseigenschaften ausführen.

Eifriges Laden

Durch das eifrige Laden können Sie alle benötigten Objekte gleichzeitig laden. Wenn Sie es vorziehen, alle Ihre Entitäten mit einem einzigen Datenbankaufruf zu bearbeiten, ist das Laden mit Eager der richtige Weg. Sie können auch mehrere Ebenen laden.

Sie haben zwei Möglichkeiten , verwandte Entitäten zu laden. Sie können entweder die stark typisierte oder die Überladung der Zeichenfolge der Include- Methode wählen.

Stark getippt

// Load one company with founder and address details
int companyId = ...;
Company company = context.Companies
    .Include(m => m.Founder)
    .Include(m => m.Addresses)
    .SingleOrDefault(m => m.Id == companyId);

// Load 5 companies with address details, also retrieve country and city
// information of addresses
List<Company> companies = context.Companies
    .Include(m => m.Addresses.Select(a => a.Country));
    .Include(m => m.Addresses.Select(a => a.City))
    .Take(5).ToList();

Diese Methode ist seit Entity Framework 4.1 verfügbar. Stellen Sie sicher, dass Sie über die Referenz verfügen, die using System.Data.Entity; einstellen.

String überladen.

// Load one company with founder and address details
int companyId = ...;
Company company = context.Companies
    .Include("Founder")
    .Include("Addresses")
    .SingleOrDefault(m => m.Id == companyId);

// Load 5 companies with address details, also retrieve country and city
// information of addresses
List<Company> companies = context.Companies
    .Include("Addresses.Country");
    .Include("Addresses.City"))
    .Take(5).ToList();

Explizites Laden

Nach dem Deaktivieren des Lazy-Ladens können Sie Entities faul laden, indem Sie die Load- Methode für Einträge explizit aufrufen. Referenz wird zum Laden einzelner Navigationseigenschaften verwendet, während Collection zum Abrufen von Sammlungen verwendet wird.

Company company = context.Companies.FirstOrDefault();
// Load founder
context.Entry(company).Reference(m => m.Founder).Load();
// Load addresses
context.Entry(company).Collection(m => m.Addresses).Load();

Wie beim Eager Loading können Sie Überladungen der obigen Methoden verwenden, um Berechtigungen nach ihren Namen zu laden:

Company company = context.Companies.FirstOrDefault();
// Load founder
context.Entry(company).Reference("Founder").Load();
// Load addresses
context.Entry(company).Collection("Addresses").Load();

Verwandte Entitäten filtern

Mit der Query- Methode können wir geladene Entitäten filtern:

Company company = context.Companies.FirstOrDefault();
// Load addresses which are in Baku
context.Entry(company)
    .Collection(m => m.Addresses)
    .Query()
    .Where(a => a.City.Name == "Baku")
    .Load();

Projektionsabfragen

Benötigt man verwandte Daten in einem denormalisierten Typ oder zB nur eine Teilmenge von Spalten, kann man Projektionsabfragen verwenden. Wenn es keinen Grund gibt, einen zusätzlichen Typ zu verwenden, besteht die Möglichkeit, die Werte mit einem anonymen Typ zu verknüpfen .

var dbContext = new MyDbContext();
var denormalizedType = from company in dbContext.Company
                       where company.Name == "MyFavoriteCompany"
                       join founder in dbContext.Founder
                       on company.FounderId equals founder.Id
                       select new 
                       {
                           CompanyName = company.Name,
                           CompanyId = company.Id,
                           FounderName = founder.Name,
                           FounderId = founder.Id
                       };

Oder mit der Abfragesyntax:

var dbContext = new MyDbContext();
var denormalizedType = dbContext.Company
                       .Join(dbContext.Founder, 
                                    c => c.FounderId,
                                    f => f.Id ,
                                    (c, f) => new 
                                    {
                                        CompanyName = c.Name,
                                        CompanyId = c.Id,
                                        FounderName = f.Name,
                                        FounderId = f.Id
                                    })
                       .Select(cf => cf);