Como atualizar GUI com backgroundworker?

Eu passei o dia inteiro tentando fazer meu aplicativo usar threads, mas sem sorte. Eu li muita documentação sobre isso e ainda recebo muitos erros, então espero que você possa me ajudar.

Eu tenho um grande método demorado que chama o database e atualiza a GUI. Isso tem que acontecer o tempo todo (ou a cada 30 segundos).

public class UpdateController { private UserController _userController; public UpdateController(LoginController loginController, UserController userController) { _userController = userController; loginController.LoginEvent += Update; } public void Update() { BackgroundWorker backgroundWorker = new BackgroundWorker(); while(true) { backgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork); backgroundWorker.RunWorkerAsync(); } } public void backgroundWorker_DoWork(object sender, DoWorkEventArgs e) { _userController.UpdateUsersOnMap(); } } 

Com esta abordagem eu recebo uma exceção porque o backgroundworker não é e STA thread (mas pelo que eu posso entender é isso que eu deveria usar). Eu tentei com um thread STA e que deu outros erros.

Eu acho que o problema é porque eu tento atualizar a GUI ao fazer a chamada de database (no segmento de fundo). Eu só deveria estar fazendo a chamada do database e, em seguida, de alguma forma, ele deve voltar para o thread principal. Depois que o thread principal é executado, ele deve voltar para o thread de segundo plano e assim por diante. Mas não consigo ver como fazer isso.

O aplicativo deve atualizar a GUI logo após a chamada do database. Firering events parecem não funcionar. O backgroundthread apenas entra neles.

EDITAR:

Algumas ótimas respostas 🙂 Este é o novo código:

 public class UpdateController{ private UserController _userController; private BackgroundWorker _backgroundWorker; public UpdateController(LoginController loginController, UserController userController) { _userController = userController; loginController.LoginEvent += Update; _backgroundWorker = new BackgroundWorker(); _backgroundWorker.DoWork += backgroundWorker_DoWork; _backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted; } public void _backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) { _userController.UpdateUsersOnMap(); } public void Update() { _backgroundWorker.RunWorkerAsync(); } void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { //UI update System.Threading.Thread.Sleep(10000); Update(); } public void backgroundWorker_DoWork(object sender, DoWorkEventArgs e) { // Big database task } 

}

Mas como posso fazer isso a cada 10 segundos? System.Threading.Thread.Sleep (10000) apenas fará meu congelamento de GUI e while (true) loop em Update () como sugerido dá uma exceção (Thread muito ocupado).

