Entity Framework
संबंधित संस्थाओं को लोड कर रहा है

टिप्पणियों

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

धीरे लोड हो रहा है

आलसी लोडिंग डिफ़ॉल्ट रूप से सक्षम है। आलसी लोडिंग को प्रॉक्सी प्रॉक्सी क्लासेस बनाकर और वर्चुअल नेविगेशन प्रॉपर को ओवरराइड करके हासिल किया जाता है। पहली बार प्रॉपर्टी एक्सेस करने पर आलसी लोडिंग होती है।

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

विशिष्ट नेविगेशन गुणों के लिए आलसी लोडिंग को बंद करने के लिए, संपत्ति की घोषणा से आभासी कीवर्ड को हटा दें:

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

यदि आप पूरी तरह से आलसी लोडिंग को बंद करना चाहते हैं, तो आपको कॉन्फ़िगरेशन बदलना होगा, उदाहरण के लिए, कॉनटेक्स्ट कंस्ट्रक्टर पर :

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

नोट: कृपया याद रखें कि यदि आप क्रमांकन का उपयोग कर रहे हैं तो आलसी लोडिंग को बंद कर दें । क्योंकि सीरियलाइज़र उन सभी प्रॉपर्टी को एक्सेस करते हैं, जिन्हें आप डेटाबेस से लोड करने जा रहे हैं। इसके अतिरिक्त, आप नेविगेशन गुणों के बीच लूप में चल सकते हैं।

उत्सुक लोड हो रहा है

उत्सुक लोडिंग आपको एक बार में अपने सभी आवश्यक संस्थाओं को लोड करने देता है। यदि आप एक डेटाबेस कॉल में काम करने के लिए अपनी सभी संस्थाओं को प्राप्त करना पसंद करते हैं, तो ईगर लोडिंग जाने का रास्ता है। यह आपको कई स्तरों को लोड करने की सुविधा भी देता है।

संबंधित संस्थाओं को लोड करने के लिए आपके पास दो विकल्प हैं , आप या तो जोरदार टाइपिंग चुन सकते हैं या शामिल विधि के स्ट्रिंग ओवरलोड कर सकते हैं।

जोर से टाइप किया हुआ।

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

यह तरीका एंटिटी फ्रेमवर्क 4.1 के बाद से उपलब्ध है। सुनिश्चित करें कि आपके पास using System.Data.Entity; संदर्भ है using System.Data.Entity; सेट।

स्ट्रिंग अधिभार।

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

लोडिंग स्पष्ट करें

आलसी लोडिंग को बंद करने के बाद आप प्रविष्टियों के लिए लोड विधि को स्पष्ट रूप से कॉल करके संस्थाओं को लोड कर सकते हैं। संदर्भ का उपयोग एकल नेविगेशन गुणों को लोड करने के लिए किया जाता है, जबकि संग्रह का उपयोग संग्रह प्राप्त करने के लिए किया जाता है।

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

जैसा कि यह ईगर लोडिंग पर है, आप उपरोक्त विधियों के ओवरलोड को उनके नाम से एंटाइटिस लोड करने के लिए उपयोग कर सकते हैं:

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

संबंधित संस्थाओं को फ़िल्टर करें।

क्वेरी पद्धति का उपयोग करके हम लोड से संबंधित संस्थाओं को फ़िल्टर कर सकते हैं:

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

प्रोजेक्शन क्वेरी

यदि किसी को संबंधित प्रकार में संबंधित डेटा की आवश्यकता होती है, या उदाहरण के लिए केवल कॉलम का एक सबसेट, प्रक्षेपण प्रश्नों का उपयोग कर सकता है। यदि अतिरिक्त प्रकार का उपयोग करने का कोई कारण नहीं है, तो मूल्यों को एक गुमनाम प्रकार में शामिल होने की संभावना है।

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

या क्वेरी-सिंटैक्स के साथ:

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