Lazy<T> Clase

Definición

Proporciona compatibilidad con la inicialización diferida.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)

Parámetros de tipo

T

El tipo de objeto que se inicializa de forma diferida.The type of object that is being lazily initialized.

Herencia
Lazy<T>
Derivado
Atributos

Ejemplos

En el ejemplo siguiente se muestra el uso Lazy<T> de la clase para proporcionar una inicialización diferida con acceso desde varios subprocesos.The following example demonstrates the use of the Lazy<T> class to provide lazy initialization with access from multiple threads.

Nota

En el ejemplo se Lazy<T>(Func<T>) usa el constructor.The example uses the Lazy<T>(Func<T>) constructor. También se Lazy<T>(Func<T>, Boolean) muestra el uso del constructor ( true especificando para isThreadSafe) y el Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor (especificando LazyThreadSafetyMode.ExecutionAndPublication para 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). Para cambiar a un constructor diferente, solo tiene que cambiar qué constructores están comentados.To switch to a different constructor, just change which constructors are commented out.

Para obtener un ejemplo en el que se muestra el almacenamiento en caché de excepciones Lazy<T>(Func<T>) utilizando los mismos constructores, vea el constructor.For an example that demonstrates exception caching using the same constructors, see the Lazy<T>(Func<T>) constructor.

El ejemplo define una clase LargeObject que uno de varios subprocesos inicializará de forma diferida.The example defines a LargeObject class that will be initialized lazily by one of several threads. Las cuatro secciones clave del código muestran la creación del inicializador, el Factory Method, la inicialización real y el constructor de la LargeObject clase, que muestra un mensaje cuando se crea el objeto.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. Al principio del método Main, el ejemplo crea el inicializador diferido seguro para subprocesos para 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)

En el Factory Method se muestra la creación del objeto, con un marcador de posición para la inicialización posterior: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

Tenga en cuenta que las dos primeras secciones de código se pueden combinar con una función lambda, como se muestra aquí: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)

En el ejemplo se realiza una pausa para indicar que puede transcurrir un período indeterminado antes de que se produzca la inicialización diferida.The example pauses, to indicate that an indeterminate period may elapse before lazy initialization occurs. Al presionar la tecla entrar , en el ejemplo se crean e inician tres subprocesos.When you press the Enter key, the example creates and starts three threads. El ThreadProc método que usan los tres subprocesos llama a Value la propiedad.The ThreadProc method that's used by all three threads calls the Value property. La primera vez que esto ocurre, LargeObject se crea la instancia de: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

El constructor de la LargeObject clase, que incluye la última sección de clave del código, muestra un mensaje y registra la identidad del subproceso de inicialización.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. La salida del programa aparece al final de la lista de código completa.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

Nota

Por simplificar, en este ejemplo se emplea una instancia global de Lazy<T> y todos los métodos son static (Shared en Visual Basic).For simplicity, this example uses a global instance of Lazy<T>, and all the methods are static (Shared in Visual Basic). No son requisitos para el uso de la inicialización diferida.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
' 

Comentarios

Use la inicialización diferida para aplazar la creación de un objeto grande o con un gran número de recursos, o la ejecución de una tarea que consume muchos recursos, especialmente cuando tal creación o ejecución no se produzcan durante la vigencia del programa.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.

Para prepararse para la inicialización diferida, cree una Lazy<T>instancia de.To prepare for lazy initialization, you create an instance of Lazy<T>. El argumento de tipo del Lazy<T> objeto que cree especifica el tipo de objeto que desea inicializar de forma diferida.The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. El constructor que se utiliza para crear el Lazy<T> objeto determina las características de la inicialización.The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. La inicialización diferida se produce la primera vez que se accede a la propiedad Lazy<T>.Value.Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

