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.SetData (LocalDataStoreSlot, Object)

 

Publicado: octubre de 2016

Establece los datos de la ranura especificada en el subproceso actualmente en ejecución, para el dominio actual de dicho subproceso. Para obtener un mejor rendimiento, utilice en su lugar los 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 void SetData(
	LocalDataStoreSlot slot,
	object data
)

Parámetros

slot
Type: System.LocalDataStoreSlot

La LocalDataStoreSlot donde se va a establecer el valor.

data
Type: System.Object

Valor que se va a establecer.

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 volver a utilizar una vez finalizado el procedimiento de subproceso y el Thread objeto ha sido reclamado por la recolección de elementos. 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

SetData 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: Thread.SetData(testSlot, "test data").

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
{
    public static void Main()
    {
        Thread[] newThreads = new Thread[4];
        int i;
        for (i = 0; i < newThreads.Length; i++)
        {
            newThreads[i] =
                new Thread(new ThreadStart(Slot.SlotTest));
            newThreads[i].Start();
        }
        Thread.Sleep(2000);
        for (i = 0; i < newThreads.Length; i++)
        {
            newThreads[i].Join();
            Console.WriteLine("Thread_{0} finished.",
                newThreads[i].ManagedThreadId);
        }
    }
}

class Slot
{
    private static Random randomGenerator = new Random();

    public static void SlotTest()
    {
        // Set random data in each thread's data slot.
        int slotData = randomGenerator.Next(1, 200);
        int threadId = Thread.CurrentThread.ManagedThreadId;

        Thread.SetData(
            Thread.GetNamedDataSlot("Random"),
            slotData);

        // Show what was saved in the thread's data slot.
        Console.WriteLine("Data stored in thread_{0}'s data slot: {1,3}",
            threadId, slotData);

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

        int newSlotData =
            (int)Thread.GetData(Thread.GetNamedDataSlot("Random"));

        if (newSlotData == slotData)
        {
            Console.WriteLine("Data in thread_{0}'s data slot is still: {1,3}",
                threadId, newSlotData);
        }
        else
        {
            Console.WriteLine("Data in thread_{0}'s data slot changed to: {1,3}",
                threadId, newSlotData);
        }
    }
}

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: