Lazy<T> Sınıf

Tanım

Yavaş başlatma desteği sağlar.Provides support for lazy initialization.

generic <typename T>
public ref class Lazy
public class Lazy<T>
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Lazy<T>
type Lazy<'T> = class
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type Lazy<'T> = class
Public Class Lazy(Of T)

Tür Parametreleri

T

Geç başlatılan nesnenin türü.The type of object that is being lazily initialized.

Devralma
Lazy<T>
Türetilmiş
Öznitelikler

Örnekler

Aşağıdaki örnek, Lazy<T> birden çok iş parçacığından erişimi olan yavaş başlatma sağlamak için sınıfının kullanımını gösterir.The following example demonstrates the use of the Lazy<T> class to provide lazy initialization with access from multiple threads.

Not

Örnek, oluşturucuyu kullanır Lazy<T>(Func<T>) .The example uses the Lazy<T>(Func<T>) constructor. Ayrıca, Lazy<T>(Func<T>, Boolean) oluşturucunun kullanımını ( true için belirterek isThreadSafe ) ve Lazy<T>(Func<T>, LazyThreadSafetyMode) oluşturucuyu ( LazyThreadSafetyMode.ExecutionAndPublication için belirterek) gösterir mode .It also demonstrates the use of the Lazy<T>(Func<T>, Boolean) constructor (specifying true for isThreadSafe) and the Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor (specifying LazyThreadSafetyMode.ExecutionAndPublication for mode). Farklı bir oluşturucuya geçiş yapmak için, hangi oluşturucuların açıklama dışarı olduğunu değiştirmeniz yeterlidir.To switch to a different constructor, just change which constructors are commented out.

Aynı oluşturucuları kullanarak özel durum önbelleğe almayı gösteren bir örnek için, oluşturucuya bakın Lazy<T>(Func<T>) .For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

Örnek, LargeObject birkaç iş parçacığından biri tarafından geç başlatılacak bir sınıfı tanımlar.The example defines a LargeObject class that will be initialized lazily by one of several threads. Kodun dört temel bölümü, başlatıcı oluşturma, fabrika yöntemi, gerçek başlatma ve sınıfın Oluşturucusu, LargeObject nesne oluşturulduğunda bir ileti gösteren Oluşturucu gösterir.The four key sections of code illustrate the creation of the initializer, the factory method, the actual initialization, and the constructor of the LargeObject class, which displays a message when the object is created. MainYöntemin başlangıcında örnek, için iş parçacığı açısından güvenli yavaş Başlatıcı oluşturur LargeObject :At the beginning of the Main method, the example creates the thread-safe lazy initializer for LargeObject:

lazyLargeObject = new Lazy<LargeObject>(InitLargeObject);

// The following lines show how to use other constructors to achieve exactly the
// same result as the previous line:
//lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, true);
//lazyLargeObject = new Lazy<LargeObject>(InitLargeObject,
//                               LazyThreadSafetyMode.ExecutionAndPublication);
lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject)

' The following lines show how to use other constructors to achieve exactly the
' same result as the previous line: 
'lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject, True)
'lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject, _
'                               LazyThreadSafetyMode.ExecutionAndPublication)

Factory yöntemi, daha fazla başlatma için bir yer tutucu ile nesnenin oluşturulmasını gösterir:The factory method shows the creation of the object, with a placeholder for further initialization:

static LargeObject InitLargeObject()
{
    LargeObject large = new LargeObject(Thread.CurrentThread.ManagedThreadId);
    // Perform additional initialization here.
    return large;
}
Private Shared Function InitLargeObject() As LargeObject
    Dim large As New LargeObject(Thread.CurrentThread.ManagedThreadId)
    ' Perform additional initialization here.
    Return large
End Function

İlk iki kod bölümünün, burada gösterildiği gibi bir Lambda işlevi kullanılarak birleştirildiğini unutmayın:Note that the first two code sections could be combined by using a lambda function, as shown here:

