How do I update the GUI from another thread

Question

Which is the simplest way to update a Label from another Thread    I have a Form running on thread1  and from that I m starting another thread  thread2    While thread2 is processing some files I would like to update a Label on the Form with the current status of thread2 s work    How could I do that

User · Answer

When you re in the UI thread you could ask it for its synchronization context task scheduler  It would give you a TaskScheduler that schedules everything on the UI thread   Then you can chain your tasks so that when the result is ready then another task  which is scheduled on the UI thread  picks it and assigns it to a label   public partial class MyForm   Form     private readonly TaskScheduler  uiTaskScheduler    public MyForm           InitializeComponent         uiTaskScheduler   TaskScheduler FromCurrentSynchronizationContext           private void buttonRunAsyncOperation Click object sender  EventArgs e          RunAsyncOperation           private void RunAsyncOperation           var task   new Task lt string gt  LengthyComputation       task ContinueWith antecedent   gt                           UpdateResultLabel antecedent Result    uiTaskScheduler       task Start           private string LengthyComputation           Thread Sleep 3000       return  47          private void UpdateResultLabel string text          labelResult Text   text          This works for tasks  not threads  which are the preferred way of writing concurrent code now

User · Answer

Threading code is often buggy and always hard to test  You don t need to write threading code to update the user interface from a background task  Just use the BackgroundWorker class to run the task and its ReportProgress method to update the user interface  Usually  you just report a percentage complete  but there s another overload that includes a state object  Here s an example that just reports a string object       private void button1 Click object sender  EventArgs e                backgroundWorker1 WorkerReportsProgress   true          backgroundWorker1 RunWorkerAsync               private void backgroundWorker1 DoWork object sender  DoWorkEventArgs e                Thread Sleep 5000           backgroundWorker1 ReportProgress 0   A            Thread Sleep 5000           backgroundWorker1 ReportProgress 0   B            Thread Sleep 5000           backgroundWorker1 ReportProgress 0   C               private void backgroundWorker1 ProgressChanged          object sender           ProgressChangedEventArgs e                label1 Text   e UserState ToString            That s fine if you always want to update the same field  If you ve got more complicated updates to make  you could define a class to represent the UI state and pass it to the ReportProgress method   One final thing  be sure to set the WorkerReportsProgress flag  or the ReportProgress method will be completely ignored

User · Answer

I wanted to add a warning because I noticed that some of the simple solutions omit the InvokeRequired check     I noticed that if your code executes before the window handle of the control has been created  e g  before the form is shown   Invoke throws an exception   So I recommend always checking on InvokeRequired before calling Invoke or BeginInvoke

User · Answer

Variation of Marc Gravell s simplest solution for  NET 4   control Invoke  MethodInvoker        gt  control Text    new text       Or use Action delegate instead   control Invoke new Action      gt  control Text    new text       See here for a comparison of the two  MethodInvoker vs Action for Control BeginInvoke

User · Answer

The easiest way I think      void Update               BeginInvoke  Action delegate                         do your update

User · Answer

When I encountered the same issue I sought help from Google  but rather than give me a simple solution it confused me more by giving examples of MethodInvoker and blah blah blah  So I decided to solve it on my own  Here is my solution   Make a delegate like this   Public delegate void LabelDelegate string s    void Updatelabel string text       if  label InvokeRequired              LabelDelegate LDEL   new LabelDelegate Updatelabel          label Invoke LDEL  text           else        label Text   text     You can call this function in a new thread like this  Thread th   new Thread      gt  Updatelabel  Hello World     th start      Don t be confused with Thread      gt          I use an anonymous function or lambda expression when I work on a thread  To reduce the lines of code you can use the ThreadStart     method too which I am not supposed to explain here

User · Answer

Here s a new look on an age-old issue using a more functional style  If you keep the TaskXM class in all of your projects you only have one line of code to never worry about cross-thread updates again   public class Example            lt summary gt          No more delegates  background workers  etc  Just one line of code as shown below          Note it is dependent on the Task Extension method shown next           lt  summary gt      public async void Method1                    Still on the GUI thread here if the method was called from the GUI thread            This code below calls the extension method which spins up a new task and calls back          await TaskXM RunCodeAsync      gt                           Running an asynchronous task here                Cannot update the GUI thread here  but can do lots of work                        Can update GUI on this line                lt summary gt      A class containing extension methods for the Task class      lt  summary gt  public static class TaskXM            lt summary gt          RunCodeAsyc is an extension method that encapsulates the Task run using a callback          lt  summary gt           lt param name  Code  gt The caller is called back on the new Task  on a different thread  lt  param gt           lt returns gt  lt  returns gt      public async static Task RunCodeAsync Action Code                await Task Run      gt                        Code                        return

