Comment puis-je mettre à jour l'interface graphique à partir d'un autre thread?

Pour .NET 2.0, voici un beau morceau de code que j'ai écrit qui fait exactement ce que vous voulez, et fonctionne bien sur un 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 });
  }
}

L'appeler comme ceci:

//thread-safe equivalent of
//myLabel.Text = status;
SetControlPropertyThreadSafe(myLabel, "Text", status);

Si vous êtes en utilisant .NET 3.0 ou supérieur, vous pouvez réécrire la méthode ci-dessus comme une extension de la méthode de la Control classe, qui serait alors de simplifier l'appel à:

myLabel.SetPropertyThreadSafe("Text", status);

Mise à JOUR 05/10/2010:

Pour .NET 3.0, vous devez utiliser ce code:

private delegate void SetPropertyThreadSafeDelegate<TResult>(
    Control @this, 
    Expression<Func<TResult>> property, 
    TResult value);

public static void SetPropertyThreadSafe<TResult>(
    this Control @this, 
    Expression<Func<TResult>> 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<TResult> 
      (SetPropertyThreadSafe), 
      new object[] { @this, property, value });
  }
  else
  {
      @this.GetType().InvokeMember(
          propertyInfo.Name, 
          BindingFlags.SetProperty, 
          null, 
          @this, 
          new object[] { value });
  }
}

qui utilise LINQ et les expressions lambda pour permettre à beaucoup plus propre, plus simple et plus sûr de la syntaxe:

myLabel.SetPropertyThreadSafe(() => myLabel.Text, status); //status has to be a string or this will fail to compile

N'est pas seulement le nom de la propriété à présent vérifié au moment de la compilation, le type de la propriété est ainsi, il est donc impossible de (par exemple) assigner une chaîne de valeur à une propriété booléenne, et donc la cause d'une exception d'exécution.

Malheureusement, cela n'a pas empêcher personne de faire des choses stupides comme en passant dans un autre Control's de la propriété et de la valeur, donc la suite sera heureux de compiler:

myLabel.SetPropertyThreadSafe(() => aForm.ShowIcon, false);

Donc j'ai ajouté de l'exécution des vérifications pour s'assurer que la propriété n'appartiennent en fait à la Control que la méthode est appelée. Pas parfait, mais encore beaucoup mieux que la .NET version 2.0.

Si quelqu'un a d'autres suggestions sur la façon d'améliorer ce code au moment de la compilation de la sécurité, s'il vous plaît commentaire!

Manipulation long travail

Depuis .NET 4.5, C# 5.0 vous devez utiliser Tâche Asynchrone basé sur le Modèle (TAP) avec async-attendre mots-clés dans tous les domaines (y compris l'interface graphique):

TAP est recommandé asynchrone modèle de conception pour le développement de nouvelles

au lieu de Modèle de Programmation asynchrone (APM) et Basé sur des événements du Modèle Asynchrone (EAP) (celle-ci inclut le Classe BackgroundWorker).

Ensuite, la solution recommandée pour le nouveau développement est:

1. Asynchrone de la mise en œuvre d'un gestionnaire d'évènement (Oui, c'est tout):

   private async void Button_Clicked(object sender, EventArgs e)
   {
       var progress = new Progress<string>(s => label.Text = s);
       await Task.Factory.StartNew(() => SecondThreadConcern.LongWork(progress),
                                   TaskCreationOptions.LongRunning);
       label.Text = "completed";
   }

2. Mise en œuvre de la deuxième thread qui avertit le thread d'INTERFACE utilisateur:

   class SecondThreadConcern
   {
       public static void LongWork(IProgress<string> progress)
       {
           //Perform a long running work...
           for (var i = 0; i < 10; i++)
           {
               Task.Delay(500).Wait();
               progress.Report(i.ToString());
           }
       }
   }

Avis la suivante:

1. À court et à nettoyer le code écrit de manière séquentielle, sans les rappels de service et explicite les threads.
2. Tâche au lieu de Fil.
3. async mot-clé, qui permet d'utiliser attendent qui à son tour empêcher le gestionnaire d'événement d'atteindre l'état d'achèvement jusqu'à la tâche terminée et, en attendant, ne pas bloquer le thread d'INTERFACE utilisateur.
4. Progrès de la classe (voir IProgress Interface) qui prend en charge La séparation des Préoccupations (SoC) principe de conception et ne nécessite pas explicite répartiteur et de l'invocation. Il utilise le courant SynchronizationContext de sa création, le lieu (ici le thread d'INTERFACE utilisateur).
5. TaskCreationOptions.LongRunning que des astuces pour ne pas la file d'attente de la tâche en ThreadPool.

Pour une plus détaillé des exemples, voir: L'Avenir de C#: les Bonnes choses viennent à ceux qui attendent' par Joseph Albahari.