lazyLargeObject = new Lazy<LargeObject>(() =>
{
    LargeObject large = new LargeObject(Thread.CurrentThread.ManagedThreadId);
    // Perform additional initialization here.
    return large;
});
lazyLargeObject = New Lazy(Of LargeObject)(Function () 
    Dim large As New LargeObject(Thread.CurrentThread.ManagedThreadId) 
    ' Perform additional initialization here.
    Return large
End Function)

Bu örnek, yavaş başlatma gerçekleşmeden önce belirsiz bir sürenin geçeceğini göstermek için duraklatılır.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. ENTER tuşuna bastığınızda, örnek üç iş parçacığı oluşturur ve başlatır.When you press the Enter key, the example creates and starts three threads. ThreadProcTüm üç iş parçacığı tarafından kullanılan yöntem Value özelliği çağırır.The ThreadProc method that's used by all three threads calls the Value property. Bu durumda, LargeObject örnek oluşturulur:The first time this happens, the LargeObject instance is created:

LargeObject large = lazyLargeObject.Value;

// IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the
//            object after creation. You must lock the object before accessing it,
//            unless the type is thread safe. (LargeObject is not thread safe.)
lock(large)
{
    large.Data[0] = Thread.CurrentThread.ManagedThreadId;
    Console.WriteLine("Initialized by thread {0}; last used by thread {1}.",
        large.InitializedBy, large.Data[0]);
}
Dim large As LargeObject = lazyLargeObject.Value

' IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the  
'            object after creation. You must lock the object before accessing it,
'            unless the type is thread safe. (LargeObject is not thread safe.)
SyncLock large
    large.Data(0) = Thread.CurrentThread.ManagedThreadId
    Console.WriteLine("Initialized by thread {0}; last used by thread {1}.", _
        large.InitializedBy, large.Data(0))
End SyncLock

LargeObjectKodun son anahtar bölümünü içeren sınıfının Oluşturucusu, bir ileti görüntüler ve başlatma iş parçacığının kimliğini kaydeder.The constructor of the LargeObject class, which includes the last key section of code, displays a message and records the identity of the initializing thread. Programın çıktısı tam kod listesinin sonunda görüntülenir.The output from the program appears at the end of the full code listing.

int initBy = 0;
public LargeObject(int initializedBy)
{
    initBy = initializedBy;
    Console.WriteLine("LargeObject was created on thread id {0}.", initBy);
}
Private initBy As Integer = 0
Public Sub New(ByVal initializedBy As Integer)
    initBy = initializedBy
    Console.WriteLine("LargeObject was created on thread id {0}.", initBy)
End Sub

Not

Kolaylık olması için bu örnek, genel bir örneğini kullanır Lazy<T> ve tüm yöntemler static ( Shared Visual Basic).For simplicity, this example uses a global instance of Lazy<T>, and all the methods are static (Shared in Visual Basic). Bunlar yavaş başlatmanın kullanılması için bir gereksinim değildir.These are not requirements for the use of lazy initialization.

using System;
using System.Threading;

class Program
{
    static Lazy<LargeObject> lazyLargeObject = null;

    static LargeObject InitLargeObject()
    {
        LargeObject large = new LargeObject(Thread.CurrentThread.ManagedThreadId);
        // Perform additional initialization here.
        return large;
    }

    static void Main()
    {
        // The lazy initializer is created here. LargeObject is not created until the
        // ThreadProc method executes.
        lazyLargeObject = new Lazy<LargeObject>(InitLargeObject);

        // The following lines show how to use other constructors to achieve exactly the
        // same result as the previous line:
        //lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, true);
        //lazyLargeObject = new Lazy<LargeObject>(InitLargeObject,
        //                               LazyThreadSafetyMode.ExecutionAndPublication);

        Console.WriteLine(
            "\r\nLargeObject is not created until you access the Value property of the lazy" +
            "\r\ninitializer. Press Enter to create LargeObject.");
        Console.ReadLine();

        // Create and start 3 threads, each of which uses LargeObject.
        Thread[] threads = new Thread[3];
        for (int i = 0; i < 3; i++)
        {
            threads[i] = new Thread(ThreadProc);
            threads[i].Start();
        }

        // Wait for all 3 threads to finish.
        foreach (Thread t in threads)
        {
            t.Join();
        }

        Console.WriteLine("\r\nPress Enter to end the program");
        Console.ReadLine();
    }