User · Answer

The simplest way in WPF applications is   this Dispatcher Invoke  Action       gt           This refers to a form in a WPF application      val1   textBox Text     Access the UI

User · Answer

The simplest way is an anonymous method passed into Label Invoke      Running on the worker thread string newText    abc   form Label Invoke  MethodInvoker delegate          Running on the UI thread     form Label Text   newText         Back on the worker thread   Notice that Invoke blocks execution until it completes--this is synchronous code  The question doesn t ask about asynchronous code  but there is lots of content on Stack Overflow about writing asynchronous code when you want to learn about it

User · Answer

Put some common variable in a separate class to hold the value   Example   public  class data holder for controls          It will hold the value for your label     public string status   string Empty     class Demo       public static  data holder for controls d1   new data holder for controls         static void Main string   args                ThreadStart ts   new ThreadStart perform logic           Thread t1   new Thread ts           t1 Start            t1 Join              your label Text d1 status  --- can access it from any thread            public static void perform logic                    Put some code here in this function         for  int i   0  i  lt  10  i                             Statements here                      Set the result in the status variable         d1 status    Task done

User · Answer

This in my C  3 0 variation of Ian Kemp s solution   public static void SetPropertyInGuiThread lt C V gt  this C control  Expression lt Func lt C  V gt  gt  property  V value  where C   Control       var memberExpression   property Body as MemberExpression      if  memberExpression    null          throw new ArgumentException  The  property  expression must specify a property on the control          var propertyInfo   memberExpression Member as PropertyInfo      if  propertyInfo    null          throw new ArgumentException  The  property  expression must specify a property on the control          if  control InvokeRequired          control Invoke               Action lt C  Expression lt Func lt C  V gt  gt   V gt  SetPropertyInGuiThread              new object     control  property  value                  else         propertyInfo SetValue control  value  null       You call it like this   myButton SetPropertyInGuiThread b   gt  b Text   Click Me       It adds null-checking to the result of the  as MemberExpression   It improves the static type-safety    Otherwise  the original is a very nice solution

User · Answer

Salvete  Having searched for this question  I found the answers by FrankG and Oregon Ghost to be the easiest most useful to me  Now  I code in Visual Basic and ran this snippet through a convertor  so I m not sure quite how it turns out   I have a dialog form called form Diagnostics  which has a richtext box  called updateDiagWindow  which I am using as a sort of logging display   I needed to be able to update its text from all threads  The extra lines allow the window to automatically scroll to the newest lines   And so  I can now update the display with one line  from anywhere in the entire program in the manner which you think it would work without any threading     form Diagnostics updateDiagWindow whatmessage     Main Code  put this inside of your form s class code     region  ---------Update Diag Window Text------------------------------------     This sub allows the diag window to be updated by all threads public void updateDiagWindow string whatmessage        var  with1   diagwindow      if   with1 InvokeRequired             with1 Invoke new UpdateDiagDelegate UpdateDiag   whatmessage         else           UpdateDiag whatmessage              This next line makes the private UpdateDiagWindow available to all threads private delegate void UpdateDiagDelegate string whatmessage   private void UpdateDiag string whatmessage        var  with2   diagwindow       with2 appendtext whatmessage        with2 SelectionStart    with2 Text Length       with2 ScrollToCaret       endregion

User · Answer

In my case  WPF  the solution is simple as this   private void updateUI         if   Dispatcher CheckAccess                  Dispatcher BeginInvoke updateUI           return                Update any number of controls here

User · Answer

You ll need to Invoke the method on the GUI thread  You can do that by calling Control Invoke   For example   delegate void UpdateLabelDelegate  string message    void UpdateLabel  string message        if  InvokeRequired                 Invoke  new UpdateLabelDelegate  UpdateLabel   message            return             MyLabelControl Text   message

User · Answer