Você precisa declarar e configurar o BackgroundWorker uma vez – depois Invocar o método RunWorkerAsync em seu loop …

 public class UpdateController { private UserController _userController; private BackgroundWorker _backgroundWorker; public UpdateController(LoginController loginController, UserController userController) { _userController = userController; loginController.LoginEvent += Update; _backgroundWorker = new BackgroundWorker(); _backgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork); _backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged); _backgroundWorker.WorkerReportsProgress= true; } public void Update() { _backgroundWorker.RunWorkerAsync(); } public void backgroundWorker_DoWork(object sender, DoWorkEventArgs e) { while (true) { // Do the long-duration work here, and optionally // send the update back to the UI thread... int p = 0;// set your progress if appropriate object param = "something"; // use this to pass any additional parameter back to the UI _backgroundWorker.ReportProgress(p, param); } } // This event handler updates the UI private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) { // Update the UI here // _userController.UpdateUsersOnMap(); } } 

Você precisa usar a propriedade Control.InvokeRequired para determinar se você está em um thread de segundo plano. Em seguida, você precisa invocar sua lógica que modificou sua interface do usuário por meio do método Control.Invoke para forçar as operações da interface do usuário a ocorrer no thread principal. Você faz isso criando um delegado e passando-o para o método Control.Invoke . O problema aqui é que você precisa de algum object derivado de Control para chamar esses methods.

Edit : Como outro usuário postou, se você pode esperar para o evento BackgroundWorker.Completed para atualizar sua interface do usuário, então você pode se inscrever para esse evento e chamar seu código de interface do usuário diretamente. BackgroundWorker_Completed é chamado no thread principal do aplicativo. meu código assume que você quer fazer atualizações durante a operação. Uma alternativa ao meu método é inscrever-se no evento BwackgroundWorker.ProgressChanged , mas acredito que você ainda precisará chamar o Invoke para atualizar sua interface do usuário nesse caso.

por exemplo

 public class UpdateController { private UserController _userController; BackgroundWorker backgroundWorker = new BackgroundWorker(); public UpdateController(LoginController loginController, UserController userController) { _userController = userController; loginController.LoginEvent += Update; } public void Update() { // The while loop was unecessary here backgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork); backgroundWorker.RunWorkerAsync(); } public delegate void DoUIWorkHandler(); public void backgroundWorker_DoWork(object sender, DoWorkEventArgs e) { // You must check here if your are executing on a background thread. // UI operations are only allowed on the main application thread if (someControlOnMyForm.InvokeRequired) { // This is how you force your logic to be called on the main // application thread someControlOnMyForm.Invoke(new DoUIWorkHandler(_userController.UpdateUsersOnMap); } else { _userController.UpdateUsersOnMap() } } } 

Você deve remover o while (true), você está adicionando manipuladores de events infinitos e invocando-os infinitas vezes.

Você pode usar o evento RunWorkerCompleted na class backgroundWorker para definir o que deve ser feito quando a tarefa em segundo plano for concluída. Portanto, você deve fazer a chamada do database no manipulador DoWork e, em seguida, atualizar a interface no manipulador RunWorkerCompleted, algo assim:

 BackgroundWorker bgw = new BackgroundWorker(); bgw.DoWork += (o, e) => { longRunningTask(); } bgw.RunWorkerCompleted += (o, e) => { if(e.Error == null && !e.Cancelled) { _userController.UpdateUsersOnMap(); } } bgw.RunWorkerAsync(); 

Além dos comentários anteriores, dê uma olhada no http://www.albahari.com/threading – o melhor documento sobre segmentação que você encontrará. Ele vai te ensinar como usar o BackgroundWorker corretamente.

Você deve atualizar a GUI quando o evento BackgroundWorker triggersr Concluído (que é chamado no thread da interface do usuário para facilitar para você, para que você não precise fazer Control.Invoke).

A declaração if na resposta de @ Lee deve ser semelhante a:

 bgw.RunWorkerCompleted += (o, e) => { if(e.Error == null && !e.Cancelled) { _userController.UpdateUsersOnMap(); } } 

… se você quiser invocar UpdateUsersOnMap(); quando não há erros e o BgWorker não foi cancelado.

Aqui está um padrão de código-fonte que você pode usar. Neste exemplo, estou redirecionando o Console, que eu uso para permitir que o trabalhador em segundo plano grave algumas mensagens em uma checkbox de texto enquanto está processando.

Esta é a class auxiliar TextBoxStreamWriter, que é usada para redirect a saída do console:

 public class TextBoxStreamWriter : TextWriter { TextBox _output = null; public TextBoxStreamWriter(TextBox output) { _output = output; } public override void WriteLine(string value) { // When character data is written, append it to the text box. // using Invoke so it works in a different thread as well _output.Invoke((Action)(() => _output.AppendText(value+"\r\n"))); } } 

Você precisa usá-lo no evento de carregamento de formulário da seguinte maneira:

 private void Form1_Load(object sender, EventArgs e) { // Instantiate the writer and redirect the console out var _writer = new TextBoxStreamWriter(txtResult); Console.SetOut(_writer); } 

Há também um botão no formulário que inicia o trabalhador em segundo plano, ele passa por um caminho para ele:

 private void btnStart_Click(object sender, EventArgs e) { backgroundWorker1.RunWorkerAsync(txtPath.Text); } 

Esta é a carga de trabalho do trabalhador em segundo plano, observe como ele usa o console para enviar mensagens para a checkbox de texto:

 private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) { var selectedPath = e.Argument as string; Console.Out.WriteLine("Processing Path:"+selectedPath); // ... } 

Se você precisar redefinir alguns controles depois, faça da seguinte maneira:

 private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { progressBar1.Invoke((Action) (() => { progressBar1.MarqueeAnimationSpeed = 0; progressBar1.Style = ProgressBarStyle.Continuous; })); } 

Neste exemplo, após a conclusão, uma barra de progresso está sendo redefinida.


Importante: Sempre que você acessar um controle de GUI, use Invoke como eu fiz nos exemplos acima. Usar o Lambda torna tudo mais fácil, como você pode ver no código.