SetData Método (LocalDataStoreSlot, Object)
Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Método Thread.SetData (LocalDataStoreSlot, Object)

 

Define os dados no slot especificado no thread em execução no momento, para o domínio atual do thread.Para melhor desempenho, use os campos marcados com o ThreadStaticAttribute atributo.

Namespace:   System.Threading
Assembly:  mscorlib (em mscorlib.dll)

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

Parâmetros

slot

O LocalDataStoreSlot no qual definir o valor.

data

O valor a ser configurado.

System_CAPS_importantImportante

O .NET Framework fornece dois mecanismos para usar o armazenamento local de thread (TLS): campos estáticos relativos a thread (ou seja, os campos marcados com o ThreadStaticAttribute atributo) e slots de dados.Campos estáticos relativos a thread fornecem melhor desempenho que slots de dados e habilitar a verificação de tipo de tempo de compilação.Para obter mais informações sobre como usar o TLS, consulte Thread Local Storage: Thread-Relative Static Fields and Data Slots.

Os threads usam um mecanismo de armazenamento local de memória para armazenar dados específicos de segmento.O common language runtime aloca uma matriz de armazenamento de dados de vários slots para cada processo quando ele é criado.O thread pode alocar um slot de dados no armazenamento de dados, armazenar e recuperar dados de um valor no slot e liberar o slot para reutilização após o término do procedimento de thread e o Thread objeto foi recuperado pela coleta de lixo.Slots de dados são exclusivos por thread.Nenhum outro thread (nem mesmo um thread filho) pode obter esses dados.

System_CAPS_noteObservação

SetData é um Shared método sempre se aplica ao thread em execução no momento, mesmo se você chamá-lo usando uma variável que faz referência a outro thread.Para evitar confusão, use o nome da classe ao chamar Shared métodos: Thread.SetData(testSlot, "test data").

Esta seção contém dois exemplos de código.O primeiro exemplo mostra como usar um campo é marcado com o ThreadStaticAttribute atributo para armazenar informações específicas de thread.O segundo exemplo mostra como usar um slot de dados para fazer a mesma coisa.

Primeiro exemplo

O exemplo a seguir mostra como usar um campo é marcado com ThreadStaticAttribute para armazenar informações específicas de thread.Essa técnica oferece um desempenho melhor que a técnica mostrada no segundo exemplo.

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 exemplo

O exemplo a seguir demonstra como usar um slot de dados chamado para armazenar informações específicas de thread.

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
Disponível desde 1.1
Retornar ao topo
Mostrar:
© 2016 Microsoft