My version is to insert one line of recursive  mantra    For no arguments       void Aaaaaaa                 if  InvokeRequired    Invoke new Action Aaaaaaa    return      1 line of mantra             Your code          For a function that has arguments       void Bbb int x  string text                if  InvokeRequired    Invoke new Action lt int  string gt  Bbb   new     x  text     return               Your code          THAT is IT     Some argumentation  Usually it is bad for code readability to put    after an if    statement in one line  But in this case it is routine all-the-same  mantra   It doesn t break code readability if this method is consistent over the project  And it saves your code from littering  one line of code instead of five    As you see if InvokeRequired   something long  you just know  this function is safe to call from another thread

User · Answer

just use synchronization context of ui  using System Threading           public partial class MyForm   Form       private readonly SynchronizationContext uiContext       public MyForm                 InitializeComponent            uiContext   SynchronizationContext Current     get ui thread context            private void button1 Click object sender  EventArgs e                Thread t   new Thread      gt                  set ui thread context to new thread context                                             for operations with ui elements to be performed in proper thread              SynchronizationContext                   SetSynchronizationContext uiContext                label1 Text    some text                           t Start

User · Answer

For example  access a control other than in the current thread   Speed Threshold   30  textOutput Invoke new EventHandler delegate       lblThreshold Text   Speed Threshold ToString           There the lblThreshold is a Label and Speed Threshold is a global variable

User · Answer

You ll have to make sure that the update happens on the correct thread  the UI thread   In order to do this  you ll have to Invoke the event-handler instead of calling it directly   You can do this by raising your event like this    The code is typed here out of my head  so I haven t checked for correct syntax  etc   but it should get you going    if  MyEvent    null        Delegate   eventHandlers   MyEvent GetInvocationList        foreach  Delegate d in eventHandlers                 Check whether the target of the delegate implements           ISynchronizeInvoke  Winforms controls do   and see          if a context-switch is required        ISynchronizeInvoke target   d Target as ISynchronizeInvoke         if  target    null  amp  amp  target InvokeRequired                    target Invoke  d                       else                   d DynamicInvoke                           Note that the code above will not work on WPF projects  since WPF controls do not implement the ISynchronizeInvoke interface   In order to make sure that the code above works with Windows Forms and WPF  and all other platforms  you can have a look at the AsyncOperation  AsyncOperationManager and SynchronizationContext classes   In order to easily raise events this way  I ve created an extension method  which allows me to simplify raising an event by just calling   MyEvent Raise this  EventArgs Empty     Of course  you can also make use of the BackGroundWorker class  which will abstract this matter for you

User · Answer

Simply use something like this    this Invoke  MethodInvoker delegate                               progressBar1 Value   e ProgressPercentage     runs on UI thread

User · Answer

I just read the answers and this appears to be a very hot topic  I m currently using  NET 3 5 SP1 and Windows Forms   The well-known formula greatly described in the previous answers that makes use of the InvokeRequired property covers most of the cases  but not the entire pool   What if the Handle has not been created yet   The InvokeRequired property  as described here  Control InvokeRequired Property reference to MSDN  returns true if the call was made from a thread that is not the GUI thread  false either if the call was made from the GUI thread  or if the Handle was not created yet   You can come across an exception if you want to have a modal form shown and updated by another thread  Because you want that form shown modally  you could do the following   private MyForm  gui   public void StartToDoThings          gui   new MyForm        Thread thread   new Thread SomeDelegate       thread Start         gui ShowDialog        And the delegate can update a Label on the GUI   private void SomeDelegate            Operations that can take a variable amount of time  even no time           then you update the GUI     if  gui InvokeRequired           gui Invoke  Action delegate    gui Label1 Text    Done            else          gui Label1 Text    Done        This can cause an InvalidOperationException if the operations before the label s update  take less time   read it and interpret it as a simplification  than the time it takes for the GUI thread to create the Form s Handle  This happens within the ShowDialog   method   You should also check for the Handle like this   private void SomeDelegate            Operations that can take a variable amount of time  even no time           then you update the GUI     if  gui IsHandleCreated        lt ---- ADDED         if  gui InvokeRequired               gui Invoke  Action delegate    gui Label1 Text    Done                else              gui Label1 Text    Done        You can handle the operation to perform if the Handle has not been created yet  You can just ignore the GUI update  like shown in the code above  or you can wait  more risky   This should answer the question   Optional stuff  Personally I came up coding the following   public class ThreadSafeGuiCommand     private const int SLEEPING STEP   100    private readonly int  totalTimeout    private int  timeout     public ThreadSafeGuiCommand int totalTimeout           totalTimeout   totalTimeout         public void Execute Form form  Action guiCommand           timeout    totalTimeout      while   form IsHandleCreated              if   timeout  lt   0  return         Thread Sleep SLEEPING STEP          timeout -  SLEEPING STEP             if  form InvokeRequired        form Invoke guiCommand       else       guiCommand            I feed my forms that get updated by another thread with an instance of this ThreadSafeGuiCommand  and I define methods that update the GUI  in my Form  like this   public void SetLabeTextTo string value       threadSafeGuiCommand Execute this  delegate   Label1 Text   value          In this way I m quite sure that I will have my GUI updated whatever thread will make the call  optionally waiting for a well-defined amount of time  the timeout