    static void ThreadProc(object state)
    {
        LargeObject large = lazyLargeObject.Value;

        // IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the
        //            object after creation. You must lock the object before accessing it,
        //            unless the type is thread safe. (LargeObject is not thread safe.)
        lock(large)
        {
            large.Data[0] = Thread.CurrentThread.ManagedThreadId;
            Console.WriteLine("Initialized by thread {0}; last used by thread {1}.",
                large.InitializedBy, large.Data[0]);
        }
    }
}

class LargeObject
{
    public int InitializedBy { get { return initBy; } }

    int initBy = 0;
    public LargeObject(int initializedBy)
    {
        initBy = initializedBy;
        Console.WriteLine("LargeObject was created on thread id {0}.", initBy);
    }

    public long[] Data = new long[100000000];
}

/* This example produces output similar to the following:

LargeObject is not created until you access the Value property of the lazy
initializer. Press Enter to create LargeObject.

LargeObject was created on thread id 3.
Initialized by thread 3; last used by thread 3.
Initialized by thread 3; last used by thread 4.
Initialized by thread 3; last used by thread 5.

Press Enter to end the program
 */
Imports System.Threading

Friend Class Program
    Private Shared lazyLargeObject As Lazy(Of LargeObject) = Nothing

    Private Shared Function InitLargeObject() As LargeObject
        Dim large As New LargeObject(Thread.CurrentThread.ManagedThreadId)
        ' Perform additional initialization here.
        Return large
    End Function


    Shared Sub Main()
        ' The lazy initializer is created here. LargeObject is not created until the 
        ' ThreadProc method executes.
        lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject)

        ' The following lines show how to use other constructors to achieve exactly the
        ' same result as the previous line: 
        'lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject, True)
        'lazyLargeObject = New Lazy(Of LargeObject)(AddressOf InitLargeObject, _
        '                               LazyThreadSafetyMode.ExecutionAndPublication)


        Console.WriteLine(vbCrLf & _
            "LargeObject is not created until you access the Value property of the lazy" _
            & vbCrLf & "initializer. Press Enter to create LargeObject.")
        Console.ReadLine()

        ' Create and start 3 threads, each of which uses LargeObject.
        Dim threads(2) As Thread
        For i As Integer = 0 To 2
            threads(i) = New Thread(AddressOf ThreadProc)
            threads(i).Start()
        Next i

        ' Wait for all 3 threads to finish. 
        For Each t As Thread In threads
            t.Join()
        Next t

        Console.WriteLine(vbCrLf & "Press Enter to end the program")
        Console.ReadLine()
    End Sub


    Private Shared Sub ThreadProc(ByVal state As Object)
        Dim large As LargeObject = lazyLargeObject.Value

        ' IMPORTANT: Lazy initialization is thread-safe, but it doesn't protect the  
        '            object after creation. You must lock the object before accessing it,
        '            unless the type is thread safe. (LargeObject is not thread safe.)
        SyncLock large
            large.Data(0) = Thread.CurrentThread.ManagedThreadId
            Console.WriteLine("Initialized by thread {0}; last used by thread {1}.", _
                large.InitializedBy, large.Data(0))
        End SyncLock
    End Sub
End Class

Friend Class LargeObject
    Public ReadOnly Property InitializedBy() As Integer
        Get
            Return initBy
        End Get
    End Property

    Private initBy As Integer = 0
    Public Sub New(ByVal initializedBy As Integer)
        initBy = initializedBy
        Console.WriteLine("LargeObject was created on thread id {0}.", initBy)
    End Sub

    Public Data(99999999) As Long
End Class

' This example produces output similar to the following:
'
'LargeObject is not created until you access the Value property of the lazy
'initializer. Press Enter to create LargeObject.
'
'LargeObject was created on thread id 3.
'Initialized by thread 3; last used by thread 3.
'Initialized by thread 3; last used by thread 5.
'Initialized by thread 3; last used by thread 4.
'
'Press Enter to end the program
' 

Açıklamalar

