Entity Framework
Gerelateerde entiteiten laden

Opmerkingen

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; }
}

Trage voortgang

Lui laden is standaard ingeschakeld. Lazy laden wordt bereikt door afgeleide proxy-klassen te maken en virtuele navigatie-eigenschappen te negeren. Lui laden vindt plaats wanneer voor het eerst toegang wordt verkregen.

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.        
}

Om het Lazy laden uit te schakelen voor specifieke navigatie-eigenschappen, verwijdert u gewoon het virtuele trefwoord uit de eigenschapsverklaring:

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

Als u Lazy-laden volledig wilt uitschakelen, moet u de configuratie wijzigen, bijvoorbeeld bij Context constructor :

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

Opmerking: vergeet niet om Lazy laden uit te schakelen als u serialisatie gebruikt. Omdat serializers toegang hebben tot elke eigenschap die u allemaal gaat laden vanuit de database. Bovendien kunt u lus tussen navigatie-eigenschappen.

Enthousiast laden

Met enthousiast laden kunt u al uw benodigde entiteiten tegelijk laden. Als u er de voorkeur aan geeft al uw entiteiten in één databaseoproep aan het werk te krijgen, dan is het laden van de manier de juiste keuze. Hiermee kunt u ook meerdere niveaus laden.

U hebt twee opties om gerelateerde entiteiten te laden, u kunt kiezen uit sterk getypte of tekenreeksoverbelasting van de methode Opnemen .

Sterk getypt.

// 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();

Deze methode is beschikbaar sinds Entity Framework 4.1. Zorg ervoor dat u de referentie using System.Data.Entity; set.

String overbelasting.

// 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();

Expliciet laden

Na het draaien van Lazy laden off kunt u lui laden entiteiten door expliciet te roepen methode Load voor inzendingen. Referentie wordt gebruikt om afzonderlijke navigatie-eigenschappen te laden, terwijl Verzameling wordt gebruikt om verzamelingen op te halen.

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();

Omdat het bezig is met Eager laden , kunt u overbelastingen van bovenstaande methoden gebruiken om entiteis met hun namen te laden:

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

Filter gerelateerde entiteiten.

Met behulp van de Query- methode kunnen we geladen gerelateerde entiteiten filteren:

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();

Projectie Query's

Als men gerelateerde gegevens in een gedenormaliseerd type nodig heeft, of bijvoorbeeld alleen een subset van kolommen, kan men projectiequery's gebruiken. Als er geen reden is om een extra type te gebruiken, bestaat de mogelijkheid om de waarden samen te voegen tot een anoniem type .

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
                       };

Of met query-syntaxis:

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);