So verwenden Sie das Lazy-Initialisierungsmuster in C#

So Verwenden Sie Das Lazy Initialisierungsmuster In C



Die verzögerte Initialisierung, auch als verzögerte Instanziierung bezeichnet, ist ein OOP-Muster, bei dem die Erstellung eines Objekts bis zu seiner ersten Verwendung verzögert wird. Stellen Sie sich ein Restaurant vor, in dem Speisen nach Bedarf zubereitet werden, was dazu beitragen kann, die Verschwendung von Ressourcen zu verhindern.

Dies ist das gleiche Prinzip der verzögerten Initialisierung. Sein Hauptziel besteht darin, die Leistung zu verbessern und verschwenderische Rechenressourcen zu vermeiden.







In diesem Leitfaden behandeln wir die Grundlagen des verzögerten Initialisierungsmusters in C#. Denken Sie daran, dass wir uns mit dem Wesentlichsten befassen und die erweiterte Implementierung dieses Musters überspringen, wie z. B. die Erstellung einer benutzerdefinierten Lazy-Initialisierung und -Implementierung, das Threading der Lazy-Initialisierung und mehr.



Verzögerte Initialisierung in C#

In C# können wir die Lazy-Objektinitialisierung mithilfe der Lazy-Klasse implementieren. Diese Klasse stellt uns die Funktionen zur Implementierung der verzögerten Initialisierung zur Verfügung.



Es ist gut zu bedenken, dass C# es uns ermöglicht, die benutzerdefinierten Methoden zum Erstellen der verzögerten Initialisierungsobjekte zu implementieren. In unserem Fall verwenden wir jedoch die Klasse Lazy, die Thread-Sicherheit unterstützt.





Die Syntax lautet wie folgt:

öffentliche Klasse Faul < T >


Hier bezeichnet „T“ den Objekttyp, den wir träge initialisieren möchten.



Beispielverwendung:

Nehmen Sie den folgenden Code, der zeigt, wie wir die Lazy-Klasse verwenden können, um die Lazy-Objektinitialisierung durchzuführen:

Verwenden des Systems;

Klasse ResourceIntensive
{
öffentliche RessourceIntensiv ( )
{
Console.WriteLine ( „Ressourcenintensiver Betrieb geschaffen!“ ) ;
}

öffentliche Zeichenfolge GetData ( )
{
zurückkehren „Daten aus ressourcenintensivem Betrieb.“ ;
}
}

Klassenprogramm
{
statische Leere Main ( )
{
Faul < Ressourcenintensiv > lazyResource = neue Lazy < Ressourcenintensiv > ( ) ;

Console.WriteLine ( „Lazy erstellt.“ ) ;
Console.WriteLine ( „Wird Wert geschaffen?“ + lazyResource.IsValueCreated ) ;

// hier aufgepasst
ResourceIntensive resources = lazyResource.Value;

Console.WriteLine ( „Wird Wert geschaffen?“ + lazyResource.IsValueCreated ) ;
Console.WriteLine ( Ressource.GetData ( ) ) ;
}
}


Achten Sie in unserem gegebenen Beispiel auf die Klasse „ResourceIntensive“. Dies hilft uns, einen Vorgang zu simulieren, der viele Ressourcen verbraucht.

In der Hauptfunktion erstellen wir zunächst ein Lazy-Objekt, rufen jedoch nicht sofort den ResourceIntensive-Konstruktor auf.

Anschließend prüfen und drucken wir, ob der Wert im Lazy-Objekt bereit ist.

Im nächsten Schritt versuchen wir, auf die Eigenschaft „Value“ des Lazy-Objekts zuzugreifen. Dadurch wird die Erstellung des eigentlichen Objekts ausgelöst.

Abschließend überprüfen wir noch einmal den Wert des Objekts.

Dies sollte eine Ausgabe zurückgeben:

Faul < Ressourcenintensität > erstellt.
Wird Wert geschaffen? FALSCH
Ressourcenintensiver Betrieb erstellt !
Wird Wert geschaffen? WAHR
Daten aus ressourcenintensivem Betrieb.


Hast du verstanden, was los war?

Dadurch wird die Objekterstellung erheblich verzögert, es sei denn, dies ist unbedingt erforderlich. In unserem Fall wird die Verwendung dieses Objekts ausgelöst, wenn wir versuchen, auf die Eigenschaft „Value“ zuzugreifen.

Wenn dies nicht versucht hätte, auf diese Eigenschaft zuzugreifen, wäre das Objekt nicht initialisiert geblieben, bis wir es tun. Wie Sie sehen, wird dadurch eine unnötige Verschwendung wertvoller Systemressourcen vermieden.

Abschluss

In diesem Grundlagen-Tutorial haben wir versucht, das Konzept der verzögerten Initialisierung in C# zu erklären und Ihnen zu helfen, es zu verstehen, warum es notwendig ist und wann Sie es verwenden könnten.