Коли я повинен використовувати Lazy <T>?

Я знайшов цю статтю про Lazy: Лінь в C # 4.0 - Ледачий

Яка найкраща практика мати найкращі показники роботи з використанням лінивих об'єктів? Чи може хтось вказати мені на практичне використання в реальній програмі? Іншими словами, коли я повинен його використовувати?

Зазвичай ви використовуєте його, коли хочете щось інстанціювати при першому використанні. Це затримує витрати на його створення до того часу, коли це потрібно, а не завжди.

Зазвичай це є кращим, коли об'єкт може бути використаний або не може використовуватися, а вартість його побудови нетривіальна.

Ви повинні намагатися уникати використання Singletons, але якщо вам це знадобиться, це Lazy<T>полегшує реалізацію ледачих, безпечних для потоків синглів:

public sealed class Singleton
{
    // Because Singleton's constructor is private, we must explicitly
    // give the Lazy<Singleton> a delegate for creating the Singleton.
    static readonly Lazy<Singleton> instanceHolder =
        new Lazy<Singleton>(() => new Singleton());

    Singleton()
    {
        // Explicit private constructor to prevent default public constructor.
        ...
    }

    public static Singleton Instance => instanceHolder.Value;
}

Чудовий приклад реального світу, коли корисно завантажувати ледачий настрій, - це такі, як ОРМ (Object Relation Mappers), як Entity Framework та NHibernate.

Скажімо, у вас є юридична особа Клієнт, яка має властивості для імені, номера телефону та замовлень. Ім'я та Телефонний номер - це звичайні рядки, але Замовлення - це властивість навігації, яка повертає список кожного замовлення, яке клієнт коли-небудь робив.

Ви часто можете пройти всі клієнти та отримати їх ім’я та номер телефону, щоб зателефонувати. Це дуже швидке і просте завдання, але уявіть, що кожного разу, коли ви створюєте клієнта, він автоматично переходив і робив складний приєднання, щоб повернути тисячі замовлень. Найгірше, що ви навіть не збираєтесь користуватися замовленнями, тому це повна трата ресурсів!

Це ідеальне місце для ледачого завантаження, тому що якщо властивість «Замовлення» ліниво, воно не буде виконувати всі замовлення клієнта, якщо вони вам справді не потрібні. Ви можете перерахувати об'єкти Клієнта, отримуючи лише їх ім’я та номер телефону, поки властивість «Замовлення» терпляче спить, готовий до того, коли вам це потрібно.

Я розглядав можливість використання Lazy<T>властивостей, щоб поліпшити продуктивність власного коду (і дізнатися трохи більше про нього). Я прийшов сюди, шукаючи відповіді про те, коли його використовувати, але здається, що скрізь, де я заходжу, є фрази на кшталт:

Використовуйте ледачу ініціалізацію, щоб відкласти створення великого або ресурсомісткого об’єкта або виконання ресурсомісткого завдання, особливо коли таке створення або виконання може не відбуватися протягом життя програми.

від класу MSDN Lazy <T>

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

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

Опис

У моєму випадку мені було особливо цікаво побачити, чи може Lazy Properties допомогти покращити частину мого коду, яка робить багато інтерполяції (більшість з них не використовується), і тому я створив тест, який порівнював 3 підходи.

Я створив окремий тестовий клас з 20 тестовими властивостями (давайте назвати їх t-властивостями) для кожного підходу.

• Клас GetInterp: Запускає лінійну інтерполяцію щоразу, коли отримується t-властивість.
• Клас InitInterp: ініціалізує t-властивості, запустивши лінійну інтерполяцію для кожного з конструкторів. Отримати лише повертає дубль.
• Клас InitLazy: встановлює t-властивості як властивості Lazy, щоб лінійна інтерполяція була запущена один раз, коли властивість вперше отримана. Подальше отримання повинно просто повернути вже обчислений подвійний.

Результати тесту вимірюються в мс і становлять в середньому 50 екземплярів або 20 отриманих властивостей. Кожен тест потім проводили 5 разів.

Результати тесту 1: Моментальне (середнє 50 екземплярів)

Class      1        2        3        4        5        Avg       %
------------------------------------------------------------------------
GetInterp  0.005668 0.005722 0.006704 0.006652 0.005572 0.0060636 6.72
InitInterp 0.08481  0.084908 0.099328 0.098626 0.083774 0.0902892 100.00
InitLazy   0.058436 0.05891  0.068046 0.068108 0.060648 0.0628296 69.59