User · Answer

Maybe a little bit overdose  but this is the kind of way I solve this normally   Invokes are not required here because of the synchronization  The BasicClassThreadExample is just a kind of layout for me  so change it to fit your actual needs   It is simple because you don t need to handle the stuff in the UI thread   public partial class Form1   Form       BasicClassThreadExample  example       public Form1                 InitializeComponent             example   new BasicClassThreadExample             example MessageReceivedEvent     example MessageReceivedEvent             void  example MessageReceivedEvent string command                listBox1 Items Add command              private void button1 Click object sender  EventArgs e                listBox1 Items Clear             example Start             public class BasicClassThreadExample   IDisposable       public delegate void MessageReceivedHandler string msg        public event MessageReceivedHandler MessageReceivedEvent       protected virtual void OnMessageReceivedEvent string msg                MessageReceivedHandler handler   MessageReceivedEvent          if  handler    null                        handler msg                        private System Threading SynchronizationContext  SynchronizationContext      private System Threading Thread  doWorkThread      private bool disposed   false       public BasicClassThreadExample                  SynchronizationContext   System ComponentModel AsyncOperationManager SynchronizationContext             public void Start                  doWorkThread    doWorkThread    new System Threading Thread dowork            if     doWorkThread IsAlive                          doWorkThread   new System Threading Thread dowork                doWorkThread IsBackground   true               doWorkThread Start                         public void dowork                 string   retval   System IO Directory GetFiles   C  Windows System32          System IO SearchOption TopDirectoryOnly           foreach  var item in retval                        System Threading Thread Sleep 25                SynchronizationContext Post new System Threading SendOrPostCallback delegate object obj                                OnMessageReceivedEvent item                   null                        protected virtual void Dispose bool disposing                if   disposed                        if  disposing                                 doWorkThread Abort                              disposed   true                       public void Dispose                 Dispose true           GC SuppressFinalize this               BasicClassThreadExample     Dispose false

User · Answer

The simple solution is to use Control Invoke   void DoSomething         if  InvokeRequired            Invoke new MethodInvoker updateGUI          else              Do Something         updateGUI             void updateGUI            update gui here

User · Answer

Basically the way to resolve this issue regardless of the framework version or the GUI underlying library type is to save the control creating the thread s Synchronization context for the worker thread that will marshal the control s related interaction from the worker thread to the GUI s thread messages queue   Example   SynchronizationContext ctx   SynchronizationContext Current     From control ctx Send Post       From worker thread

User · Answer

None of the Invoke stuff in the previous answers is necessary   You need to look at WindowsFormsSynchronizationContext      In the main thread WindowsFormsSynchronizationContext mUiContext   new WindowsFormsSynchronizationContext             In some non-UI Thread     Causes an update in the GUI thread  mUiContext Post UpdateGUI  userData         void UpdateGUI object userData           Update your GUI controls here

User · Answer

Another example about the subject  I made an abstract class  UiSynchronizeModel  that contains a common method implementation   public abstract class UiSynchronizeModel       private readonly TaskScheduler uiSyncContext      private readonly SynchronizationContext winformsOrDefaultContext       protected UiSynchronizeModel                 this winformsOrDefaultContext   SynchronizationContext Current    new SynchronizationContext            this uiSyncContext   TaskScheduler FromCurrentSynchronizationContext               protected void RunOnGuiThread Action action                this winformsOrDefaultContext Post o   gt  action    null              protected void CompleteTask Task task  TaskContinuationOptions options  Action lt Task gt  action                task ContinueWith delegate                       action task               task Dispose               CancellationToken None  options  this uiSyncContext             Your model or controller class should be derived from this abstract class  You can use any pattern  tasks or manually managed background threads  and use these methods like this   public void MethodThatCalledFromBackroundThread        this RunOnGuiThread      gt              Do something over UI controls            Tasks example   var task   Task Factory StartNew delegate          Background code     this RunOnGuiThread      gt               Do something over UI controls              this CompleteTask task  TaskContinuationOptions OnlyOnRanToCompletion  delegate          Code that can safely use UI controls

