Lazy<T> Lazy<T> Lazy<T> Lazy<T> Class

定義

遅延初期化のサポートを提供します。Provides support for lazy initialization.

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

型パラメーター

T

遅延初期化されるオブジェクトの型。The type of object that is being lazily initialized.

継承
Lazy<T>Lazy<T>Lazy<T>Lazy<T>
派生
属性

次の例では、使用、Lazy<T>複数のスレッドからのアクセス権を持つ遅延初期化を提供するクラス。The following example demonstrates the use of the Lazy<T> class to provide lazy initialization with access from multiple threads.

注意

この例では、Lazy<T>(Func<T>)コンス トラクター。The example uses the Lazy<T>(Func<T>) constructor. 使用にも示しますが、Lazy<T>(Func<T>, Boolean)コンス トラクター (を指定するtrueisThreadSafe) とLazy<T>(Func<T>, LazyThreadSafetyMode)コンス トラクター (を指定するLazyThreadSafetyMode.ExecutionAndPublicationmode)。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). 別のコンス トラクターを切り替えるだけどのコンス トラクターをコメント アウトを変更します。To switch to a different constructor, just change which constructors are commented out.

例外を示す例については、同じコンス トラクターを使用して、キャッシュを参照してください、Lazy<T>(Func<T>)コンス トラクター。For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

この例では、複数あるスレッドのうちの 1 つによって遅れて初期化される LargeObject クラスを定義します。The example defines a LargeObject class that will be initialized lazily by one of several threads. コードの 4 つの主要セクションが、初期化子、ファクトリ メソッド、実際の初期化のコンス トラクターの作成を示しています、LargeObjectクラスは、オブジェクトが作成されたときにメッセージが表示されます。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. Main メソッドの開始時に、この例では 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<LargeObject>(InitLargeObject, true);
'lazyLargeObject = new Lazy<LargeObject>(InitLargeObject, _
'                               LazyThreadSafetyMode.ExecutionAndPublication);

ファクトリ メソッドは、初期化を行うためのプレース ホルダーで、オブジェクトの作成を示しています。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

次に示すように、最初の 2 つのコードのセクションでは、でしたラムダ関数を使用して組み合わせることを確認してください。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)

例では、遅延初期化が発生する前に、不確定な期間が切れることを示すために一時停止します。The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. 押したときに、 Enterキー、例では、作成して 3 つのスレッドを開始します。When you press the Enter key, the example creates and starts three threads. ThreadProc 3 つのスレッドのすべての呼び出しで使用されるメソッド、Valueプロパティ。The ThreadProc method that's used by all three threads calls the Value property. これは、最初に、LargeObjectインスタンスが作成されます。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

コンス トラクター、LargeObjectクラスは、コードの最後の主要セクションが含まれているメッセージが表示され、初期化中のスレッドの id を記録します。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. 完全なコード リストの最後に、プログラムからの出力が表示されます。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

注意

簡略化のために、この例では Lazy<T> のグローバル インスタンスを使用して、すべてのメソッドは static (Visual Basic の Shared) です。For simplicity, this example uses a global instance of Lazy<T>, and all the methods are static (Shared in Visual Basic). これらは、遅延初期化を使用するための要件ではありません。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
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<LargeObject>(InitLargeObject, true);
        'lazyLargeObject = new Lazy<LargeObject>(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
' 

注釈

遅延初期化を使用して、このような作成または実行は、プログラムの有効期間中に発生しない場合に特に、大規模またはリソースを消費するオブジェクトの作成や、リソースを消費するタスクの実行を延期します。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.

インスタンスを作成する遅延初期化の準備として、Lazy<T>します。To prepare for lazy initialization, you create an instance of Lazy<T>. 型引数、Lazy<T>を作成するオブジェクトを遅延初期化に使用オブジェクトの種類を指定します。The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. 使用して作成するコンス トラクター、Lazy<T>オブジェクトが初期化の特性を決定します。The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. 遅延初期化は、Lazy<T>.Value プロパティへの初回のアクセス時に発生します。Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

