Ленивая загрузка против нетерпеливой загрузки

Ленивая загрузка в Entity Framework - явление по умолчанию, которое происходит при загрузке связанных сущностей и доступе к ним. Однако жадная загрузка относится к практике принудительной загрузки всех этих отношений. Я столкнулся с вопросом, в какой ситуации ускоренная загрузка может быть более выгодной, чем ленивая загрузка. Спрашиваем об этом, потому что очевидно, что ленивая загрузка более дружественна к ресурсам, и даже если мы воспользуемся этим ToList()методом, мы все равно сможем воспользоваться преимуществами ленивой загрузки. Однако я подумал, что, возможно, ленивая загрузка увеличивает количество запросов к реальной базе данных, и, возможно, поэтому иногда разработчики используютInlcudeметод принудительной загрузки всех отношений. Например, при использовании автоматического создания шаблонов Visual Studio в MVC 5 метод Index, который автоматически создается в контроллере, всегда использует нетерпеливую загрузку, и у меня всегда возникал вопрос, почему в этом случае Microsoft использует нетерпеливую загрузку по умолчанию.

Я был бы признателен, если бы кто-нибудь объяснил мне, в какой ситуации жадная загрузка будет более выгодной, чем ленивая загрузка, и почему мы вообще ее используем, когда есть что-то более дружественное к ресурсам, как ленивая загрузка.

Я считаю, что такие отношения можно категоризировать

Когда использовать активную загрузку

1. На «одной стороне» отношений «один ко многим», которые, как вы уверены, используются повсюду с основным объектом. как пользовательское свойство статьи. Свойство категории продукта.
2. Обычно, когда отношений не слишком много, и активная загрузка будет хорошей практикой, чтобы уменьшить количество запросов на сервер.

Когда использовать отложенную загрузку

1. Практически со всех сторон "коллекции" отношений "один ко многим". например статьи пользователя или продукты категории
2. Вы точно знаете, что недвижимость вам не понадобится сразу.

Примечание: как сказал Transcendent, при ленивой загрузке может возникнуть проблема с удалением.

Жажда загрузки: Жажда загрузки поможет вам загрузить все необходимые объекты сразу. т.е. связанные объекты (дочерние объекты) загружаются автоматически вместе с родительским объектом.

Когда использовать:

1. Используйте нетерпеливую загрузку, когда отношений не слишком много. Таким образом, нетерпеливая загрузка - это хороший способ уменьшить количество запросов к серверу.
2. Используйте нетерпеливую загрузку, если вы уверены, что будете везде использовать связанные сущности с основной сущностью.

Ленивая загрузка: в случае отложенной загрузки связанные объекты (дочерние объекты) не загружаются автоматически вместе с родительским объектом, пока они не будут запрошены. По умолчанию LINQ поддерживает отложенную загрузку.

Когда использовать:

1. Используйте отложенную загрузку при использовании коллекций "один ко многим".
2. Используйте отложенную загрузку, если вы уверены, что не используете связанные объекты мгновенно.

ПРИМЕЧАНИЕ. Entity Framework поддерживает три способа загрузки связанных данных - активная загрузка, отложенная загрузка и явная загрузка.

Ленивая загрузка приведет к нескольким вызовам SQL, в то время как при нетерпеливой загрузке данные могут быть загружены одним «более тяжелым» вызовом (с соединениями / подзапросами).

Например, если между вашим веб-сервером и сервером sql наблюдается высокий пинг, вы должны использовать «Нетерпеливую» загрузку вместо загрузки связанных элементов по одному с отложенной загрузкой.

Рассмотрим ситуацию ниже

public class Person{
    public String Name{get; set;}
    public String Email {get; set;}
    public virtual Employer employer {get; set;}
}

public List<EF.Person> GetPerson(){
    using(EF.DbEntities db = new EF.DbEntities()){
       return db.Person.ToList();
    }
}

Теперь после вызова этого метода вы больше не можете лениво загружать Employerобъект. Почему? потому что dbобъект утилизирован. Так что вам нужно сделать, Person.Include(x=> x.employer)чтобы это было загружено.

Активная загрузка Если вы уверены, что хотите получить одновременно несколько объектов, например, вы должны показать пользователя и его данные на одной странице, тогда вам следует перейти к активной загрузке. При активной загрузке выполняется одноразовое обращение к базе данных и загрузка связанных сущностей.

Ленивая загрузка Когда вам нужно отображать пользователей только на странице, и, щелкая по пользователям, вам нужно отобразить данные пользователя, вам нужно перейти к отложенной загрузке. Ленивая загрузка делает несколько обращений, чтобы загрузить связанные объекты при связывании / итерации связанных объектов.

Ленивая загрузка - хороша при обработке с разбивкой на страницы, например, когда на странице появляется список пользователей, который содержит 10 пользователей, и когда пользователь прокручивает страницу вниз, вызов API приводит к следующим 10 пользователям. Это хорошо, когда вы не хотите загружать данные enitire в один раз, так как это займет больше времени и ухудшит пользовательский опыт.

Неторопливая загрузка - это хорошо, как предлагали другие люди, когда нет много связей и сразу извлекает все данные за один вызов базы данных

По возможности лучше использовать активную загрузку, поскольку это оптимизирует производительность вашего приложения.

ex-:

Eager loading

var customers= _context.customers.Include(c=> c.membershipType).Tolist();

lazy loading

В модели заказчик должен определить

Public virtual string membershipType {get; set;}

Таким образом, при запросе ленивая загрузка намного медленнее загружает все ссылочные объекты, но при этом выполняется запрос на загрузку и выбирает только релевантный объект.

// Using LINQ and just referencing p.Employer will lazy load
// I am not at a computer but I know I have lazy loaded in one
// query with a single query call like below.
List<Person> persons = new List<Person>();
using(MyDbContext dbContext = new MyDbContext())
{
    persons = (
        from p in dbcontext.Persons
        select new Person{
            Name = p.Name,
            Email = p.Email,
            Employer = p.Employer
        }).ToList();
}