Escrevendo para uma caixa de texto usando dois tópicos

Question

Eu tenho algum problema não resolvido com threads. É a minha primeira vez fazendo isso. Eu sei como usar um segmento para gravação em uma caixa de texto, mas não tenho idéia de como usar dois deles para fazer o trabalho. Alguém tem uma idéia do que eu tenho que fazer para ser capaz de usar dois tópicos para escrever para o mesmo caixa de texto, mas não no mesmo tempo. Obrigado.

Answer 1

Aqui está um exemplo que usa dois tópicos para escrever números aleatórios para uma caixa de texto multi-line. Como Brandon e Jon B observou, você precisa usar Invoke () para serializar as chamadas para o segmento GUI.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    Random m_random = new Random((int)DateTime.Now.Ticks);
    ManualResetEvent m_stopThreadsEvent = new ManualResetEvent(false);

    private void buttonStart_Click(object sender, EventArgs e)
    {
        Thread t1 = new Thread(new ThreadStart(ThreadOne));
        Thread t2 = new Thread(new ThreadStart(ThreadTwo));

        t1.Start();
        t2.Start();
    }

    private void ThreadOne()
    {
        for(;;)
        {
            int n = m_random.Next(1000);
            AppendText(String.Format("One: {0}\r\n", n));
            if(m_stopThreadsEvent.WaitOne(n))
            {
                break;
            }
        }
    }

    private void ThreadTwo()
    {
        for(;;)
        {
            int n = m_random.Next(1000);
            AppendText(String.Format("Two: {0}\r\n", n));
            if(m_stopThreadsEvent.WaitOne(n))
            {
                break;
            }
        }
    }

    delegate void AppendTextDelegate(string text);

    private void AppendText(string text)
    {
        if(textBoxLog.InvokeRequired)
        {
            textBoxLog.Invoke(new AppendTextDelegate(this.AppendText), new object[] { text });
        }
        else
        {
            textBoxLog.Text = textBoxLog.Text += text;
        }
    }

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        m_stopThreadsEvent.Set();
    }
}

Answer 2

Outra opção é usar um método de retorno de chamada Thread. Este é um método que existe no segmento principal, mas ao criar um novo segmento que você passar um identificador / referência a este método. Isso permite que o segundo segmento para chamar o método no thread principal e a funcionalidade para atualizar / verificar a caixa de texto ia sentar lá.

Olhe para passar delegados entre segmentos.

Answer 3

Uma opção que você poderia fazer, é mensagens de envio para um objeto Fila e usar um temporizador nas janelas formar para ler mensagens dessa fila e escrever para a caixa de texto.

A fim de fazer tudo de bom e threadsage você poderia bloquear o objeto da fila quando ler e escrever para ele.

Por exemplo:

    private Queue<string> messages = new Queue<string>();

    /// <summary>
    /// Add Message To The Queue
    /// </summary>
    /// <param name="text"></param>
    public void NewMessage(string text)
    {
        lock (messages)
        {
            messages.Enqueue(text);
        }
    }

    private void tmr_Tick(object sender, EventArgs e)
    {
        if (messages.Count == 0) return;
        lock (messages)
        {
            this.textBox.Text += Environment.NewLine + messages;
        }
    }

Answer 4

abordagem mais segura é só para ter um fio de ser capaz de trabalhar na caixa de texto (ou qualquer objeto gui), tem quaisquer outros tópicos que precisam executar uma ação na caixa de texto comunicar suas necessidades para o segmento que controla o texto caixa.

para que a sua questão torna-se como se comunicar entre threads, isso vai ser específico language / OS, então você precisa fornecer mais informações.

Answer 5

Este MSDN artigo explica como fazer rosca chamadas seguras para janelas controles de formulário.

Answer 6

Você só pode componentes GUI de acesso do thread principal. Para escrever para uma caixa de texto de outro segmento, você precisa usar BeginInvoke () .