Entity Framework
Laddar relaterade enheter

Anmärkningar

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

Lat lastning

Lat laddning är aktiverad som standard. Lat laddning uppnås genom att skapa härledda proxyklasser och åsidosätta virtuella navigationsegenskaper. Lat laddning inträffar när tillgång till egendom för första gången.

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

För att stänga av Lazy-laddning för specifika navigationsegenskaper tar du bara bort virtuella nyckelord från fastighetsdeklarationen:

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

Om du vill stänga av Lazy lastning helt måste du ändra konfiguration, till exempel på Context constructor :

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

Obs: Kom ihåg att stänga av Lazy-laddning om du använder serialisering. Eftersom serienummer får åtkomst till varje egendom du kommer att ladda alla dem från databasen. Dessutom kan du stöta på loop mellan navigationsegenskaper.

Ivrig lastning

Ivrig lastning låter dig ladda alla nödvändiga enheter på en gång. Om du föredrar att få alla dina enheter att arbeta med i ett databassamtal, är Eager-laddningen vägen att gå. Det låter dig också ladda flera nivåer.

Du har två alternativ för att ladda närstående enheter, kan du välja antingen starkt skrivit eller sträng överbelastning av Inkludera metoden.

Starkt typad.

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

Den här metoden är tillgänglig eftersom Entity Framework 4.1. Se till att du har referensen using System.Data.Entity; uppsättning.

Strängöverbelastning.

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

Explicit lastning

När du har stängt av Lazy-laddningen kan du ladda enheter lätt genom att uttryckligen anropa Load- metoden för poster. Hänvisning används för att ladda enstaka navigationsegenskaper, medan Collection används för att hämta samlingar.

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

Eftersom det är på Eager-lastning kan du använda överbelastningar av ovanstående metoder för att ladda entiteis med deras namn:

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

Filtrera relaterade enheter.

Med hjälp av Query- metoden kan vi filtrera laddade relaterade enheter:

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

Projektionsfrågor

Om man behöver relaterade data i en denormaliserad typ, eller t.ex. bara en delmängd av kolumner, kan man använda projektionsfrågor. Om det inte finns någon anledning att använda en extra typ finns det möjligheten att koppla värdena till en anonym typ .

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

Eller med frågesyntax:

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