ほとんどの場合、コンス トラクターを選択することは、2 つの質問に対する回答に依存します。In most cases, choosing a constructor depends on your answers to two questions:

  • 遅れて初期化されるオブジェクトは、複数のスレッドからアクセスされるでしょうか。Will the lazily initialized object be accessed from more than one thread? そうである場合、Lazy<T>オブジェクトを使用するとすべてのスレッドで作成可能性があります。If so, the Lazy<T> object might create it on any thread. 既定の動作がスレッド セーフを作成するには単純なコンス トラクターのいずれかを使用することができますLazy<T>オブジェクト、それにアクセスしようとしているスレッドの数に関係なく遅延インスタンス化されたオブジェクトの 1 つのインスタンスが作成されます。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>スレッド セーフでないオブジェクトの場合は、スレッド セーフを含まないように指定することができるコンス トラクターを使用する必要があります。To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.

    注意事項

    作成、Lazy<T>遅れて初期化されるオブジェクトはスレッド セーフでオブジェクトは保護されません。Making the Lazy<T> object thread safe does not protect the lazily initialized object. 複数のスレッドが遅れて初期化されるオブジェクトにアクセスできる場合おく必要がありますプロパティとメソッドのアクセスをマルチ スレッド セーフです。If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • 遅延初期化は、多くのコードを必要または遅れて初期化されるオブジェクトが既定のコンス トラクターにする必要があるし、例外をスローせず、あらゆる操作を実行しますか。Does lazy initialization require a lot of code, or does the lazily initialized object have a default constructor that does everything you need and doesn't throw exceptions? 初期化コードを記述する必要がある場合、または例外を処理する必要がある場合は、ファクトリ メソッドを受け取るコンス トラクターのいずれかを使用します。If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. ファクトリ メソッドでは、初期化コードを記述します。Write your initialization code in the factory method.

これら 2 つの要因に基づいて選択するにはコンス トラクターを次の表に示します。The following table shows which constructor to choose, based on these two factors:

オブジェクトがアクセスします。Object will be accessed by 初期化コードが必要ない場合 (既定のコンス トラクター) を使用して、If no initialization code is required (default constructor), use 初期化コードが必要な場合は、使用します。If initialization code is required, use
複数のスレッドMultiple threads Lazy<T>() Lazy<T>(Func<T>)
1 つのスレッドOne thread Lazy<T>(Boolean) isThreadSafe設定falseします。Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean) isThreadSafe設定falseします。Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

ラムダ式を使用すると、ファクトリ メソッドを指定します。You can use a lambda expression to specify the factory method. これにより、1 か所ですべての初期化コードが保持されます。This keeps all the initialization code in one place. ラムダ式は、遅れて初期化されるオブジェクトのコンス トラクターに渡す引数も含めて、コンテキストをキャプチャします。The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

例外キャッシュファクトリ メソッドを使用する場合、例外がキャッシュされます。Exception caching When you use factory methods, exceptions are cached. つまり、ファクトリ メソッドが、例外の最初の時間をスローした場合、スレッドにアクセスしようと、Valueのプロパティ、Lazy<T>オブジェクトのすべての後続の試行で同じ例外がスローされます。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. これにより、すべての呼び出し、Valueプロパティは同じ結果に、別のスレッドが異なる結果を取得する場合に生じる可能性のある微妙なエラーを回避できます。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をそれ以外の場合は初期化されている以前の時点でスタートアップ中に通常します。The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. 以前の時点のエラーでは、通常は致命的です。A failure at that earlier point is usually fatal. 回復可能なエラーが発生する可能性がある場合は、遅延初期化を使用していない場合と同様、(この例では、ファクトリ メソッド) で初期化ルーチンに再試行ロジックを作成することをお勧めします。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.

ロックする代わりに特定の状況でのオーバーヘッドを回避する可能性があります、Lazy<T>オブジェクトの既定のロック動作します。Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. まれに、デッドロックの可能性があります。In rare situations, there might be a potential for deadlocks. このような場合は、使用することができます、Lazy<T>(LazyThreadSafetyMode)またはLazy<T>(Func<T>, LazyThreadSafetyMode)コンス トラクターを指定してLazyThreadSafetyMode.PublicationOnlyします。In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. これにより、 Lazy<T> 、スレッドを呼び出す場合、それぞれ複数のスレッドの遅れて初期化されるオブジェクトのコピーを作成するオブジェクト、Valueプロパティ同時にします。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>オブジェクトにより、すべてのスレッドが遅れて初期化されるオブジェクトの同じインスタンスを使用し、使用されていないインスタンスを破棄します。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. そのため、ロックのオーバーヘッドを軽減するのコストは、プログラムの作成し、負荷の高いオブジェクトの余分なコピーを破棄する場合がある場合がありますです。Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. ほとんどの場合でない可能性があります。In most cases, this is unlikely. 例では、Lazy<T>(LazyThreadSafetyMode)Lazy<T>(Func<T>, LazyThreadSafetyMode)コンス トラクターは、この動作を示します。The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

重要

指定するとLazyThreadSafetyMode.PublicationOnly、ファクトリ メソッドを指定した場合でも、例外はキャッシュされないされます。When you specify LazyThreadSafetyMode.PublicationOnly, exceptions are never cached, even if you specify a factory method.