Voir aussi à propos de Modèle de thread de l'INTERFACE utilisateur concept.

La gestion des exceptions

L'extrait de code ci-dessous est un exemple de la façon de gérer les exceptions et le bouton à bascule du Enabled de propriété pour empêcher plusieurs clics cours d'exécution en arrière-plan.

private async void Button_Click(object sender, EventArgs e)
{
    button.Enabled = false;

    try
    {
        var progress = new Progress<string>(s => button.Text = s);
        await Task.Run(() => SecondThreadConcern.FailingWork(progress));
        button.Text = "Completed";
    }
    catch(Exception exception)
    {
        button.Text = "Failed: " + exception.Message;
    }

    button.Enabled = true;
}

class SecondThreadConcern
{
    public static void FailingWork(IProgress<string> progress)
    {
        progress.Report("I will fail in...");
        Task.Delay(500).Wait();

        for (var i = 0; i < 3; i++)
        {
            progress.Report((3 - i).ToString());
            Task.Delay(500).Wait();
        }

        throw new Exception("Oops...");
    }
}

Feu et oublier de la méthode d'extension pour .NET 3.5+

using System;
using System.Windows.Forms;

public static class ControlExtensions
{
    ///<summary>
    ///Executes the Action asynchronously on the UI thread, does not block execution on the calling thread.
    ///</summary>
    ///<param name="control"></param>
    ///<param name="code"></param>
    public static void UIThread(this Control @this, Action code)
    {
        if (@this.InvokeRequired)
        {
            @this.BeginInvoke(code);
        }
        else
        {
            code.Invoke();
        }
    }
}

Cela peut être appelée à l'aide de la ligne de code suivante:

this.UIThread(() => this.myLabel.Text = "Text Goes Here");

La solution la plus simple est d'utiliser Control.Invoke.

void DoSomething()
{
if (InvokeRequired) {
Invoke(new MethodInvoker(updateGUI));
} else {
//Do Something
updateGUI();
}
}
void updateGUI() {
//update gui here
}

La grande majorité des réponses utilisez Control.Invoke qui est un condition de course en attente de se produire. Considérons, par exemple, de la accepté de répondre:

string newText = "abc"; //running on worker thread
this.Invoke((MethodInvoker)delegate { 
someLabel.Text = newText; //runs on UI thread
});

Si l'utilisateur ferme le formulaire juste avant this.Invoke est appelé (rappelez-vous, this est le Form objet), un ObjectDisposedException sera probablement tiré.

La solution est d'utiliser SynchronizationContext, spécifiquement SynchronizationContext.Current comme hamilton.danielb suggère (d'autres réponses reposent sur des SynchronizationContext des implémentations qui est complètement inutile). J'ai légèrement modifier son code pour utiliser SynchronizationContext.Post plutôt que SynchronizationContext.Send si (comme il n'y a généralement pas besoin de le thread de travail à attendre):

public partial class MyForm : Form
{
private readonly SynchronizationContext _context;
public MyForm()
{
_context = SynchronizationContext.Current
...
}
private MethodOnOtherThread()
{
...
_context.Post(status => someLabel.Text = newText,null);
}
}

Noter que sur .NET 4.0 et vous devez vraiment être à l'aide de tâches pour des opérations asynchrones. Voir n-san réponse pour l'équivalent approche basée sur les tâches (à l'aide de TaskScheduler.FromCurrentSynchronizationContext).

Enfin, sur .NET 4.5 et vous pouvez également utiliser Progress<T> (qui, en gros, capture SynchronizationContext.Current, lors de sa création), comme démontré par Ryszard Dżegan de l' pour les cas où l'opération de longue durée doit exécuter le code de l'INTERFACE utilisateur tout en travaillant.

Vous aurez besoin d'Invoquer la méthode sur le thread GUI. Vous pouvez le faire en appelant le Contrôle.Invoquer.

Par exemple:

delegate void UpdateLabelDelegate (string message);
void UpdateLabel (string message)
{
if (InvokeRequired)
{
Invoke (new UpdateLabelDelegate (UpdateLabel), message);
return;
}
MyLabelControl.Text = message;
}

Aucun Invoquer des trucs dans la réponse à la question précédente est nécessaire.

Vous avez besoin de regarder 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
}

Salvete! Après avoir cherché pour cette question, j'ai trouvé les réponses par FrankG et Oregon Fantôme être le plus facile plus utile pour moi. Maintenant, je code en Visual Basic et a couru cet extrait par l'intermédiaire d'un convertisseur; donc je ne sais pas bien comment il se trouve.

J'ai une boîte de dialogue formulaire appelé form_Diagnostics, qui a un richtext boîte, appelé updateDiagWindow, qui je suis en utilisant comme une sorte de journalisation de l'écran. J'avais besoin d'être en mesure de mettre à jour son texte à partir de tous les threads. Les lignes supplémentaires permettent à la fenêtre pour faire défiler automatiquement les plus récentes lignes.

Et donc, je peux maintenant mettre à jour l'affichage avec une ligne, de n'importe où dans l'ensemble du programme de la manière dont vous pensez qu'il serait de travailler sans aucun filetage:

  form_Diagnostics.updateDiagWindow(whatmessage);

Code principal (mettre cela à l'intérieur de votre formulaire de code de classe):

#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

Dans mon C# 3.0 variation de Ian Kemp solution:

public static void SetPropertyInGuiThread<C,V>(this C control, Expression<Func<C, V>> 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<C, Expression<Func<C, V>>, V>)SetPropertyInGuiThread,
new object[] { control, property, value }
);
else
propertyInfo.SetValue(control, value, null);
}

Vous l'appeler comme ceci:

myButton.SetPropertyInGuiThread(b => b.Text, "Click Me!")

1. Il ajoute null-vérification à la suite de l' "comme MemberExpression".
2. Il améliore le type statique de sécurité.

Sinon, l'original est une très belle solution.

Quand j'ai rencontré le même problème j'ai demandé l'aide de Google, mais plutôt que de me donner une solution simple il me troublait de plus en donnant des exemples de MethodInvoker et bla bla bla. J'ai donc décidé de le résoudre sur mon propre. Voici ma solution:

Faire un délégué comme ceci:

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
}

Vous pouvez appeler cette fonction dans un nouveau thread comme celui-ci

Thread th = new Thread(() => Updatelabel("Hello World"));
th.start();

Ne pas confondre avec Thread(() => .....). J'utilise une fonction anonyme ou une expression lambda, quand je travaille sur un fil. Afin de réduire les lignes de code, vous pouvez utiliser le ThreadStart(..) méthode que je ne suis pas censé expliquer ici.

Vous pouvez utiliser le délégué Action:

private void UpdateMethod()
{
if (InvokeRequired)
{
Invoke(new Action(UpdateMethod));
}
}

Essayer de mettre à jour l'étiquette à l'aide de cette

public static class ExtensionMethods
{
private static Action EmptyDelegate = delegate() { };
public static void Refresh(this UIElement uiElement)
{
uiElement.Dispatcher.Invoke(DispatcherPriority.Render, EmptyDelegate);
}
}

Vous devez utiliser invoquer et délégué

private delegate void MyLabelDelegate();
label1.Invoke( new MyLabelDelegate(){ label1.Text += 1; });

Par exemple, accéder à un contrôle autre que dans le thread actuel:

Speed_Threshold = 30;
textOutput.Invoke(new EventHandler(delegate
{
lblThreshold.Text = Speed_Threshold.ToString();
}));

Il le lblThreshold est un Label et Speed_Threshold est une variable globale.

Je viens de lire les réponses et que cela semble être un sujet très chaud. Je suis actuellement à l'aide .NET 3.5 SP1 et Windows Forms.

La formule bien connue grandement décrites dans les réponses précédentes qui rend l'utilisation de la InvokeRequired propriété couvre la plupart des cas, mais pas dans l'ensemble du bassin.

Que si le Poignée n'a pas encore été créé?

La InvokeRequired de propriété, tel que décrit ici (le Contrôle.InvokeRequired référence du Bien à MSDN) retourne true si l'appel a été fait à partir d'un thread qui n'est pas le thread GUI, false si l'appel a été fait à partir du thread GUI, ou si le Poignée n'était pas encore créé.

Vous pouvez venir à travers une exception si vous voulez avoir un formulaire modal montré et mis à jour par un autre thread. Parce que vous souhaitez que le formulaire ci-modal, vous pouvez effectuer les opérations suivantes:

private MyForm _gui;
public void StartToDoThings()
{
_gui = new MyForm();
Thread thread = new Thread(SomeDelegate);
thread.Start();
_gui.ShowDialog();
}

Et le délégué peut mettre à jour une Étiquette sur l'interface graphique:

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!";
}

Cela peut provoquer une InvalidOperationException si les opérations avant que le label de la mise à jour de "prendre moins de temps" (le lire et de l'interpréter à la simplification de la procédure) que le temps qu'il faut pour que le thread GUI pour créer le Forme's Poignée. Ce qui se passe à l'intérieur de la ShowDialog() méthode.

Vous devriez également vérifier pour la Poignée comme ceci:

private void SomeDelegate()
{
//Operations that can take a variable amount of time, even no time
//... then you update the GUI
if(_gui.IsHandleCreated)  // <---- ADDED
if(_gui.InvokeRequired)
_gui.Invoke((Action)delegate { _gui.Label1.Text = "Done!"; });
else
_gui.Label1.Text = "Done!";
}

Vous pouvez gérer l'opération à effectuer si le Poignée n'a pas encore été créé: Vous pouvez tout simplement ignorer l'interface graphique de mise à jour (comme indiqué dans le code ci-dessus) ou vous pouvez attendre (plus risqué).
Cela devrait répondre à la question.

Facultatif trucs:
Personnellement, je suis venu de codage suivantes:

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 <= 0) return;
Thread.Sleep(SLEEPING_STEP);
_timeout -= SLEEPING_STEP;
}
if (form.InvokeRequired)
form.Invoke(guiCommand);
else
guiCommand();
}
}

