Что такое ленивая инициализация и почему она полезна?

Что такое ленивая инициализация объектов? Как вы это делаете и каковы преимущества?

Ответ 1

Lazy Initialization - это оптимизация производительности, когда вы откладываете (потенциально дорогостоящее) создание объекта до того, как он вам действительно понадобится.

Хорошим примером является не создание соединения с базой данных спереди, а только перед тем, как вам нужно получить данные из базы данных.

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

Ответ 2

Как уже упоминалось, отложенная инициализация задерживает инициализацию до тех пор, пока не будет использован компонент или объект. Вы можете просмотреть отложенную инициализацию как приложение времени выполнения принципа YAGNI - "You ain't gonna need it"

Преимущества отложенной инициализации с точки зрения приложения состоят в том, что пользователям не нужно платить время инициализации за функции, которые они не будут использовать. Предположим, вы должны были инициализировать каждый компонент вашего приложения заранее. Это может создать потенциально долгое время запуска - пользователям придется ждать десятки секунд или минут, прежде чем ваше приложение будет готово к использованию. Они ждут и платят за инициализацию функций, которые они могут никогда не использовать или не использовать сразу.

Вместо этого, если вы отложите инициализацию этих компонентов до времени использования, ваше приложение запустится гораздо быстрее. Пользователю по-прежнему придется оплачивать стоимость запуска при использовании других компонентов, но эта стоимость будет амортизироваться при запуске программы, а не сокращаться в начале, и пользователь может связывать время инициализации этих объектов с функциями, которыми они являются. с помощью.

Ответ 3

Lazy Initialization - это концепция отложенного создания объекта, пока объект не будет использован вначале. При правильном использовании это может привести к значительному повышению производительности.

Лично я использовал Lazy Initialization при создании собственной обработанной вручную ORM в .NET 2.0. При загрузке моих коллекций из базы данных фактические элементы коллекции были инициализированы ленивыми. Это означало, что коллекции были созданы быстро, но каждый объект загружался только тогда, когда я этого требовал.

Если вы знакомы с шаблоном Singleton, вы, вероятно, видели и ленивую инициализацию в действии.

public class SomeClassSingleton
{
    private static SomeClass _instance = null;

    private SomeClassSingleton()
    {
    }

    public static SomeClass GetInstance()
    {
        if(_instance == null)
            _instance = new SomeClassSingleton();

        return _instance;
    }
}

В этом случае экземпляр SomeClass не инициализируется, пока он не понадобится первому потребителю SomeClassSingleton.

Ответ 4

В общих вычислительных терминах "ленивая оценка" означает отсрочку обработки на чем-то, пока вы на самом деле не нуждаетесь в ней. Основная идея заключается в том, что иногда вы можете избежать дорогостоящих операций, если вам это не понадобится, или если значение изменится до его использования.

Простым примером этого является System.Exception.StackTrace. Это свойство string для исключения, но оно фактически не создается до тех пор, пока вы не получите доступ к нему. Внутри он делает что-то вроде:

String StackTrace{
  get{
    if(_stackTrace==null){
      _stackTrace = buildStackTrace();
    }
    return _stackTrace;
  }
}

Это сэкономит вам накладные расходы на вызов callStackTrace, пока кто-то не захочет посмотреть, что это такое.

Свойства - один из способов просто обеспечить этот тип поведения.

Ответ 5

Здесь вы можете прочитать Lazy Initialization с образцом кода.

Если у вас есть объект, который дорогой для создания, и программа может не использовать его. Например, предположим что у вас есть в памяти клиент объект, обладающий свойством Orders который содержит большой массив порядка объекты, которые должны быть инициализированы, требует подключения к базе данных. Если пользователь никогда не просит отобразить Заказы или использовать данные в вычислении, то нет причин использовать систему памяти или вычислительных циклов для создания Это. Используя Lazy, чтобы объявить объект Orders для ленивых инициализации, вы можете избежать траты системные ресурсы, когда объект не используется.

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

Ответ 6

Ленивая инициализация объекта означает, что его создание отложено до его первого использования. (Для этой темы термины "ленивая инициализация" и "ленивое" создание являются синонимами.). Ленивая инициализация в основном используется для повышения производительности, предотвращения расточительных вычислений и сокращения требований к программной памяти. Это наиболее распространенные сценарии:

Если у вас есть объект, который стоит создавать, и программа может его не использовать. Например, предположим, что у вас есть объект Customer, у которого есть свойство Orders, которое содержит большой массив объектов Order, для инициализации которого требуется соединение с базой данных. Если пользователь никогда не просит отобразить Заказы или использовать данные в вычислении, тогда нет причин использовать системную память или вычислительные циклы для ее создания. Используя Lazy для объявления объекта Orders для ленивой инициализации, вы можете избежать потери ресурсов системы, когда объект не используется.

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

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

Ответ 7

//Lazy instantiation delays certain tasks. 
//It typically improves the startup time of a C# application.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LazyLoad
{
    class Program
    {
        static void Main(string[] args)
        {
            Lazy<MyClass> MyLazyClass = new Lazy<MyClass>(); // create lazy class
            Console.WriteLine("IsValueCreated = {0}",MyLazyClass.IsValueCreated); // print value to check if initialization is over

            MyClass sample = MyLazyClass.Value; // real value Creation Time
            Console.WriteLine("Length = {0}", sample.Length); // print array length

            Console.WriteLine("IsValueCreated = {0}", MyLazyClass.IsValueCreated); // print value to check if initialization is over
            Console.ReadLine();
        }
    }

    class MyClass
    {
        int[] array;
        public MyClass()
        {
            array = new int[10];

        }

        public int Length
        {
            get
            {
                return this.array.Length;
            }
        }
    }
}


// out put

// IsValueCreated = False
// Length = 10
// IsValueCreated = True

Ответ 8

Насколько я понял о ленивом init до сих пор, заключается в том, что программа не загружает/не запрашивает все данные a один раз. Он ждет его использования, прежде чем запрашивать его, например. SQL-сервер.

Если у вас есть база данных с большой таблицей, объединенной с большим количеством субтитров, и вам не нужны детали, соединенные с другими вкладками, если вы не перейдете в "редактировать" или "просмотреть детали", а затем "Lazy Init". поможет приложению ускориться и сначала "ленить нагрузку" на нужные детали.

В SQL или LINQ вы можете установить эту "настройку" в вашей модели базы данных pr. dataelement.

Надеюсь, это имеет смысл для вашего вопроса?

Веб-клиент (например, браузер) делает то же самое. Изображения "ленивы загружены" после HTML, и AJAX также является "своего рода ленивым init" при правильном использовании.

Ответ 9

Примеры баз данных, которые были упомянуты до сих пор, хороши, но не ограничиваются только уровнем доступа к данным. Вы можете применять одни и те же принципы в любой ситуации, когда производительность или память могут вызывать беспокойство. Хороший пример (хотя и не .NET) находится в Cocoa, где вы можете подождать, пока пользователь не попросит окно фактически загрузить его (и связанные с ним объекты) из nib. Это может помочь уменьшить использование памяти и ускорить загрузку исходного приложения, особенно когда вы говорите о таких вещах, как окна настроек, которые не понадобятся до более позднего времени, если когда-либо.

Ответ 10

Вы получите правильный ответ по этой ссылке, пожалуйста, следуйте.https://docs.microsoft.com/en-us/dotnet/framework/performance/lazy-initialization