Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Thread.GetData (LocalDataStoreSlot)

 

Publicado: octubre de 2016

Recupera el valor de la ranura especificada en el subproceso actual, dentro del dominio actual del subproceso. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.

Espacio de nombres:   System.Threading
Ensamblado:  mscorlib (en mscorlib.dll)

[HostProtectionAttribute(SecurityAction.LinkDemand, SharedState = true, 
	ExternalThreading = true)]
public static object GetData(
	LocalDataStoreSlot slot
)

Parámetros

slot
Type: System.LocalDataStoreSlot

La LocalDataStoreSlot de donde se va a obtener el valor.

Valor devuelto

Type: System.Object

El valor recuperado.

System_CAPS_importantImportante

.NET Framework proporciona dos mecanismos para usar el almacenamiento local de subprocesos (TLS): campos estáticos relacionados con subprocesos (es decir, los campos marcados con el ThreadStaticAttribute atributo) y ranuras de datos. Los campos estáticos relacionados con subprocesos proporcionan un rendimiento mucho mejor que las ranuras de datos y habilitar la comprobación de tipo en tiempo de compilación. Para obtener más información sobre el uso de TLS, consulte Thread Local Storage: Thread-Relative Static Fields and Data Slots.

Subprocesos utilizan un mecanismo de memoria de almacenamiento local para almacenar datos específicos del subproceso. Common language runtime asigna una matriz de almacenamiento de datos de varias ranuras a cada proceso cuando se crea. El subproceso puede asignar una ranura de datos del almacén de datos, almacenar y recuperar datos de un valor en la ranura y liberar la ranura para reutilizarlo cuando el subproceso finalice. Las ranuras de datos son únicas para cada subproceso. Ningún otro subproceso (ni siquiera un subproceso secundario) puede obtener esos datos.

System_CAPS_noteNota

GetData es un Shared (método) que se aplica siempre al subproceso actualmente en ejecución, incluso si la llamada se utiliza una variable que hace referencia a otro subproceso. Para evitar confusiones, utilice el nombre de clase al llamar a Shared métodos: Dim test As Object = Thread.GetData(testSlot).

Esta sección contiene dos ejemplos de código. El primer ejemplo muestra cómo utilizar un campo que se marca con el ThreadStaticAttribute atributo para almacenar información específica de subprocesos. El segundo ejemplo muestra cómo usar una ranura de datos para hacer lo mismo.

Primer ejemplo

En el ejemplo siguiente se muestra cómo utilizar un campo que se marca con ThreadStaticAttribute para almacenar información específica de subprocesos. Esta técnica proporciona mejor rendimiento que la técnica que se muestra en el segundo ejemplo.

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        for(int i = 0; i < 3; i++)
        {
            Thread newThread = new Thread(ThreadData.ThreadStaticDemo);
            newThread.Start();
        }
    }
}

class ThreadData
{
    [ThreadStaticAttribute]
    static int threadSpecificData;

    public static void ThreadStaticDemo()
    {
        // Store the managed thread id for each thread in the static
        // variable.
        threadSpecificData = Thread.CurrentThread.ManagedThreadId;

        // Allow other threads time to execute the same code, to show
        // that the static data is unique to each thread.
        Thread.Sleep( 1000 );

        // Display the static data.
        Console.WriteLine( "Data for managed thread {0}: {1}", 
            Thread.CurrentThread.ManagedThreadId, threadSpecificData );
    }
}

/* This code example produces output similar to the following:

Data for managed thread 4: 4
Data for managed thread 5: 5
Data for managed thread 3: 3
 */

Segundo ejemplo

En el ejemplo siguiente se muestra cómo usar una ranura de datos para almacenar información específica del subproceso.

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        Thread[] newThreads = new Thread[4];
        for(int i = 0; i < newThreads.Length; i++)
        {
            newThreads[i] = new Thread(
                new ThreadStart(Slot.SlotTest));
            newThreads[i].Start();
        }
    }
}

class Slot
{
    static Random randomGenerator;
    static LocalDataStoreSlot localSlot;

    static Slot()
    {
        randomGenerator = new Random();
        localSlot = Thread.AllocateDataSlot();
    }

    public static void SlotTest()
    {
        // Set different data in each thread's data slot.
        Thread.SetData(localSlot, randomGenerator.Next(1, 200));

        // Write the data from each thread's data slot.
        Console.WriteLine("Data in thread_{0}'s data slot: {1,3}", 
            AppDomain.GetCurrentThreadId().ToString(),
            Thread.GetData(localSlot).ToString());

        // Allow other threads time to execute SetData to show
        // that a thread's data slot is unique to the thread.
        Thread.Sleep(1000);

        Console.WriteLine("Data in thread_{0}'s data slot: {1,3}", 
            AppDomain.GetCurrentThreadId().ToString(),
            Thread.GetData(localSlot).ToString());
    }
}

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: