Como executo um pequeno pedaço de código em um novo thread?

Eu tenho um pouco de código que preciso executar em um thread diferente da GUI, pois atualmente faz com que o formulário congele enquanto o código é executado (10 segundos ou mais).

Suponha que eu nunca criei um novo segmento antes; o que é um exemplo simples / básico de como fazer isso em C # e usando o .NET Framework 2.0 ou posterior?

Um bom lugar para começar a ler é Joe Albahari .

Se você deseja criar seu próprio encadeamento, é o mais simples possível:

using System.Threading;
new Thread(() => 
{
    Thread.CurrentThread.IsBackground = true; 
    /* run your code here */ 
    Console.WriteLine("Hello, world"); 
}).Start();

BackgroundWorker parece ser a melhor escolha para você.

Aqui está o meu exemplo mínimo. Depois de clicar no botão, o trabalhador em segundo plano começará a trabalhar no encadeamento em segundo plano e também relatará seu progresso simultaneamente. Também será relatado após a conclusão do trabalho.

using System.ComponentModel;
...
    private void button1_Click(object sender, EventArgs e)
    {
        BackgroundWorker bw = new BackgroundWorker();

        // this allows our worker to report progress during work
        bw.WorkerReportsProgress = true;

        // what to do in the background thread
        bw.DoWork += new DoWorkEventHandler(
        delegate(object o, DoWorkEventArgs args)
        {
            BackgroundWorker b = o as BackgroundWorker;

            // do some simple processing for 10 seconds
            for (int i = 1; i <= 10; i++)
            {
                // report the progress in percent
                b.ReportProgress(i * 10);
                Thread.Sleep(1000);
            }

        });

        // what to do when progress changed (update the progress bar for example)
        bw.ProgressChanged += new ProgressChangedEventHandler(
        delegate(object o, ProgressChangedEventArgs args)
        {
            label1.Text = string.Format("{0}% Completed", args.ProgressPercentage);
        });

        // what to do when worker completes its task (notify the user)
        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
        delegate(object o, RunWorkerCompletedEventArgs args)
        {
            label1.Text = "Finished!";
        });

        bw.RunWorkerAsync();
    }

Nota:

• Coloquei tudo no método único usando o método anônimo do C # para simplificar, mas você sempre pode utilizá-los em métodos diferentes.
• É seguro atualizar a GUI dentro ProgressChangedou nos RunWorkerCompletedmanipuladores. No entanto, atualizar a GUI de DoWork causará InvalidOperationException.

O ThreadPool.QueueUserWorkItem é bastante ideal para algo simples. A única ressalva é acessar um controle do outro segmento.

System.Threading.ThreadPool.QueueUserWorkItem(delegate {
    DoSomethingThatDoesntInvolveAControl();
}, null);

Rápido e sujo, mas funcionará:

Usando no topo:

using System.Threading;

código simples:

static void Main( string[] args )
{
    Thread t = new Thread( NewThread );
    t.Start();
}

static void NewThread()
{
    //code goes here
}

Acabei de jogar isso em um novo aplicativo de console para um exemplo

Aqui está outra opção:

Task.Run(()=>{
//Here is a new thread
});

Tente usar a classe BackgroundWorker . Você fornece delegados para o que executar e para ser notificado quando o trabalho terminar. Há um exemplo na página do MSDN ao qual vinculei.

Se você deseja obter um valor:

var someValue;

Thread thread = new Thread(delegate()
            {                 
                //Do somthing and set your value
                someValue = "Hello World";
            });

thread.Start();

while (thread.IsAlive)
  Application.DoEvents();

Coloque esse código em uma função (o código que não pode ser executado no mesmo encadeamento que a GUI) e, para acionar a execução desse código, coloque o seguinte.

Thread myThread= new Thread(nameOfFunction);

workerThread.Start();

Chamar a função de início no objeto de encadeamento causará a execução da sua chamada de função em um novo encadeamento.

Aqui, como usar threads com um progressBar, é apenas para sublinhar como os threads funcionam, no formulário há três botões progressBar e 4:

 public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
    Thread t, t2, t3;
    private void Form1_Load(object sender, EventArgs e)
    {

        CheckForIllegalCrossThreadCalls = false;

         t = new Thread(birinicBar); //evry thread workes with a new progressBar


         t2 = new Thread(ikinciBar);


         t3 = new Thread(ucuncuBar);

    }

    public void birinicBar() //to make progressBar work
    {
        for (int i = 0; i < 100; i++) {
            progressBar1.Value++;
            Thread.Sleep(100); // this progressBar gonna work faster
        }
    }

    public void ikinciBar()
    {
        for (int i = 0; i < 100; i++)
        {
            progressBar2.Value++;
            Thread.Sleep(200);
        }


    }

    public void ucuncuBar()
    {
        for (int i = 0; i < 100; i++)
        {
            progressBar3.Value++;
            Thread.Sleep(300);
        }
    }

    private void button1_Click(object sender, EventArgs e) //that button to start the threads
    {
        t.Start();
        t2.Start(); t3.Start();

    }

    private void button4_Click(object sender, EventArgs e)//that button to stup the threads with the progressBar
    {
        t.Suspend();
        t2.Suspend();
        t3.Suspend();
    }

    private void button2_Click(object sender, EventArgs e)// that is for contuniue after stuping
    {
        t.Resume();
        t2.Resume();
        t3.Resume();
    }

    private void button3_Click(object sender, EventArgs e) // finally with that button you can remove all of the threads
    {
        t.Abort();
        t2.Abort();
        t3.Abort();
    }
}