User · Answer

Simplest way is invoking as follows     Application Current Dispatcher Invoke new Action      gt                                     try                                                                                             catch  Exception

User · Answer

Because of the triviality of the scenario I would actually have the UI thread poll for the status  I think you will find that it can be quite elegant   public class MyForm   Form     private volatile string m Text         private System Timers Timer m Timer     private MyForm           m Timer   new System Timers Timer        m Timer SynchronizingObject   this      m Timer Interval   1000      m Timer Elapsed     s  a    gt    MyProgressLabel Text   m Text         m Timer Start        var thread   new Thread WorkerThread       thread Start           private void WorkerThread           while                      Periodically publish progress information        m Text    Still working                    The approach avoids the marshaling operation required when using the ISynchronizeInvoke Invoke and ISynchronizeInvoke BeginInvoke methods  There is nothing wrong with using the marshaling technique  but there are a couple of caveats you need to be aware of    Make sure you do not call BeginInvoke too frequently or it could overrun the message pump  Calling Invoke on the worker thread is a blocking call  It will temporarily halt the work being done in that thread    The strategy I propose in this answer reverses the communication roles of the threads  Instead of the worker thread pushing the data the UI thread polls for it  This a common pattern used in many scenarios  Since all you are wanting to do is display progress information from the worker thread then I think you will find that this solution is a great alternative to the marshaling solution  It has the following advantages    The UI and worker threads remain loosely coupled as opposed to the Control Invoke or Control BeginInvoke approach which tightly couples them  The UI thread will not impede the progress of the worker thread  The worker thread cannot dominate the time the UI thread spends updating  The intervals at which the UI and worker threads perform operations can remain independent  The worker thread cannot overrun the UI thread s message pump  The UI thread gets to dictate when and how often the UI gets updated

User · Answer

Fire and forget extension method for  NET 3 5   using System  using System Windows Forms   public static class ControlExtensions            lt summary gt          Executes the Action asynchronously on the UI thread  does not block execution on the calling thread           lt  summary gt           lt param name  control  gt  lt  param gt           lt param name  code  gt  lt  param gt      public static void UIThread this Control  this  Action code                if   this InvokeRequired                         this BeginInvoke code                     else                       code Invoke                        This can be called using the following line of code   this UIThread      gt  this myLabel Text    Text Goes Here

User · Answer

For many purposes it s as simple as this   public delegate void serviceGUIDelegate    private void updateGUI       this Invoke new serviceGUIDelegate serviceGUI         serviceGUI    is a GUI level method within the form  this  that can change as many controls as you want  Call  updateGUI    from the other thread  Parameters can be added to pass values  or  probably faster  use class scope variables with locks on them as required if there is any possibility of a clash between threads accessing them that could cause instability   Use BeginInvoke instead of Invoke if the non-GUI thread is time critical  keeping Brian Gideon s warning in mind

User · Answer

You must use invoke and delegate  private delegate void MyLabelDelegate    label1 Invoke  new MyLabelDelegate    label1 Text    1

User · Answer

Even if the operation is time-consuming  thread sleep in my example  - This code will NOT lock your UI      private void button1 Click object sender  EventArgs e            Thread t   new Thread new ThreadStart ThreadJob          t IsBackground   true        t Start                  private void ThreadJob           string newValue   Hi        Thread Sleep 2000          this Invoke  MethodInvoker delegate                 label1 Text   newValue

User · Answer

The vast majority of answers use Control Invoke which is a race condition waiting to happen  For example  consider the accepted answer   string newText    abc      running on worker thread this Invoke  MethodInvoker delegate        someLabel Text   newText     runs on UI thread       If the user closes the form just before this Invoke is called  remember  this is the Form object   an ObjectDisposedException will be likely fired   The solution is to use SynchronizationContext  specifically SynchronizationContext Current as hamilton danielb suggests  other answers rely on specific SynchronizationContext implementations which is completely unnecessary   I would slightly modify his code to use SynchronizationContext Post rather than SynchronizationContext Send though  as there s typically no need for the worker thread to wait    public partial class MyForm   Form       private readonly SynchronizationContext  context      public MyForm                  context   SynchronizationContext Current                        private MethodOnOtherThread                                context Post status   gt  someLabel Text   newText null             Note that on  NET 4 0 and up you should really be using tasks for async operations  See n-san s answer for the equivalent task-based approach  using TaskScheduler FromCurrentSynchronizationContext     Finally  on  NET 4 5 and up you can also use Progress lt T gt   which basically captures SynchronizationContext Current upon its creation  as demonstrated by Ryszard Dzegan s for cases where the long-running operation needs to run UI code while still working

