Co to jest leniwa inicjalizacja obiektów? Jak to robisz i jakie są zalety?
Odpowiedzi:
Inicjalizacja z opóźnieniem to optymalizacja wydajności, w której odraczasz (potencjalnie kosztowne) tworzenie obiektów do momentu, gdy faktycznie ich potrzebujesz.
Dobrym przykładem jest to, aby nie tworzyć połączenia z bazą danych z góry, ale tylko tuż przed uzyskaniem danych z bazy danych.
Głównym powodem tego jest to, że (często) można całkowicie uniknąć tworzenia obiektu, jeśli nigdy go nie potrzebujesz.
Lazyjest zamieszczony w następującym pytaniu SO: stackoverflow.com/a/15894928/4404962 ta sugestia rozwiązała dokładnie to, co musieliśmy rozwiązać - używając Lazyjako głównego podmiotu
Jak wspominali inni, leniwa inicjalizacja opóźnia inicjalizację do momentu użycia składnika lub obiektu. Możesz postrzegać leniwą inicjalizację jako aplikację wykonawczą z zasadą YAGNI - „ You ain't gonna need it”
Zalety leniwej inicjalizacji z punktu widzenia aplikacji polegają na tym, że użytkownicy nie muszą płacić za czas inicjalizacji za funkcje, których nie będą używać. Załóżmy, że miałbyś zainicjować każdy komponent aplikacji z góry. Może to spowodować potencjalnie długi czas uruchamiania - użytkownicy musieliby czekać dziesiątki sekund lub minut, zanim aplikacja będzie gotowa do użycia. Czekają i płacą za inicjalizację funkcji, z których mogą nigdy nie korzystać lub których mogą nie używać od razu.
Zamiast tego, jeśli odroczysz inicjalizację tych komponentów do czasu ich użycia, aplikacja uruchomi się znacznie szybciej. Użytkownik nadal będzie musiał zapłacić koszt uruchomienia podczas korzystania z innych komponentów, ale ten koszt będzie amortyzowany przez cały przebieg programu i nie będzie skondensowany na początku, a użytkownik może powiązać czas inicjalizacji tych obiektów z funkcjami, którymi są za pomocą.
Inicjalizacja z opóźnieniem to koncepcja odroczenia tworzenia obiektu do czasu jego pierwszego użycia. Jeśli jest używany prawidłowo, może spowodować znaczny wzrost wydajności.
Osobiście użyłem Lazy Initialization podczas tworzenia własnego, ręcznie zwijanego ORM w .NET 2.0. Podczas ładowania moich kolekcji z bazy danych rzeczywiste elementy kolekcji były inicjowane z opóźnieniem. Oznaczało to, że kolekcje powstawały szybko, ale każdy obiekt był ładowany tylko wtedy, gdy tego potrzebowałem.
Jeśli znasz wzorzec Singleton, prawdopodobnie widziałeś również leniwą inicjalizację w akcji.
public class SomeClassSingleton
{
private static SomeClass _instance = null;
private SomeClassSingleton()
{
}
public static SomeClass GetInstance()
{
if(_instance == null)
_instance = new SomeClassSingleton();
return _instance;
}
}
W takim przypadku wystąpienie SomeClass nie jest inicjowane, dopóki nie będzie wymagane przez konsumenta SomeClassSingleton.
Ogólnie rzecz biorąc, „leniwa ocena” oznacza odraczanie przetwarzania czegoś do momentu, gdy faktycznie tego potrzebujesz. Główną ideą jest to, że czasami można uniknąć kosztownych operacji, jeśli okaże się, że ich nie potrzebujesz lub jeśli wartość zmieniłaby się, zanim z niej skorzystasz.
Prostym tego przykładem jest System.Exception.StackTrace. Jest to właściwość typu string w przypadku wyjątku, ale w rzeczywistości nie jest tworzona, dopóki nie uzyskasz do niej dostępu. Wewnętrznie robi coś takiego:
String StackTrace{
get{
if(_stackTrace==null){
_stackTrace = buildStackTrace();
}
return _stackTrace;
}
}
Oszczędza to narzutów związanych z faktycznym wywoływaniem buildStackTrace, dopóki ktoś nie będzie chciał zobaczyć, co to jest.
Właściwości są jednym ze sposobów na zapewnienie tego typu zachowania.
Tutaj możesz przeczytać o Lazy Initialization z przykładowym kodem.
Gdy masz obiekt, którego tworzenie jest drogie, a program może go nie używać. Na przykład załóżmy, że masz w pamięci obiekt Customer, który ma właściwość Orders zawierającą dużą tablicę obiektów Order, które do zainicjowania wymagają połączenia z bazą danych. Jeśli użytkownik nigdy nie prosi o wyświetlenie Zamówień lub użycie danych w obliczeniach, nie ma powodu, aby używać pamięci systemowej lub cykli obliczeniowych do ich tworzenia. Używając Lazy, aby zadeklarować obiekt Orders do opóźnionej inicjalizacji, można uniknąć marnowania zasobów systemowych, gdy obiekt nie jest używany.
Gdy masz obiekt, który jest drogi w tworzeniu i chcesz odłożyć jego utworzenie do czasu zakończenia innych kosztownych operacji. Na przykład załóżmy, że program ładuje kilka instancji obiektów podczas uruchamiania, ale tylko niektóre z nich są wymagane natychmiast. Wydajność uruchamiania programu można poprawić, odraczając inicjalizację obiektów, które nie są wymagane, do momentu utworzenia wymaganych obiektów.
Leniwa inicjalizacja obiektu oznacza, że jego utworzenie jest odroczone do czasu jego pierwszego użycia. (W tym temacie terminy inicjowanie z opóźnieniem i instancje z opóźnieniem są synonimami). Inicjowanie z opóźnieniem jest używane głównie w celu zwiększenia wydajności, uniknięcia niepotrzebnych obliczeń i zmniejszenia wymagań dotyczących pamięci programu. Oto najczęstsze scenariusze:
Gdy masz obiekt, którego tworzenie jest drogie, a program może go nie używać. Na przykład załóżmy, że masz w pamięci obiekt Customer, który ma właściwość Orders zawierającą dużą tablicę obiektów Order, które do zainicjowania wymagają połączenia z bazą danych. Jeśli użytkownik nigdy nie prosi o wyświetlenie Zamówień lub użycie danych w obliczeniach, nie ma powodu, aby używać pamięci systemowej lub cykli obliczeniowych do ich tworzenia. Używając Lazy, aby zadeklarować obiekt Orders do opóźnionej inicjalizacji, można uniknąć marnowania zasobów systemowych, gdy obiekt nie jest używany.
Gdy masz obiekt, który jest drogi w tworzeniu i chcesz odłożyć jego utworzenie do czasu zakończenia innych kosztownych operacji. Na przykład załóżmy, że program ładuje kilka instancji obiektów podczas uruchamiania, ale tylko niektóre z nich są wymagane natychmiast. Wydajność uruchamiania programu można poprawić, odraczając inicjalizację obiektów, które nie są wymagane, do momentu utworzenia wymaganych obiektów.
Chociaż możesz napisać własny kod, aby wykonać leniwą inicjalizację, zalecamy zamiast tego użycie Lazy. Lazy i powiązane typy obsługują również bezpieczeństwo wątków i zapewniają spójne zasady propagacji wyjątków.
//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
Jak dotąd zrozumiałem o leniwym inicie, że program nie ładuje / nie żąda wszystkich danych raz. Czeka na jego użycie, zanim zażąda go np. serwer SQL.
Jeśli masz bazę danych z dużą tabelą połączoną z dużą liczbą podtabel i nie potrzebujesz szczegółów połączonych z innych tabel, chyba że przechodzisz do „edycji” lub „przeglądania szczegółów”, wtedy Lazy Init. pomoże aplikacji działać szybciej i najpierw "leniwie ładować" szczegółowe dane, gdy będą potrzebne.
W SQL lub LINQ możesz ustawić to „ustawienie” w modelu prod bazy danych. element danych.
Mam nadzieję, że to ma sens dla twojego pytania?
Klient sieciowy (np. Przeglądarka) robi to samo. Obrazy są „ładowane z opóźnieniem” po kodzie HTML, a AJAX jest również „rodzajem leniwego inicjalizacji”, jeśli jest używany prawidłowo.
Wspomniane do tej pory przykłady baz danych są dobre, ale nie ogranicza się to tylko do warstwy dostępu do danych. Możesz zastosować te same zasady w każdej sytuacji, w której wydajność lub pamięć mogą być problemem. Dobry przykład (choć nie .NET) znajduje się w kakao, gdzie możesz poczekać, aż użytkownik zażąda okna, aby załadować go (i powiązane z nim obiekty) z końcówki. Może to pomóc zmniejszyć zużycie pamięci i przyspieszyć początkowe ładowanie aplikacji, zwłaszcza gdy mówisz o takich rzeczach, jak okna Preferencji, które nie będą potrzebne do późniejszego czasu, jeśli w ogóle.