Lazy<T> 클래스

정의

초기화 지연에 대한 지원을 제공합니다.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

초기화 지연할 개체의 형식입니다.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) 생성자 ( true 에 지정 isThreadSafe ) 및 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 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 ( Shared Visual Basic)입니다.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 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. 그러면 모든 초기화 코드가 한 곳에 보관 됩니다.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. 즉, 스레드가 개체의 속성에 처음으로 액세스 하려고 할 때 팩터리 메서드가 예외를 throw 하는 경우 Value Lazy<T> 모든 후속 시도에서 동일한 예외가 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. 이렇게 하면 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.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.

적용 대상

스레드 보안

기본적으로 클래스의 모든 public 및 protected 멤버 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.

추가 정보