- Je nourrir mes formulaires mis à jour par un autre thread avec une instance de cette ThreadSafeGuiCommand, et je définir des méthodes de mise à jour de l'interface graphique (dans mon Formulaire) comme ceci:

public void SetLabeTextTo(string value)
{
_threadSafeGuiCommand.Execute(this, delegate { Label1.Text = value; });
}

De cette façon, je suis sûr que je vais avoir mon GUI mis à jour tout ce thread va faire l'appel, éventuellement en attente pour une quantité définie de temps (timeout).

La façon la plus simple dans les applications WPF est:

this.Dispatcher.Invoke((Action)(() =>
{
//This refers to a form in a WPF application 
val1 = textBox.Text; //Access the UI 
}));

Même si l'opération est coûteuse en temps (thread.dormir dans mon exemple) - Ce code ne sera PAS verrouiller votre INTERFACE utilisateur:

 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; 
});
}

Peut-être un peu l'overdose, mais c'est le genre de façon-je résoudre ce normalement:

Invoque ne sont pas nécessaires ici en raison de la synchronisation.
Le BasicClassThreadExample est juste une sorte de mise en page pour moi, afin de modifier pour l'adapter à vos besoins réels.

Il est simple parce que vous n'avez pas besoin de manipuler la substance dans le thread de l'INTERFACE utilisateur!

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); }
}

Un autre exemple sur le sujet: j'ai fait une classe abstraite, UiSynchronizeModel, qui contient une méthode commune de mise en œuvre:

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 => action(), null);
}
protected void CompleteTask(Task task, TaskContinuationOptions options, Action<Task> action)
{
task.ContinueWith(delegate
{
action(task);
task.Dispose();
}, CancellationToken.None, options, this.uiSyncContext);
}
}

Votre modèle ou de contrôleur de classe devrait être dérivé de cette classe abstraite. Vous pouvez utiliser n'importe quel motif (tâches ou gérés manuellement threads d'arrière-plan) et l'utilisation de ces méthodes comme ceci:

public void MethodThatCalledFromBackroundThread()
{
this.RunOnGuiThread(() => {
//Do something over UI controls
});
}

Tâches exemple:

var task = Task.Factory.StartNew(delegate
{
//Background code
this.RunOnGuiThread(() => {
//Do something over UI controls
});
});
this.CompleteTask(task, TaskContinuationOptions.OnlyOnRanToCompletion, delegate
{
//Code that can safely use UI controls
});

Je préfère celui-ci:

private void UpdateNowProcessing(string nowProcessing)
{
if (this.InvokeRequired)
{
Action<string> d = UpdateNowProcessing;
Invoke(d, nowProcessing);
}
else
{
this.progressDialog.Next(nowProcessing);
}            
}

Mettre en commun certaines variables dans une classe séparée pour conserver la valeur.

Exemple:

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 < 10; i++)
{
//Statements here
}
//Set the result in the status variable
d1.status = "Task done";
}
}

Dans mon cas (WPF) la solution est simple: les

private void updateUI()
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.BeginInvoke(updateUI);
return;
}
//Update any number of controls here
}

Approche générale est comme:

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(() => 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<Control, string> setText =
(control, text) => control.Text = text;
}
}

Explication:

La réponse est assez comme cette une. Mais utilise plus propre (comme pour moi) et plus récents de la syntaxe. Le point est InvokeRequired propriété de control. Il obtient une valeur indiquant si l'appelant doit appeler une méthode invoke lors de la prise des appels de méthode pour le contrôle parce que l'appelant est sur un autre thread que le contrôle a été créé. Donc, si nous appelons control.SetText("some text") sur le même thread control a été créé, c'est OK pour Text que ce control.Text = text. Mais sur un autre thread, il provoque System.InvalidOperationException si on doit l'appeler une méthode via control.Invoke(...) pour définir Text sur le fil control a été créé.

Pour atteindre cet objectif dans WPF, je le fais de la façon suivante.

 new Thread(() => 
{
while (...)
{
SomeLabel.Dispatcher.BeginInvoke((Action)(() => SomeLabel.Text = ...));
}
}).Start();