User · Answer

For  NET 2 0  here s a nice bit of code I wrote that does exactly what you want  and works for any property on a Control   private delegate void SetControlPropertyThreadSafeDelegate      Control control       string propertyName       object propertyValue    public static void SetControlPropertyThreadSafe      Control control       string propertyName       object propertyValue      if  control InvokeRequired          control Invoke new SetControlPropertyThreadSafeDelegate                     SetControlPropertyThreadSafe        new object     control  propertyName  propertyValue           else         control GetType   InvokeMember          propertyName           BindingFlags SetProperty           null           control           new object     propertyValue             Call it like this      thread-safe equivalent of    myLabel Text   status  SetControlPropertyThreadSafe myLabel   Text   status     If you re using  NET 3 0 or above  you could rewrite the above method as an extension method of the Control class  which would then simplify the call to   myLabel SetPropertyThreadSafe  Text   status     UPDATE 05 10 2010   For  NET 3 0 you should use this code   private delegate void SetPropertyThreadSafeDelegate lt TResult gt       Control  this       Expression lt Func lt TResult gt  gt  property       TResult value    public static void SetPropertyThreadSafe lt TResult gt       this Control  this       Expression lt Func lt TResult gt  gt  property       TResult value      var propertyInfo    property Body as MemberExpression  Member        as PropertyInfo     if  propertyInfo    null            this GetType   IsSubclassOf propertyInfo ReflectedType            this GetType   GetProperty            propertyInfo Name             propertyInfo PropertyType     null          throw new ArgumentException  The lambda expression  property  must reference a valid property on this Control            if   this InvokeRequired             this Invoke new SetPropertyThreadSafeDelegate lt TResult gt          SetPropertyThreadSafe          new object      this  property  value           else            this GetType   InvokeMember            propertyInfo Name             BindingFlags SetProperty             null              this             new object     value             which uses LINQ and lambda expressions to allow much cleaner  simpler and safer syntax   myLabel SetPropertyThreadSafe      gt  myLabel Text  status      status has to be a string or this will fail to compile   Not only is the property name now checked at compile time  the property s type is as well  so it s impossible to  for example  assign a string value to a boolean property  and hence cause a runtime exception   Unfortunately this doesn t stop anyone from doing stupid things such as passing in another Control s property and value  so the following will happily compile   myLabel SetPropertyThreadSafe      gt  aForm ShowIcon  false     Hence I added the runtime checks to ensure that the passed-in property does actually belong to the Control that the method s being called on  Not perfect  but still a lot better than the  NET 2 0 version   If anyone has any further suggestions on how to improve this code for compile-time safety  please comment

User · Answer

Handling long work  Since  NET 4 5 and C  5 0 you should use Task-based Asynchronous Pattern  TAP  along with async-await keywords in all areas  including the GUI       TAP is the recommended asynchronous design pattern for new development   instead of Asynchronous Programming Model  APM  and Event-based Asynchronous Pattern  EAP   the latter includes the BackgroundWorker Class    Then  the recommended solution for new development is    Asynchronous implementation of an event handler  Yes  that s all    private async void Button Clicked object sender  EventArgs e        var progress   new Progress lt string gt  s   gt  label Text   s       await Task Factory StartNew      gt  SecondThreadConcern LongWork progress                                   TaskCreationOptions LongRunning       label Text    completed      Implementation of the second thread that notifies the UI thread   class SecondThreadConcern       public static void LongWork IProgress lt string gt  progress                   Perform a long running work            for  var i   0  i  lt  10  i                          Task Delay 500  Wait                progress Report i ToString                          Notice the following     Short and clean code written in sequential manner without callbacks and explicit threads  Task instead of Thread  async keyword  that allows to use await which in turn prevent the event handler from reaching the completion state till the task finished and in the meantime doesn t block the UI thread  Progress class  see IProgress Interface  that supports Separation of Concerns  SoC  design principle and doesn t require explicit dispatcher and invoking  It uses the current SynchronizationContext from its creation place  here the UI thread   TaskCreationOptions LongRunning that hints to do not queue the task into ThreadPool    For a more verbose examples see  The Future of C   Good things come to those who  await  by Joseph Albahari   See also about UI Threading Model concept   Handling exceptions  The below snippet is an example of how to handle exceptions and toggle button s Enabled property to prevent multiple clicks during background execution   private async void Button Click object sender  EventArgs e        button Enabled   false       try               var progress   new Progress lt string gt  s   gt  button Text   s           await Task Run      gt  SecondThreadConcern FailingWork progress            button Text    Completed             catch Exception exception                button Text    Failed      exception Message             button Enabled   true     class SecondThreadConcern       public static void FailingWork IProgress lt string gt  progress                progress Report  I will fail in               Task Delay 500  Wait             for  var i   0  i  lt  3  i                          progress Report  3 - i  ToString                 Task Delay 500  Wait                       throw new Exception  Oops

