Was ist der Unterschied von neuem Lazy <Foo>() zu neuem Lazy <Foo> (() => new Foo())?

Question

Ich las einige .NET 4+ Code, wo es ein Lambda in Lazy Konstruktor verwenden, wie diese new Lazy<Foo>(() => new Foo()). Wie unterscheidet es sich von new Lazy<Foo>(), wenn keine Argumente an den Konstruktor Foo übergeben werden?

Answer 1

Wenn man sich die Zusammenfassung sehen für die beiden Konstrukteure in Frage ...

// Summary: 
//  Provides support for lazy initialization. 
// 
// Type parameters: 
// T: 
//  Specifies the type of object that is being lazily initialized. 
public class Lazy<T> { 
    // Summary: 
    //  Initializes a new instance of the System.Lazy<T> class. When lazy initialization 
    //  occurs, the default constructor of the target type is used. 
    public Lazy(); 
    // 
    // Summary: 
    //  Initializes a new instance of the System.Lazy<T> class. When lazy initialization 
    //  occurs, the specified initialization function is used. 
    // 
    // Parameters: 
    // valueFactory: 
    //  The delegate that is invoked to produce the lazily initialized value when 
    //  it is needed. 
    // 
    // Exceptions: 
    // System.ArgumentNullException: 
    //  valueFactory is null. 
    public Lazy(Func<T> valueFactory); 
} 

Das heißt, der Hauptunterschied ist, was Sie mit dem in der zweiten Konstruktor tun können

zB. ..

new Lazy<Foo>(() => new Foo(){ SomeProperty = someValue}); 

new Lazy<Foo>(() => new Foo(someValue)); 

... die sich vom Standardkonstruktor unterscheiden würden. Wenn der Typ keinen Standardkonstruktor mit keinen Parametern hat, dann kann new Lazy<T>() fehlschlagen.

Answer 2

Aus meiner Sicht würden Sie die Lambda-Ausdruck-Form verwenden, wenn Sie Parameter übergeben möchten, die bei der Initialisierung verwendet werden sollen. Ich denke nicht, dass es einen Anwendungsfall für das Lambda ohne Parameter gibt.

Answer 3

new Lazy<Foo>() verwendet Reflektion, eine Instanz von Foo Aufruf des Standard-Konstruktor zu erstellen, wie der folgenden Code Activator.CreateInstance(typeof(T)) mit so etwas. Dies bedeutet, dass Foo einen Standardkonstruktor haben muss.

Auf der anderen Seite gibt Ihnen Lazy<Foo>(Func<T>), falls erforderlich, mehr Flexibilität in Bezug auf den Aufbau der Instanz, die über den Lazy-Typ erstellt wurde.

Answer 4

Der Lazy-Standardkonstruktor ist nützlich, wenn der Typ mit einem Standardkonstruktor instanziiert werden kann. Dies bedeutet new Lazy<Foo>(() => new Foo()), wobei Foo keine Konstruktorparameter übernimmt, in den meisten Fällen auf new Lazy<Foo>() vereinfacht werden kann.

Die Ausnahme ist, wenn der Konstrukteurs-Typ privat ist - da als Standard Lazy<T> Konstruktor erwähnt verwendet Activator.CreateInstance(typeof(T)), das wird nicht funktionieren, wenn der Konstruktor privat ist, auch wenn es keine Parameter. Zum Beispiel könnte man eine Singleton implementieren Lazy<T> wie folgt verwendet:

public class Foo 
{ 
    // Notice that the Lazy(Func<T>) constructor is used here 
    // because Foo's constructor is private 
    private static readonly Lazy<Foo> _instance = new Lazy<Foo>(() => new Foo()); 
    public static Foo Current => _instance.Value; 

    private Foo() 
    { 
     // Don't allow calling code to new 
    } 
}