Büyük veya Kaynak yoğunluklu bir nesnenin oluşturulmasını veya Kaynak yoğunluklu bir görevin yürütülmesini, özellikle de programın kullanım ömrü boyunca böyle bir oluşturma veya yürütme gerçekleşmeyebilir durumunda ertelenmesi için yavaş başlatma kullanın.Use lazy initialization to defer the creation of a large or resource-intensive object, or the execution of a resource-intensive task, particularly when such creation or execution might not occur during the lifetime of the program.

Yavaş başlatmaya hazırlanmak için bir örneği oluşturursunuz Lazy<T> .To prepare for lazy initialization, you create an instance of Lazy<T>. Oluşturduğunuz nesnenin tür bağımsız değişkeni, Lazy<T> geç başlatmak istediğiniz nesnenin türünü belirtir.The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. Nesnesini oluşturmak için kullandığınız Oluşturucu, Lazy<T> başlatmanın özelliklerini belirler.The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. Özelliğe ilk kez erişildiğinde geç başlatma gerçekleşir Lazy<T>.Value .Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

Çoğu durumda, bir oluşturucunun seçilmesi iki soruya verilen yanıtlara bağlıdır:In most cases, choosing a constructor depends on your answers to two questions:

  • Geç Initialized nesnesine birden fazla iş parçacığından erişilir mi?Will the lazily initialized object be accessed from more than one thread? Öyleyse, Lazy<T> nesne onu herhangi bir iş parçacığında oluşturabilir.If so, the Lazy<T> object might create it on any thread. Varsayılan davranışı iş parçacığı açısından güvenli bir nesne oluşturmak için olan basit oluşturuculardan birini kullanabilirsiniz. bu Lazy<T> sayede, geç örneklenmiş nesnenin yalnızca bir örneğinin, ne kadar iş parçacığına erişmeye çalıştığı bağımsız olarak oluşturulmasını sağlayabilirsiniz.You can use one of the simple constructors whose default behavior is to create a thread-safe Lazy<T> object, so that only one instance of the lazily instantiated object is created no matter how many threads try to access it. Lazy<T>İş parçacığı güvenli olmayan bir nesne oluşturmak için, iş parçacığı güvenliği belirtmenizi sağlayan bir Oluşturucu kullanmanız gerekir.To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.

    Dikkat

    Lazy<T>Nesne iş parçacığını güvenli hale getirmek, geç Initialized nesnesini korumaz.Making the Lazy<T> object thread safe does not protect the lazily initialized object. Birden çok iş parçacığı geç başlatılmış nesneye erişebilmelidir, özelliklerini ve yöntemlerini çoklu iş parçacıklı erişim için güvenli hale getirin.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • Yavaş başlatma için çok fazla kod gerekiyor veya geç başlatılmış nesne, ihtiyacınız olan her şeyi yapan ve özel durum atmayan bir oluşturucuya sahip mi?Does lazy initialization require a lot of code, or does the lazily initialized object have a parameterless constructor that does everything you need and doesn't throw exceptions? Başlatma kodu yazmanız gerekiyorsa veya özel durumların işlenmesi gerekiyorsa, bir fabrika yöntemi alan oluşturuculardan birini kullanın.If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. Fabrika yöntemine başlatma kodunuzu yazın.Write your initialization code in the factory method.

Aşağıdaki tabloda, bu iki etkene göre hangi oluşturucunun seçeceğiniz gösterilmektedir:The following table shows which constructor to choose, based on these two factors:

Nesne şu şekilde erişilecekObject will be accessed by Başlatma kodu gerekmiyorsa (parametresiz Oluşturucu), şunu kullanınIf no initialization code is required (parameterless constructor), use Başlatma kodu gerekliyse, şunu kullanınIf initialization code is required, use
Birden çok iş parçacığıMultiple threads Lazy<T>() Lazy<T>(Func<T>)
Bir iş parçacığıOne thread Lazy<T>(Boolean) , isThreadSafe olarak ayarlanır false .Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean) , isThreadSafe olarak ayarlanır false .Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

Fabrika yöntemini belirtmek için bir lambda ifadesi kullanabilirsiniz.You can use a lambda expression to specify the factory method. Bu, tüm başlatma kodlarını tek bir yerde tutar.This keeps all the initialization code in one place. Lambda ifadesi, geç başlatılan nesnenin oluşturucusuna geçirdiğiniz bağımsız değişkenler dahil olmak üzere bağlamı yakalar.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