User · Answer

I prefer this one   private void UpdateNowProcessing string nowProcessing        if  this InvokeRequired                Action lt string gt  d   UpdateNowProcessing          Invoke d  nowProcessing             else               this progressDialog Next nowProcessing

User · Answer

General approach is like   using System  using System Threading  using System Windows Forms   namespace WindowsFormsApp1       public partial class Form1   Form               int clickCount   0           public Form1                         InitializeComponent                label1 SetText  0                       private void button1 Click object sender  EventArgs e                        new Thread      gt  label1 SetText    clickCount  ToString     Start                         public static class ControlExtensions               public static void SetText this Control control  string text                        if  control InvokeRequired                  control Invoke setText  control  text               else                 control Text   text                     private static readonly Action lt Control  string gt  setText                control  text    gt  control Text   text            Explanation   The answer is pretty like this one  But uses neater  as for me  and newer syntax  The point is InvokeRequired property of control  It gets a value indicating whether the caller must call an invoke method when making method calls to the control because the caller is on a different thread than the one the control was created on  So if we call control SetText  some text   on the same thread control was created on  it s OK just to set Text as this control Text   text  But on any other thread it causes System InvalidOperationException so one must call a method via control Invoke      to set Text on the thread control was created on

User · Answer

Create a class variable   SynchronizationContext  context    Set it in the constructor that creates your UI   var  context   SynchronizationContext Current    When you want to update the label    context Send status   gt          UPDATE LABEL    null

User · Answer

To achieve this in WPF I do it the following way    new Thread      gt           while                       SomeLabel Dispatcher BeginInvoke  Action       gt  SomeLabel Text                     Start

User · Answer

First get the instance of your form  in this case mainForm   and then just use this code in the another thread   mainForm Invoke new MethodInvoker delegate              Update things in my mainForm here     mainForm UpdateView

User · Answer

This is the classic way you should do this   using System  using System Windows Forms  using System Threading   namespace Test       public partial class UIThread   Form               Worker worker           Thread workerThread           public UIThread                         InitializeComponent                 worker   new Worker                worker ProgressChanged    new EventHandler lt ProgressChangedArgs gt  OnWorkerProgressChanged               workerThread   new Thread new ThreadStart worker StartWork                workerThread Start                       private void OnWorkerProgressChanged object sender  ProgressChangedArgs e                           Cross thread - so you don t get the cross-threading exception             if  this InvokeRequired                                this BeginInvoke  MethodInvoker delegate                                       OnWorkerProgressChanged sender  e                                       return                                Change control             this label1 Text   e Progress                       public class Worker               public event EventHandler lt ProgressChangedArgs gt  ProgressChanged           protected void OnProgressChanged ProgressChangedArgs e                        if ProgressChanged  null                                ProgressChanged this e                                    public void StartWork                         Thread Sleep 100               OnProgressChanged new ProgressChangedArgs  Progress Changed                 Thread Sleep 100                         public class ProgressChangedArgs   EventArgs               public string Progress  get private set           public ProgressChangedArgs string progress                        Progress   progress                      Your worker thread has an event  Your UI thread starts off another thread to do the work and hooks up that worker event so you can display the state of the worker thread   Then in the UI you need to cross threads to change the actual control    like a label or a progress bar

User · Answer

