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)コンストラクター (の場合isThreadSafeはを指定true ) とLazy<T>(Func<T>, LazyThreadSafetyMode)コンストラクター ( LazyThreadSafetyMode.ExecutionAndPublicationの場合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). 別のコンストラクターに切り替えるには、コメントアウトするコンストラクターを変更するだけです。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(Of LargeObject)(AddressOf InitLargeObject, True)
'lazyLargeObject = New Lazy(Of LargeObject)(AddressOf 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. 3 ThreadProcつのすべてのスレッドで使用されるメソッド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(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
' 

注釈

遅延初期化を使用すると、大量またはリソースを消費するオブジェクトの作成や、リソースを集中的に使用するタスクの実行を遅らせることができます。特に、プログラムの有効期間中にこのような作成や実行が行われない場合があります。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つを使用できます。これにより、遅延インスタンス化されたオブジェクトの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 parameterless 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 (parameterless constructor), use 初期化コードが必要な場合は、を使用します。If initialization code is required, use
複数のスレッドMultiple threads Lazy<T>() Lazy<T>(Func<T>)
1つのスレッドOne thread Lazy<T>(Boolean)isThreadSafefalse設定された。Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean)isThreadSafefalse設定された。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.

同等のコンストラクターLazy<T>(LazyThreadSafetyMode) LazyThreadSafetyMode.PublicationOnlyおよび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パラメーターを持つコンストラクターの場合、 isThreadSafeをに設定します。For 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 parameterless 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 parameterless 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 parameterless 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.

こちらもご覧ください