Entity Framework
Cargando entidades relacionadas

Observaciones

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

Carga lenta

La carga diferida está habilitada por defecto. La carga diferida se logra creando clases de proxy derivadas y anulando proeprties de navegación virtual. La carga perezosa se produce cuando se accede a la propiedad por primera vez.

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

Para desactivar la carga diferida para propiedades de navegación específicas, simplemente elimine la palabra clave virtual de la declaración de propiedad:

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

Si desea desactivar completamente la carga diferida, debe cambiar la configuración, por ejemplo, en el constructor de contexto :

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

Nota: recuerde desactivar la carga diferida si está utilizando la serialización. Debido a que los serializadores acceden a todas las propiedades, los cargará desde la base de datos. Además, puede ejecutarse en bucle entre las propiedades de navegación.

Carga impaciente

La carga impaciente le permite cargar todas las entidades necesarias a la vez. Si prefiere que todas sus entidades trabajen en una llamada a la base de datos, entonces el proceso de carga impaciente es el camino a seguir. También te permite cargar múltiples niveles.

Tiene dos opciones para cargar entidades relacionadas, puede elegir sobrecargas de tipo fuertemente tipadas o de cadena del método Include .

Fuertemente mecanografiado

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

Este método está disponible desde Entity Framework 4.1. Asegúrese de tener la referencia using System.Data.Entity; conjunto.

Sobrecarga de cuerdas.

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

Carga explícita

Después de girar perezoso carga fuera puede cargar con pereza entidades llamando explícitamente al método de carga para las entradas. La referencia se usa para cargar propiedades de navegación individuales, mientras que la colección se usa para obtener colecciones.

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

Como está en la carga Eager , puede utilizar sobrecargas de los métodos anteriores para cargar entiteis por sus nombres:

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

Filtrar entidades relacionadas.

Usando el método de consulta podemos filtrar las entidades relacionadas cargadas:

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

Consultas de proyeccion

Si se necesitan datos relacionados en un tipo desnormalizado, o, por ejemplo, solo un subconjunto de columnas, se pueden usar consultas de proyección. Si no hay razón para usar un tipo extra, existe la posibilidad de unir los valores en un tipo anónimo .

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

O con sintaxis de consulta:

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