I couldn t get Microsoft s logic behind this ugly implementation  but you have to have two functions   void setEnableLoginButton       if  InvokeRequired             btn login can be any conroller   label  button textbox   etc        btn login Invoke new MethodInvoker setEnable            OR       Invoke new MethodInvoker setEnable          else       setEnable           void setEnable       btn login Enabled   isLoginBtnEnabled      These snippets work for me  so I can do something on another thread  and then I update the GUI   Task Factory StartNew     gt           THIS IS NOT GUI     Thread Sleep 5000          HERE IS INVOKING GUI     btn login Invoke new Action      gt  DoSomethingOnGUI           private void DoSomethingOnGUI           GUI    MessageBox Show  message    title   MessageBoxButtons OK  MessageBoxIcon Exclamation       Even simpler   btn login Invoke new Action     gt      HERE YOU ARE ON GUI

User · Answer

Try to refresh the label using this  public static class ExtensionMethods       private static Action EmptyDelegate   delegate             public static void Refresh this UIElement uiElement                uiElement Dispatcher Invoke DispatcherPriority Render  EmptyDelegate

User · Answer

Label lblText    initialized elsewhere  void AssignLabel string text       if  InvokeRequired             BeginInvoke  Action lt string gt  AssignLabel  text         return           lblText Text   text                 Note that BeginInvoke   is preferred over Invoke   because it s less likely to cause deadlocks  however  this is not an issue here when just assigning text to a label     When using Invoke   you are waiting for the method to return  Now  it may be that you do something in the invoked code that will need to wait for the thread  which may not be immediately obvious if it s buried in some functions that you are calling  which itself may happen indirectly via event handlers  So you would be waiting for the thread  the thread would be waiting for you and you are deadlocked    This actually caused some of our released software to hang  It was easy enough to fix by replacing Invoke   with BeginInvoke    Unless you have a need for synchronous operation  which may be the case if you need a return value  use BeginInvoke

User · Answer

You may use the already-existing delegate Action   private void UpdateMethod         if  InvokeRequired                Invoke new Action UpdateMethod

User · Answer

Most of the other answers are a little complex for me on this question  I m new to C    so I am writing mine   I have a WPF application and have defined a worker as below   Issue   BackgroundWorker workerAllocator  workerAllocator DoWork    delegate  object sender1  DoWorkEventArgs e1           This is my DoWork function         It is given as an anonymous function  instead of a separate DoWork function         I need to update a message to textbox  txtLog  from this thread function         Want to write below line  to update UI     txt Text    my message          But it fails with           System InvalidOperationException            The calling thread cannot access this object because a different thread owns it      Solution   workerAllocator DoWork    delegate  object sender1  DoWorkEventArgs e1           The below single line works     txtLog Dispatcher BeginInvoke  Action       gt  txtLog Text    my message         I am yet to find out what the above line means  but it works   For WinForms   Solution   txtLog Invoke  MethodInvoker delegate       txtLog Text    my message

User · Answer

This one is similar to the solution above using  NET Framework 3 0  but it solved the issue of compile-time safety support   public  static class ControlExtension       delegate void SetPropertyValueHandler lt TResult gt  Control souce  Expression lt Func lt Control  TResult gt  gt  selector  TResult value        public static void SetPropertyValue lt TResult gt  this Control source  Expression lt Func lt Control  TResult gt  gt  selector  TResult value                if  source InvokeRequired                        var del   new SetPropertyValueHandler lt TResult gt  SetPropertyValue               source Invoke del  new object    source  selector  value                      else                       var propInfo     MemberExpression selector Body  Member as PropertyInfo              propInfo SetValue source  value  null                       To use   this lblTimeDisplay SetPropertyValue a   gt  a Text   some string    this lblTimeDisplay SetPropertyValue a   gt  a Visible  false     The compiler will fail if the user passes the wrong data type   this lblTimeDisplay SetPropertyValue a   gt  a Visible   sometext

User · Answer

And yet another generic Control extension aproach    First add an extension method for objects of type Control  public static void InvokeIfRequired lt T gt  this T c  Action lt T gt  action  where T   Control       if  c InvokeRequired                c Invoke new Action      gt  action c               else               action c             and call like this from another thread to access a Control named object1 in UI-thread   object1 InvokeIfRequired c   gt    c Visible   true      object1 InvokeIfRequired c   gt    c Text    ABC           or like this  object1 InvokeIfRequired c   gt              c Text    ABC         c Visible   true

[c#] How do I update the GUI from another thread?

Examples related to c#

Examples related to .net

Examples related to multithreading

Examples related to winforms

Examples related to user-interface