同等のコンス トラクターの使用を有効にするだけでなくLazyThreadSafetyMode.PublicationOnlyLazy<T>(LazyThreadSafetyMode)Lazy<T>(Func<T>, LazyThreadSafetyMode)コンス トラクターは、他のコンス トラクターの機能を実現できます。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. 次の表では、同等の動作を生成するパラメーターの値を示します。The following table shows the parameter values that produce equivalent behavior.

作成する、Lazy<T>されるオブジェクトTo create a Lazy<T> object that is コンス トラクターを持つ、 LazyThreadSafetyMode modeパラメーター設定modeFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to ブール値を持つコンス トラクターのisThreadSafeパラメーター設定isThreadSafeFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to スレッド セーフ パラメーターなしのコンス トラクターFor constructors with no thread safety parameters
完全スレッド セーフであります。使用がロックを 1 つのスレッドが値を初期化することを確認します。Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true このようなすべてのコンス トラクターは、完全にスレッド セーフです。All such constructors are fully thread safe.
スレッド セーフでないです。Not thread safe. None false 該当なし。Not applicable.
完全スレッド セーフであります。値を初期化するためにスレッド競合します。Fully thread safe; threads race to initialize the value. PublicationOnly 該当なし。Not applicable. 該当なし。Not applicable.

その他の機能の使用についてはLazy<T>、スレッド内静的フィールドを持つ、またはプロパティのバッキング ストアとしてを参照してください。遅延初期化します。Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.

コンストラクター

Lazy<T>() Lazy<T>() Lazy<T>() Lazy<T>()

Lazy<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the Lazy<T> class. 遅延初期化が発生した場合、対象の型の既定のコンストラクターが使用されます。When lazy initialization occurs, the default constructor of the target type is used.

Lazy<T>(Boolean) Lazy<T>(Boolean) Lazy<T>(Boolean) Lazy<T>(Boolean)

Lazy<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the Lazy<T> class. 遅延初期化が発生した場合、対象の型の既定のコンストラクターと指定された初期化モードが使用されます。When lazy initialization occurs, the default constructor of the target type and the specified initialization mode are used.

Lazy<T>(Func<T>) Lazy<T>(Func<T>) Lazy<T>(Func<T>) Lazy<T>(Func<T>)

Lazy<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the Lazy<T> class. 遅延初期化が発生した場合、指定された初期化関数が使用されます。When lazy initialization occurs, the specified initialization function is used.

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

Lazy<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the Lazy<T> class. 遅延初期化が発生した場合、指定された初期化関数および初期化モードが使用されます。When lazy initialization occurs, the specified initialization function and initialization mode are used.

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

指定された初期化関数とスレッド セーフ モードを使用する Lazy<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the Lazy<T> class that uses the specified initialization function and thread-safety mode.

Lazy<T>(LazyThreadSafetyMode) Lazy<T>(LazyThreadSafetyMode) Lazy<T>(LazyThreadSafetyMode) Lazy<T>(LazyThreadSafetyMode)

T の既定のコンストラクターと指定されたスレッド セーフ モードを使用する Lazy<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the Lazy<T> class that uses the default constructor of T and the specified thread-safety mode.

Lazy<T>(T) Lazy<T>(T) Lazy<T>(T) Lazy<T>(T)

事前に初期化され、指定された値を使用する Lazy<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the Lazy<T> class that uses a preinitialized specified value.

プロパティ

IsValueCreated IsValueCreated IsValueCreated IsValueCreated

この Lazy<T> インスタンスに対して値が作成されているかどうかを示す値を取得します。Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value Value Value Value

現在の Lazy<T> インスタンスの遅延初期化された値を取得します。Gets the lazily initialized value of the current Lazy<T> instance.

メソッド

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

指定したオブジェクトが、現在のオブジェクトと等しいかどうかを判断します。Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

既定のハッシュ関数として機能します。Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

現在のインスタンスの Type を取得します。Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

現在の Object の簡易コピーを作成します。Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

このインスタンスの Value プロパティの文字列形式を作成して返します。Creates and returns a string representation of the Value property for this instance.

適用対象

スレッド セーフ

既定ですべてのパブリックおよびプロテクト メンバーのLazy<T>クラスはスレッド セーフであると、複数のスレッドから同時に使用される可能性があります。By default, all public and protected members of the Lazy<T> class are thread safe and may be used concurrently from multiple threads. これらのスレッド セーフの保証は、必要に応じて、型のコンス トラクターにパラメーターを使用して、インスタンスごとに削除できます。These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

こちらもご覧ください