Результати тесту 2: Перше отримання (в середньому 20 об'єктів отримує)

Class      1        2        3        4        5        Avg       %
------------------------------------------------------------------------
GetInterp  0.263    0.268725 0.31373  0.263745 0.279675 0.277775 54.38
InitInterp 0.16316  0.161845 0.18675  0.163535 0.173625 0.169783 33.24
InitLazy   0.46932  0.55299  0.54726  0.47878  0.505635 0.510797 100.00

Результати тесту 3: Друге отримання (в середньому 20 об'єктів отримує)

Class      1        2        3        4        5        Avg       %
------------------------------------------------------------------------
GetInterp  0.08184  0.129325 0.112035 0.097575 0.098695 0.103894 85.30
InitInterp 0.102755 0.128865 0.111335 0.10137  0.106045 0.110074 90.37
InitLazy   0.19603  0.105715 0.107975 0.10034  0.098935 0.121799 100.00

Спостереження

GetInterpнайшвидше створити так, як очікувалося, оскільки воно нічого не робить. InitLazyшвидше уявити, ніж InitInterpприпускати, що накладні витрати в налаштуванні лінивих властивостей швидше, ніж мій лінійний розрахунок інтерполяції. Однак я трохи заплутався тут, тому що InitInterpслід робити 20 лінійних інтерполяцій (щоб встановити його t-властивості), але для отримання екземпляра потрібно лише 0,09 мс (тест 1), порівняно з GetInterpяким потрібно лише 0,28 мс, щоб зробити лише одну лінійну інтерполяцію перший раз (тест 2) і 0,1 мс, щоб зробити це вдруге (тест 3).

Це займає InitLazyмайже в 2 рази довше, ніж GetInterpперший раз отримати майно, хоча InitInterpвоно найшвидше, оскільки воно заселяло його властивості під час інстанції. (Принаймні, це було б зробити, але чому це результат інстанції був набагато швидшим, ніж одна лінійна інтерполяція? Коли саме це робить ці інтерполяції?)

На жаль, схоже, що в моїх тестах відбувається деяка автоматична оптимізація коду. GetInterpЩоб отримати об’єкт нерухомості потрібно в один і той же час, як і вдруге, але він відображається як більш ніж у 2 рази швидше. Схоже, що така оптимізація впливає і на інші класи, оскільки для тестування 3. вони займають приблизно стільки ж часу, проте такі оптимізації можуть мати місце і в моєму виробничому коді, що також може бути важливим фактором.

Висновки

Хоча деякі результати, як очікується, є й дуже цікаві несподівані результати, ймовірно, завдяки оптимізації коду. Навіть для класів, схожих на те, що вони роблять багато роботи в конструкторі, результати інстанції показують, що вони все ще можуть бути дуже швидкими для створення, порівняно з отриманням подвійного властивості. Хоча фахівці в цій галузі, можливо, зможуть прокоментувати та дослідити більш ретельно, моє особисте відчуття полягає в тому, що мені потрібно зробити цей тест ще раз, але на своєму виробничому коді, щоб вивчити, які саме оптимізації можуть відбуватися і там. Однак я очікую, що це InitInterpможе бути шлях.

Просто, щоб вказати на приклад, опублікований Метью

public sealed class Singleton
{
    // Because Singleton's constructor is private, we must explicitly
    // give the Lazy<Singleton> a delegate for creating the Singleton.
    private static readonly Lazy<Singleton> instanceHolder =
        new Lazy<Singleton>(() => new Singleton());

    private Singleton()
    {
        ...
    }

    public static Singleton Instance
    {
        get { return instanceHolder.Value; }
    }
}

до того, як народився Ледачий, ми зробили б це так:

private static object lockingObject = new object();
public static LazySample InstanceCreation()
{
    if(lazilyInitObject == null)
    {
         lock (lockingObject)
         {
              if(lazilyInitObject == null)
              {
                   lazilyInitObject = new LazySample ();
              }
         }
    }
    return lazilyInitObject ;
}

Від MSDN:

Використовуйте екземпляр Lazy, щоб відкласти створення великого або ресурсомісткого об'єкта або виконання ресурсомісткого завдання, особливо коли таке створення або виконання може не відбуватися протягом життя програми.

Окрім відповіді Джеймса Майкла Зайця, Lazy надає безпечну ініціалізацію вашої вартості. Погляньте на запис MSDN з перерахуванням LazyThreadSafetyMode, що описує різні типи режимів безпеки потоку для цього класу.

Ви повинні подивитися цей приклад, щоб зрозуміти архітектуру Lazy Loading

private readonly Lazy<List<int>> list = new Lazy<List<int>>(() =>
{
    List<int> configList = new List<int>(Thread.CurrentThread.ManagedThreadId);
    return configList;
});
public void Execute()
{
    list.Value.Add(0);
    if (list.IsValueCreated)
    {
        list.Value.Add(1);
        list.Value.Add(2);

        foreach (var item in list.Value)
        {
            Console.WriteLine(item);
        }
    }
    else
    {
        Console.WriteLine("Value not created");
    }
}

-> вихід -> 0 1 2

але якщо цей код не напишіть "list.Value.Add (0);"

output -> Значення не створено