Che cosa è lazy initialization e perché è utile?

Ciò che è pigro inizializzazione di oggetti? Come si fa a farlo e quali sono i vantaggi?

InformationsquelleAutor SNA | 2009-06-11

 

9 Replies
  1. 88

    Lazy Initialization di ottimizzare le prestazioni in cui si posticipa (potenzialmente costosi) creazione di un oggetto fino a poco prima che realmente bisogno.

    Un buon esempio è quello di non creare una connessione di database di fronte, ma solo prima è necessario per ottenere i dati dal database.

    Il motivo chiave per fare questo è che (spesso) si può evitare di creare completamente un oggetto se non ne avrete mai bisogno.

    • Si dovrebbe andare da sé, ma solo nel caso in cui ha perso La ragione è un’ottimizzazione è perché spesso non c’è bisogno di fare la creazione a tutti, e perché si potrebbe risparmiare facendo qualche lavoro quando il computer è già occupato fino a quando non è meno intensa.
    • Buon commento. Ho modificato la risposta di comprendere il vostro punto.
    • un ottimo (e diverse) caso di utilizzo/ragione per l’utilizzo di Lazy è pubblicato nel seguente MODO domanda : stackoverflow.com/a/15894928/4404962 questo suggerimento risolto esattamente ciò di cui abbiamo bisogno per risolvere utilizzando Lazy come chiave principali
  2. 42

    Come altri hanno detto, lazy initialization è ritardare inizializzazione fino a quando un componente o di un oggetto. È possibile visualizzare lazy initialization come applicazione runtime del YAGNI principio – “You ain't gonna need it

    I vantaggi da un punto di vista di applicazione della lazy initialization sono che gli utenti non devono pagare il tempo di inizializzazione per funzioni che non uso. Supponiamo che si stavano per inizializzare ogni componente dell’applicazione di fronte. Questo potrebbe creare un potenzialmente lungo tempo di avvio – si sarebbe dovuto attendere decine di secondi o di minuti prima che l’applicazione è pronta per l’uso. Sono in attesa e pagando per l’inizializzazione di caratteristiche che non possono mai usare o non usare subito.

    Invece, se si posticipa l’inizializzazione di tali componenti fino a quando il tempo di utilizzo, l’applicazione si avvia molto più velocemente. L’utente dovrà comunque pagare i costi di avvio durante l’utilizzo di altri componenti, ma che il costo sarà ammortizzato in tutta l’esecuzione del programma e non condensato in l’inizio, e l’utente può associare il tempo di inizializzazione di questi oggetti con le caratteristiche che stanno utilizzando.

    • Peccato, ho potuto dare solo +1! Buona logica, BTW.
    • YAGNI significa “you ain’t gonna necessario[la funzione, il codice]”. Lazy initialization è un’ottimizzazione che è un lavoro in sé. Io direi piuttosto che si applica in un altro modo: a meno che sai per certo è necessario lazy initialization, non è YAGNI.
  3. 13

    Lazy Initialization è il concetto di rinviare la creazione di un oggetto fino a che l’oggetto è effettivamente utilizzato prima. Se usato correttamente, può portare a significativi miglioramenti delle prestazioni.

    Personalmente, ho usato Lazy Initialization quando creando il mio arrotolato a mano ORM in .NET 2.0. Quando carico le mie raccolte dal database, i veri oggetti della collezione sono stati pigri inizializzato. Questo significava che le collezioni sono state create in fretta, ma ogni oggetto è stato caricato solo quando è necessario.

    Se si ha familiarità con il Singleton pattern, probabilmente avete visto lazy initialization in azione.

    public class SomeClassSingleton
    {
        private static SomeClass _instance = null;
    
        private SomeClassSingleton()
        {
        }
    
        public static SomeClass GetInstance()
        {
            if(_instance == null)
                _instance = new SomeClassSingleton();
    
            return _instance;
        }
    }

    In questo caso, l’istanza di SomeClass non è inizializzato fino a quando non è prima necessario dal SomeClassSingleton consumatore.

    • Rimuovere l’esplicita variabile privata a ‘null’ per migliorare la velocità leggermente più ;). Comunque, è ridondante.
    • bel punto, SomeClassSingleton deve essere uguale o inferiore classe di SomeClass
    • che cosa circa la sicurezza dei thread per questa classe singleton?
    • Non so se qualcuno legge vecchia risposte, ma presumo che il privato statico ottenere metodo di istanza deve essere pubblica?
    • Io non li leggo, e sì che dovrebbe essere. Ho aggiornato solo nel caso in cui qualcun altro ancora legge questo.
    • non dovrebbe _instance = new SomeClassSingleton(); essere _instance = new SomeClass(); ? o io sono la comprensione dal punto di vista diverso

  4. 5

    In generale in termini di elaborazione, ‘lazy evaluation” significa rinviare l’elaborazione su qualcosa fino a quando è effettivamente necessario. L’idea principale che a volte è possibile evitare costose operazioni di se risultano di non averne bisogno, o se il valore potrebbe cambiare prima del suo utilizzo.

    Un semplice esempio di questo è il Sistema.Fa eccezione.StackTrace. Questa è una stringa di proprietà su un’eccezione, ma non è effettivamente costruito fino ad accedervi. Internamente si fa qualcosa di simile:

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

    Ciò consente di risparmiare il sovraccarico di chiamare effettivamente buildStackTrace fino a quando qualcuno vuole vedere di cosa si tratta.

    Proprietà sono un modo semplicemente di fornire questo tipo di comportamento.

    • Questo non è thread-safe.
    • Vero, ma io non sono sicuro perché si dovrebbe essere la condivisione di un riferimento a un’eccezione tra più thread comunque.
  5. 2

    Qui si può leggere su Lazy Initialization con codice di esempio.

    • Quando si dispone di un oggetto che è
      costoso per creare, e il programma
      potrebbe non utilizzare. Ad esempio, si supponga
      che hai in memoria un Cliente
      oggetto che ha un’Ordini di proprietà
      che contiene una vasta gamma di Ordine
      oggetti che, per essere inizializzato,
      richiede una connessione di database. Se il
      utente non chiede mai di visualizzare gli Ordini
      o usa i dati in un calcolo,
      non vi è alcun motivo per utilizzare il sistema
      memoria o i cicli di calcolo per creare
      si. Utilizzando Pigro per dichiarare
      gli Ordini oggetto per pigri
      l’inizializzazione, si può evitare di sprecare
      risorse di sistema quando l’oggetto è
      non utilizzato.

    • Quando si dispone di un oggetto che è
      costoso per creare, e che si desidera
      rinviare la sua creazione fino a dopo le altre
      costose operazioni sono state
      completate. Ad esempio, si supponga che
      il programma carichi diversi oggetti
      istanze quando si comincia, ma solo
      alcuni di essi sono necessari immediatamente.
      È possibile migliorare l’avvio di
      le prestazioni del programma da
      il rinvio di inizializzazione del
      gli oggetti che non sono necessari fino a
      gli oggetti sono stati
      creato.

  6. 2

    Pigro inizializzazione di un oggetto significa che la sua creazione viene posticipata al primo utilizzo. (Per questo argomento, i termini lazy initialization e pigro istanza sono sinonimi. Lazy initialization è utilizzato principalmente per migliorare le prestazioni, evitare calcoli inutili e ridurre il programma di requisiti di memoria. Questi sono gli scenari più comuni:

    Quando si dispone di un oggetto che è costoso per creare, e il programma potrebbe non utilizzare. Per esempio, si supponga di avere in memoria un oggetto Cliente che ha un Ordini di proprietà che contiene una grande varietà di oggetti di Ordine che, per essere inizializzato, richiede una connessione di database. Se l’utente non chiede mai di visualizzare gli Ordini o usa i dati in un calcolo, non vi è alcun motivo per utilizzare la memoria di sistema o di cicli di calcolo per crearlo. Utilizzando Pigro per dichiarare l’oggetto Orders per lazy initialization, si può evitare di sprecare risorse di sistema quando l’oggetto non è usato.

    Quando si dispone di un oggetto che è costoso per creare, e si desidera rinviare la sua creazione, finché, dopo altre costose operazioni sono state completate. Ad esempio, si supponga che il programma carichi diverse istanze di un oggetto quando si inizia, ma solo alcuni di essi sono necessari immediatamente. È possibile migliorare le prestazioni di avvio del programma posticipando l’inizializzazione degli oggetti che non sono necessarie fino a quando gli oggetti sono stati creati.

    Anche se è possibile scrivere il proprio codice per eseguire lazy initialization, si consiglia di utilizzare Pigri, invece. Pigri e i relativi tipi di thread di supporto, di sicurezza e di fornire una coerente eccezione di propagazione politica.

  7. 2
    //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. 1

    Come quello che ho capito pigro init finora, è che il programma non carica/richiesta tutti i dati di una volta. Si attende che l’uso di esso prima della richiesta da eg. SQL-server.

    Se si dispone di un database con una tabella di grandi dimensioni è entrato con una grande quantità di sottotabelle e non richiedono i dettagli aggiunti da altri tabels a meno che non andare in “modifica” o “visualizza dettagli”, quindi Pigro Init. aiuterà l’applicazione per andare più veloce e di prima “lazy load” il detailsdata al momento del bisogno.

    In SQL o LINQ è possibile impostare questa “impostazione” nel database del modello pr. dataelement.

    Spero che questo abbia un senso alla tua domanda?

    Un webclient (es. un browser) fa la stessa cosa. Le immagini sono “pigri” caricato dopo l’HTML e AJAX è anche “una sorta di pigra init” se usato subito.

  9. 1

    Il database di esempi che sono stati citati finora sono buoni, ma non è limitato a solo il livello di accesso ai dati. Si potrebbe applicare lo stesso principio a qualsiasi situazione in cui le prestazioni o la memoria può essere una preoccupazione. Un buon esempio (anche se non .NET) è in Cacao, dove è possibile attendere fino a quando l’utente richiede una finestra per caricare (e i relativi oggetti) dal pennino. Questo può aiutare a mantenere la memoria di utilizzo e accelerare l’applicazione iniziale di carico, soprattutto quando si sta parlando di cose come le Preferenze di windows che non essere necessario fino a qualche tempo più tardi, se mai.

Lascia un commento