En la mayoría de los casos, la elección de un constructor depende de las respuestas a dos preguntas:In most cases, choosing a constructor depends on your answers to two questions:

  • ¿Se puede tener acceso al objeto inicializado de forma diferida desde más de un subproceso?Will the lazily initialized object be accessed from more than one thread? Si es así, Lazy<T> el objeto podría crearlo en cualquier subproceso.If so, the Lazy<T> object might create it on any thread. Puede usar uno de los constructores simples cuyo comportamiento predeterminado es crear un objeto seguro Lazy<T> para subprocesos, de modo que solo se cree una instancia del objeto con instancias diferidas independientemente del número de subprocesos que intenten acceder a ella.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. Para crear un Lazy<T> objeto que no sea seguro para subprocesos, debe usar un constructor que le permita especificar sin seguridad para subprocesos.To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.

    Precaución

    Al convertir Lazy<T> el objeto en seguro para subprocesos no se protege el objeto inicializado de forma diferida.Making the Lazy<T> object thread safe does not protect the lazily initialized object. Si varios subprocesos pueden tener acceso al objeto inicializado de forma diferida, debe hacer que sus propiedades y métodos sean seguros para el acceso multiproceso.If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

  • ¿La inicialización diferida requiere una gran cantidad de código, o el objeto inicializado de forma diferida tiene un constructor sin parámetros que hace todo lo que necesita y no inicia excepciones?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? Si necesita escribir código de inicialización o si es necesario controlar las excepciones, use uno de los constructores que toma un Factory Method.If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. Escriba el código de inicialización en el Factory Method.Write your initialization code in the factory method.

En la tabla siguiente se muestra qué constructor elegir, en función de estos dos factores:The following table shows which constructor to choose, based on these two factors:

Tendrá acceso al objeto.Object will be accessed by Si no se requiere ningún código de inicialización (constructor sin parámetros), useIf no initialization code is required (parameterless constructor), use Si se requiere código de inicialización, useIf initialization code is required, use
Varios subprocesosMultiple threads Lazy<T>() Lazy<T>(Func<T>)
Un subprocesoOne thread Lazy<T>(Boolean)con isThreadSafe establecido en false.Lazy<T>(Boolean) with isThreadSafe set to false. Lazy<T>(Func<T>, Boolean)con isThreadSafe establecido en false.Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

Puede usar una expresión lambda para especificar el Factory Method.You can use a lambda expression to specify the factory method. Esto mantiene todo el código de inicialización en un solo lugar.This keeps all the initialization code in one place. La expresión lambda captura el contexto, incluidos los argumentos que se pasan al constructor del objeto inicializado de forma diferida.The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

Almacenamiento en caché de excepciones Cuando se usan métodos de generador, las excepciones se almacenan en caché.Exception caching When you use factory methods, exceptions are cached. Es decir, si el Factory Method produce una excepción la primera vez que un subproceso intenta tener acceso Value a la propiedad Lazy<T> del objeto, se produce la misma excepción en cada intento posterior.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. Esto garantiza que cada llamada a la Value propiedad produce el mismo resultado y evita errores sutiles que podrían surgir si distintos subprocesos obtienen resultados diferentes.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. Representa un real T que, de lo contrario, se habría inicializado en algún punto anterior, normalmente durante el inicio. Lazy<T>The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. Un error en ese punto anterior suele ser grave.A failure at that earlier point is usually fatal. Si se produce un error recuperable, se recomienda que cree la lógica de reintento en la rutina de inicialización (en este caso, el Factory Method), tal como lo haría si no usara la inicialización diferida.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.

Alternativa al bloqueo En determinadas situaciones, puede que desee evitar la sobrecarga del comportamiento de Lazy<T> bloqueo predeterminado del objeto.Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. En raras ocasiones, puede haber un riesgo para los interbloqueos.In rare situations, there might be a potential for deadlocks. En tales casos, puede usar el Lazy<T>(LazyThreadSafetyMode) constructor o Lazy<T>(Func<T>, LazyThreadSafetyMode) y especificar. LazyThreadSafetyMode.PublicationOnlyIn such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. Esto permite Lazy<T> al objeto crear una copia del objeto inicializado de forma diferida en cada uno de varios subprocesos si Value los subprocesos llaman a la propiedad simultáneamente.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. El Lazy<T> objeto garantiza que todos los subprocesos usan la misma instancia del objeto inicializado de forma diferida y descarta las instancias que no se usan.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. Por lo tanto, el costo de reducir la sobrecarga de bloqueo es que el programa podría crear y descartar copias adicionales de un objeto caro.Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. En la mayoría de los casos, esto es improbable.In most cases, this is unlikely. En los ejemplos de Lazy<T>(LazyThreadSafetyMode) los Lazy<T>(Func<T>, LazyThreadSafetyMode) constructores y se muestra este comportamiento.The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.

Importante

Cuando se especifica LazyThreadSafetyMode.PublicationOnly, las excepciones nunca se almacenan en caché, incluso si se especifica un Factory Method.When you specify LazyThreadSafetyMode.PublicationOnly, exceptions are never cached, even if you specify a factory method.