// following declaration of delegate ,,,
public delegate long GetEnergyUsageDelegate(DateTime lastRunTime, 
                                            DateTime procDateTime);

// following inside of some client method
GetEnergyUsageDelegate nrgDel = GetEnergyUsage;
IAsyncResult aR = nrgDel.BeginInvoke(lastRunTime, procDT, null, null);
while (!aR.IsCompleted) Thread.Sleep(500);
int usageCnt = nrgDel.EndInvoke(aR);

Charles, seu código (acima) não está correto. Você não precisa girar a espera para concluir. EndInvoke bloqueará até que o WaitHandle seja sinalizado.

Se você deseja bloquear até a conclusão, basta

nrgDel.EndInvoke(nrgDel.BeginInvoke(lastRuntime,procDT,null,null));

ou alternativamente

ar.AsyncWaitHandle.WaitOne();

Mas qual é o sentido de emitir chamadas anyc se você bloquear? Você também pode usar uma chamada síncrona. Uma aposta melhor seria não bloquear e passar um lambda para limpeza:

nrgDel.BeginInvoke(lastRuntime,procDT,(ar)=> {ar.EndInvoke(ar);},null);

Uma coisa a ter em mente é que você deve ligar para o EndInvoke. Muitas pessoas esquecem isso e acabam vazando o WaitHandle, pois a maioria das implementações assíncronas libera o handhandle no EndInvoke.

Se você for usar o objeto Thread bruto, precisará configurar o IsBackground como true no mínimo e também definir o modelo Threading Apartment (provavelmente STA).

public static void DoWork()
{
    // do some work
}

public static void StartWorker()
{
    Thread worker = new Thread(DoWork);
    worker.IsBackground = true;
    worker.SetApartmentState(System.Threading.ApartmentState.STA);
    worker.Start()
}

Eu recomendaria a classe BackgroundWorker se você precisar de interação da interface do usuário.

outra opção, que usa delegados e o Pool de threads ...

assumindo 'GetEnergyUsage' é um método que usa um DateTime e outro DateTime como argumentos de entrada e retorna um Int ...

// following declaration of delegate ,,,
public delegate long GetEnergyUsageDelegate(DateTime lastRunTime, 
                                            DateTime procDateTime);

// following inside of some client method 
GetEnergyUsageDelegate nrgDel = GetEnergyUsage;                     
IAsyncResult aR = nrgDel.BeginInvoke(lastRunTime, procDT, null, null);
while (!aR.IsCompleted) Thread.Sleep(500);
int usageCnt = nrgDel.EndInvoke(aR);

Existem várias maneiras de executar threads separados no .Net, cada um com comportamentos diferentes. Você precisa continuar executando o encadeamento após o encerramento da GUI? Você precisa passar informações entre o thread e a GUI? O thread precisa atualizar a GUI? O encadeamento deve executar uma tarefa e encerrar ou deve continuar em execução? As respostas a essas perguntas lhe dirão qual método usar.

Há um bom artigo sobre método assíncrono no site do Code Project que descreve os vários métodos e fornece código de exemplo.

Observe que este artigo foi escrito antes da introdução do padrão async / waitit e da Task Parallel Library no .NET.

Como usar um segmento de plano de fundo para procurar arquivos

Você precisa ter muito cuidado com o acesso de outros threads a coisas específicas da GUI (é comum em muitos kits de ferramentas da GUI). Se você deseja atualizar algo na GUI a partir do processamento do thread, verifique esta resposta que eu acho útil para o WinForms. Para o WPF, veja isso (mostra como tocar o componente no método UpdateProgress () para funcionar com outros threads, mas, na verdade, eu não gosto que isso não esteja ocorrendo CheckAccess()antes do BeginInvokeDispathcer, consulte e procure o CheckAccess nele)

Estava procurando um livro específico do .NET sobre encadeamento e encontrou este (disponível para download gratuito). Consulte http://www.albahari.com/threading/ para obter mais detalhes.

Acredito que você encontrará o que precisa para iniciar a execução como novo encadeamento nas primeiras 20 páginas e tem muito mais (não tenho certeza sobre trechos específicos da GUI, quero dizer estritamente específicos ao encadeamento). Ficaria feliz em ouvir o que a comunidade pensa sobre este trabalho, porque eu estou lendo este. Por enquanto, parecia bem legal para mim (por mostrar métodos e tipos específicos do .NET para threading). Também abrange o .NET 2.0 (e não o antigo 1.1) o que eu realmente aprecio.

Eu recomendo consultar a Power Threading Library de Jeff Richter e, especificamente, o IAsyncEnumerator. Dê uma olhada no vídeo de Charlie Calvert blog de onde Richter o para uma boa visão geral.

Não se deixe levar pelo nome, porque isso facilita a codificação das tarefas de programação assíncrona.