Özel durum önbelleğe alma Fabrika yöntemlerini kullandığınızda özel durumlar önbelleğe alınır.Exception caching When you use factory methods, exceptions are cached. Diğer bir deyişle, bir iş parçacığı nesnenin özelliğine erişmeyi denediğinde, fabrika yöntemi bir özel durum oluşturursa Value Lazy<T> , her sonraki denemede de aynı özel durum oluşturulur.That is, if the factory method throws an exception the first time a thread tries to access the Value property of the Lazy<T> object, the same exception is thrown on every subsequent attempt. Bu, özelliğe yapılan her çağrının Value aynı sonucu üretmesini ve farklı iş parçacıkları farklı sonuçlar elde ededurumlarda oluşabilecek hafif hataları önlenmesini sağlar.This ensures that every call to the Value property produces the same result and avoids subtle errors that might arise if different threads get different results. , Lazy<T> T Diğer koşullarda, genellikle başlangıç sırasında daha önceki bir noktada başlatılan bir fiili için ' i temsil eder.The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. Daha önceki bir noktadaki hata genellikle önemli.A failure at that earlier point is usually fatal. Kurtarılabilir bir hata için olası bir sorun varsa, yavaş başlatma kullanmadığınız gibi, başlatma yordamına (Bu durumda, Factory yöntemi) yeniden deneme mantığı oluşturmanızı öneririz.If there is a potential for a recoverable failure, we recommend that you build the retry logic into the initialization routine (in this case, the factory method), just as you would if you weren't using lazy initialization.

Kilitlemenin alternatifi Belirli durumlarda, Lazy<T> nesnenin varsayılan kilitleme davranışının yükünü ortadan kaldırmak isteyebilirsiniz.Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. Nadir durumlarda kilitlenmeleri olası olabilir.In rare situations, there might be a potential for deadlocks. Böyle durumlarda, Lazy<T>(LazyThreadSafetyMode) veya Lazy<T>(Func<T>, LazyThreadSafetyMode) oluşturucusunu kullanabilir ve belirtebilirsiniz LazyThreadSafetyMode.PublicationOnly .In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. Bu, Lazy<T> iş parçacıkları Value özelliği aynı anda çağırdıysanız, nesnenin birkaç iş parçacığı üzerinde geç başlatılmış nesnenin bir kopyasını oluşturmasını sağlar.This enables the Lazy<T> object to create a copy of the lazily initialized object on each of several threads if the threads call the Value property simultaneously. Lazy<T>Nesnesi, tüm iş parçacıklarının geç başlatılmış nesnenin aynı örneğini kullanmasını ve kullanılmayan örnekleri atmasını sağlar.The Lazy<T> object ensures that all threads use the same instance of the lazily initialized object and discards the instances that are not used. Bu nedenle, kilitleme ek yükünü azaltma maliyeti, programınızın bazen pahalı bir nesnenin ek kopyalarını oluşturup atıp atamamasını sağlayabilir.Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. Çoğu durumda bu durum düşüktür.In most cases, this is unlikely. Lazy<T>(LazyThreadSafetyMode)Ve Lazy<T>(Func<T>, LazyThreadSafetyMode) oluşturucularının örnekleri bu davranışı gösterir.The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

Önemli

Belirttiğinizde LazyThreadSafetyMode.PublicationOnly , bir fabrika yöntemi belirtseniz bile özel durumlar hiçbir zaman önbelleğe alınmaz.When you specify LazyThreadSafetyMode.PublicationOnly, exceptions are never cached, even if you specify a factory method.

Denk oluşturucular Öğesinin kullanımını etkinleştirmenin yanı sıra, LazyThreadSafetyMode.PublicationOnly Lazy<T>(LazyThreadSafetyMode) ve Lazy<T>(Func<T>, LazyThreadSafetyMode) oluşturucuları diğer oluşturucuların işlevlerini çoğaltabilir.Equivalent constructors In addition to enabling the use of LazyThreadSafetyMode.PublicationOnly, the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors can duplicate the functionality of the other constructors. Aşağıdaki tabloda denk davranış üreten parametre değerleri gösterilmektedir.The following table shows the parameter values that produce equivalent behavior.

Bir nesne oluşturmak için Lazy<T>To create a Lazy<T> object that is Parametresi olan oluşturucular için LazyThreadSafetyMode mode , modeFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Boolean parametresi olan oluşturucular için isThreadSafe , isThreadSafeFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to İş parçacığı güvenlik parametreleri olmayan oluşturucular içinFor constructors with no thread safety parameters
Tam iş parçacığı güvenli; yalnızca bir iş parçacığının değeri Başlatan şekilde kilitlemeyi kullanır.Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true Bu tür oluşturucular tamamen iş parçacığı güvenlidir.All such constructors are fully thread safe.
İş parçacığı güvenli değil.Not thread safe. None false Geçerli değildir.Not applicable.
Tam iş parçacığı güvenli; değeri başlatmak için iş parçacıkları Race.Fully thread safe; threads race to initialize the value. PublicationOnly Geçerli değildir.Not applicable. Geçerli değildir.Not applicable.

Diğer yetenekler Lazy<T> İş parçacığı statik alanlarıyla veya özellikler için yedekleme deposu olarak ' nin kullanımı hakkında bilgi için bkz. yavaş başlatma.Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.

Oluşturucular

Lazy<T>()

Lazy<T> sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Lazy<T> class. Yavaş başlatma gerçekleştiğinde, hedef türün parametresiz oluşturucusu kullanılır.When lazy initialization occurs, the parameterless constructor of the target type is used.

Lazy<T>(Boolean)

Lazy<T> sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Lazy<T> class. Yavaş başlatma gerçekleştiğinde, hedef türün parametresiz oluşturucusu ve belirtilen başlatma modu kullanılır.When lazy initialization occurs, the parameterless constructor of the target type and the specified initialization mode are used.

Lazy<T>(Func<T>)

Lazy<T> sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Lazy<T> class. Yavaş başlatma gerçekleştiğinde, belirtilen başlatma işlevi kullanılır.When lazy initialization occurs, the specified initialization function is used.

Lazy<T>(Func<T>, Boolean)

Lazy<T> sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Lazy<T> class. Yavaş başlatma gerçekleştiğinde, belirtilen başlatma işlevi ve başlatma modu kullanılır.When lazy initialization occurs, the specified initialization function and initialization mode are used.

Lazy<T>(Func<T>, LazyThreadSafetyMode)

Lazy<T>Belirtilen başlatma işlevini ve iş parçacığı güvenliği modunu kullanan sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Lazy<T> class that uses the specified initialization function and thread-safety mode.

Lazy<T>(LazyThreadSafetyMode)

Lazy<T>Parametresiz oluşturucusunu T ve belirtilen iş parçacığı güvenliği modunu kullanan sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Lazy<T> class that uses the parameterless constructor of T and the specified thread-safety mode.

Lazy<T>(T)

Lazy<T>Önceden başlatılmış bir belirtilen değeri kullanan sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Lazy<T> class that uses a preinitialized specified value.

Özellikler

IsValueCreated

Bu örnek için bir değer oluşturulup oluşturulmayacağını gösteren bir değer alır Lazy<T> .Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value

Geçerli örneğin geç Initialized değerini alır Lazy<T> .Gets the lazily initialized value of the current Lazy<T> instance.

Yöntemler

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
ToString()

Bu örnek için özelliğin dize gösterimini oluşturur ve döndürür Value .Creates and returns a string representation of the Value property for this instance.

Şunlara uygulanır

İş Parçacığı Güvenliği

Varsayılan olarak, sınıfının tüm ortak ve korumalı üyeleri Lazy<T> iş parçacığı güvenlidir ve birden çok iş parçacığından aynı anda kullanılabilir.By default, all public and protected members of the Lazy<T> class are thread safe and may be used concurrently from multiple threads. Bu iş parçacığı güvenlik garantisi, türün oluşturucuları için parametreler kullanılarak isteğe bağlı olarak ve örnek başına kaldırılabilir.These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

Ayrıca bkz.