Constructores equivalentes Además de habilitar el uso de LazyThreadSafetyMode.PublicationOnly, los Lazy<T>(LazyThreadSafetyMode) constructores Lazy<T>(Func<T>, LazyThreadSafetyMode) y pueden duplicar la funcionalidad de los demás constructores.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. En la tabla siguiente se muestran los valores de parámetro que producen un comportamiento equivalente.The following table shows the parameter values that produce equivalent behavior.

Para crear un Lazy<T> objeto que seaTo create a Lazy<T> object that is Para los constructores que tienen LazyThreadSafetyMode un mode parámetro, mode establezca enFor constructors that have a LazyThreadSafetyMode mode parameter, set mode to Para los constructores que tienen un isThreadSafe parámetro booleano, isThreadSafe establezca enFor constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to Para constructores sin parámetros de seguridad para subprocesosFor constructors with no thread safety parameters
Totalmente seguro para subprocesos; utiliza el bloqueo para asegurarse de que solo un subproceso inicializa el valor.Fully thread safe; uses locking to ensure that only one thread initializes the value. ExecutionAndPublication true Todos estos constructores son totalmente seguros para subprocesos.All such constructors are fully thread safe.
No es seguro para subprocesos.Not thread safe. None false No es aplicable.Not applicable.
Totalmente seguro para subprocesos; los subprocesos corazaan para inicializar el valor.Fully thread safe; threads race to initialize the value. PublicationOnly No es aplicable.Not applicable. No es aplicable.Not applicable.

Otras funcionalidades Para obtener información sobre el uso Lazy<T> de con campos estáticos de subproceso o como memoria auxiliar para las propiedades, consulte inicialización diferida.Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.

Constructores

Lazy<T>()

Inicializa una nueva instancia de la clase Lazy<T>.Initializes a new instance of the Lazy<T> class. Cuando se produce la inicialización diferida, se usa el constructor sin parámetros del tipo de destino.When lazy initialization occurs, the parameterless constructor of the target type is used.

Lazy<T>(Boolean)

Inicializa una nueva instancia de la clase Lazy<T>.Initializes a new instance of the Lazy<T> class. Cuando se produce la inicialización diferida, se usan el constructor sin parámetros del tipo de destino y el modo de inicialización especificado.When lazy initialization occurs, the parameterless constructor of the target type and the specified initialization mode are used.

Lazy<T>(Func<T>)

Inicializa una nueva instancia de la clase Lazy<T>.Initializes a new instance of the Lazy<T> class. Cuando se produce la inicialización diferida, se usa la función de inicialización especificada.When lazy initialization occurs, the specified initialization function is used.

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

Inicializa una nueva instancia de la clase Lazy<T>.Initializes a new instance of the Lazy<T> class. Cuando se produce la inicialización diferida, se usan la función de inicialización y el modo de inicialización especificados.When lazy initialization occurs, the specified initialization function and initialization mode are used.

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

Inicializa una nueva instancia de la clase Lazy<T> que utiliza la función de inicialización y el modo de seguridad para subprocesos especificados.Initializes a new instance of the Lazy<T> class that uses the specified initialization function and thread-safety mode.

Lazy<T>(LazyThreadSafetyMode)

Inicializa una nueva instancia de la clase Lazy<T> que usa el constructor sin parámetros de T y el modo de seguridad para subprocesos especificado.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)

Inicializa una nueva instancia de la clase Lazy<T> que usa un valor especificado preinicializado.Initializes a new instance of the Lazy<T> class that uses a preinitialized specified value.

Propiedades

IsValueCreated

Obtiene un valor que indica si se ha creado un valor para esta instancia de Lazy<T>.Gets a value that indicates whether a value has been created for this Lazy<T> instance.

Value

Obtiene el valor inicializado de forma diferida de la instancia actual de Lazy<T>.Gets the lazily initialized value of the current Lazy<T> instance.

Métodos

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
ToString()

Crea y devuelve una representación de cadena de la propiedad Value de esta instancia.Creates and returns a string representation of the Value property for this instance.

Se aplica a

Seguridad para subprocesos

De forma predeterminada, todos los miembros públicos y protegidos Lazy<T> de la clase son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos.By default, all public and protected members of the Lazy<T> class are thread safe and may be used concurrently from multiple threads. Estas garantías de seguridad para subprocesos se pueden quitar opcionalmente y por instancia, mediante los parámetros de los constructores del tipo.These thread-safety guarantees may be removed optionally and per instance, using parameters to the type's constructors.

Consulte también: