Lazy<T> 클래스

정의

초기화 지연에 대한 지원을 제공합니다.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> 클래스를 사용 하 여 여러 스레드에서의 액세스에 지연 초기화를 제공 하는 방법을 보여 줍니다.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) 생성자 (isThreadSafetrue 지정) 및 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.

이 예제에서는 여러 스레드 중 하나에서 지연 하 여 초기화 되는 LargeObject 클래스를 정의 합니다.The example defines a LargeObject class that will be initialized lazily by one of several threads. 코드의 네 가지 주요 섹션에서는 개체를 만들 때 메시지를 표시 하는 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

처음 두 코드 섹션에서는 다음과 같이 람다 함수를 사용 하 여 결합할 수 없습니다 note: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 키를 누르면이 예제에서는 세 개의 스레드를 만들고 시작 합니다.When you press the Enter key, the example creates and starts three threads. 세 스레드 모두에 사용 되는 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.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.

대부분의 경우에서이 두 질문에 답변에 따라 달라 집니다 생성자를 선택 합니다.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> 개체를 만들 수 있습니다. 따라서 지연 되는 개체의 인스턴스 중 하나는 액세스를 시도 하는 스레드 수에 관계 없이 생성 됩니다.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.

  • 초기화 지연에 많은 코드가 필요 하거나, 지연 초기화 된 개체에는 필요한 모든 작업을 수행 하 고 예외를 throw 하지 않는 매개 변수가 없는 생성자가 있습니다.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.

다음 표에서 이러한 두 가지 요인에 기반을 선택 하는 생성자를 보여 줍니다.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>)
스레드 하나One thread false로 설정 된 isThreadSafeLazy<T>(Boolean) 합니다.Lazy<T>(Boolean) with isThreadSafe set to false. false로 설정 된 isThreadSafeLazy<T>(Func<T>, Boolean) 합니다.Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

팩터리 메서드를 지정 하는 람다 식을 사용할 수 있습니다.You can use a lambda expression to specify the factory method. 이렇게 하면 한 곳에서 모든 초기화 코드가 있습니다.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. 즉, 스레드가 Lazy<T> 개체의 Value 속성에 처음으로 액세스 하려고 할 때 팩터리 메서드가 예외를 throw 하는 경우 모든 후속 시도에서 동일한 예외가 throw 됩니다.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. 이렇게 하면 스레드가 Value 속성을 동시에 호출 하는 경우 Lazy<T> 개체가 여러 스레드 각각에 대해 지연 초기화 된 개체의 복사본을 만들 수 있습니다.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.PublicationOnly사용을 사용 하도록 설정 하는 것 외에도 Lazy<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 매개 변수가 있는 생성자의 경우 mode를로 설정 합니다.For 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
완벽 하 게 스레드로부터 안전 합니다. 해당 스레드가 하나만 있도록 잠금을 사용 하 여 값을 초기화 합니다.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> 클래스의 새 인스턴스를 초기화합니다.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> 클래스의 새 인스턴스를 초기화합니다.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> 클래스의 새 인스턴스를 초기화합니다.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> 클래스의 새 인스턴스를 초기화합니다.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> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Lazy<T> class that uses the specified initialization function and thread-safety mode.

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> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Lazy<T> class that uses a preinitialized specified value.

속성

IsValueCreated

값이 이 Lazy<T> 인스턴스에 대해 만들어졌는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value

현재 Lazy<T> 인스턴스의 초기화 지연된 값을 가져옵니다.Gets the lazily initialized value of the current Lazy<T> instance.

메서드

Equals(Object)

지정한 개체가 현재 개체와 같은지를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
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.

추가 정보