Comment puis-je actualiser les propriétés de contrôle visuel (TextBlock.text) définies dans une boucle?

À chaque itération de boucle je veux visuellement mise à jour le texte d'un textblock. Mon problème est que la fenêtre WPF ou de contrôle n'est pas visuellement de rafraîchissement jusqu'à ce que la boucle est terminée.

        for (int i = 0; i < 50; i++)
        {
            System.Threading.Thread.Sleep(100);
            myTextBlock.Text = i.ToString();                
        }

En VB6, je voudrais appeler la fonction DoEvents() ou de contrôle.actualiser. Pour le moment je voudrais juste un moyen rapide et sale solution similaire à la fonction DoEvents(), mais j'aimerais aussi savoir sur les solutions de rechange ou de la "bonne" façon de faire. Est-il une liaison simple déclaration, je pourrais ajouter? Quelle est la syntaxe?
Merci à l'avance.

source d'informationauteur DeveloperDan

Si vous vraiment veux du rapide et sale de la mise en œuvre et ne se soucient pas de maintenir le produit à l'avenir ou à propos de l'expérience de l'utilisateur, vous pouvez simplement ajouter une référence à System.De Windows.Formes et appel System.Windows.Forms.Application.DoEvents():

for (int i = 0; i < 50; i++)
{
    System.Threading.Thread.Sleep(100);
    MyTextBlock.Text = i.ToString();
    System.Windows.Forms.Application.DoEvents();
}

L'inconvénient est que c'est vraiment vraiment mauvais. Vous allez à verrouiller l'INTERFACE utilisateur au cours de la discussion.Sleep(), qui agace les utilisateurs, et vous pouvez vous retrouver avec des résultats imprévisibles en fonction de la complexité du programme (j'ai vu une application où les deux méthodes ont été en cours d'exécution sur le thread de l'INTERFACE utilisateur, chacun appelant la fonction DoEvents() à plusieurs reprises...).

C'est comment il devrait être fait:

Tout moment de votre demande d'attendre que quelque chose arrive (c'est à dire une lecture du disque, un appel de service web, ou un Sleep()), il devrait être sur un thread séparé.
Vous ne devez pas définir TextBlock.Texte manuellement le lier à une propriété et implémenter INotifyPropertyChanged.

Voici un exemple montrant la fonctionnalité que vous avez demandé. Il ne prend que quelques secondes de plus à écrire et c'est tellement plus facile de travailler avec et il n'a pas de verrouillage de l'INTERFACE utilisateur.

Xaml:

<StackPanel>
    <TextBlock Name="MyTextBlock" Text="{Binding Path=MyValue}"></TextBlock>
    <Button Click="Button_Click">OK</Button>
</StackPanel>

Le code-behind:

public partial class MainWindow : Window, INotifyPropertyChanged
{
    public MainWindow()
    {
        InitializeComponent();
        this.DataContext = this;
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        Task.Factory.StartNew(() =>
        {
            for (int i = 0; i < 50; i++)
            {
                System.Threading.Thread.Sleep(100);
                MyValue = i.ToString();
            }
        });
    }

    private string myValue;
    public string MyValue
    {
        get { return myValue; }
        set
        {
            myValue = value;
            RaisePropertyChanged("MyValue");
        }
    }

    private void RaisePropertyChanged(string propName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propName));
    }
    public event PropertyChangedEventHandler PropertyChanged;
}

Le code peut sembler un peu compliqué, mais c'est une pierre angulaire de WPF, et il est livré avec un peu de pratique, c'est bien la peine d'apprendre.

4

C'est comment vous le feriez normalement:
```
ThreadPool.QueueUserWorkItem(ignored =>
    {
        for (int i = 0; i < 50; i++) {
            System.Threading.Thread.Sleep(100);
            myTextBlock.Dispatcher.BeginInvoke(
                new Action(() => myTextBlock.Text = i.ToString()));
        }
    });
```
Cette délégués de l'opération à un travailleur de pool de threads, ce qui permet à votre thread d'INTERFACE utilisateur pour traiter les messages (et maintient votre INTERFACE utilisateur à partir de zéro). Parce que le thread ne peut pas accéder à myTextBlock directement, il doit utiliser BeginInvoke.

Bien que cette approche n'est pas "le WPF façon" de faire les choses, il n'y a rien de mal à cela (et en effet, je ne crois pas qu'il existe une alternative avec ce petit code). Mais une autre façon de faire les choses iraient comme ceci:
1. Lier la Text de la TextBlock à une propriété d'un objet qui implémente INotifyPropertyChanged
2. De l'intérieur de la boucle, définissez cette propriété à la valeur que vous voulez; les modifications sont propagées dans l'INTERFACE utilisateur automatiquement
3. Pas nécessaire pour les threads, BeginInvokeou quoi que ce soit d'autre
Si vous disposez déjà d'un objet et l'INTERFACE utilisateur a accès, c'est aussi simple que l'écriture Text="{Binding MyObject.MyProperty}".

Mise à jour: Par exemple, supposons que vous avez ceci:
```
class Foo : INotifyPropertyChanged //you need to implement the interface
{
    private int number;

    public int Number {
        get { return this.number; }
        set {
            this.number = value;
            //Raise PropertyChanged here
        }
    }
}

class MyWindow : Window
{
    public Foo PropertyName { get; set; }
}
```
La liaison serait fait comme ceci dans le code XAML:
```
<TextBlock Text="{Binding PropertyName.Number}" />
```
4

J'ai essayé la solution exposée ici, et ça n'a pas fonctionné pour moi jusqu'à ce que j'ai ajouté ce qui suit.

Créer une méthode d'extension et assurez-vous de référence contenant l'assemblage de votre projet.
```
public static void Refresh(this UIElement uiElement)
    {
        uiElement.Dispatcher.Invoke(DispatcherPriority.Background, new Action( () => { }));
    }
```
Ensuite l'appeler juste après RaisePropertyChanged.
```
RaisePropertyChanged("MyValue");
myTextBlock.Refresh();
```
Qui force l'UIThread de prendre le contrôle pour les petits tout et expédier les modifications en attente sur le UIElement.
1

Vous pouvez faire Répartiteur.BeginInvoke afin de faire un thread contexte-commutateur, de sorte que le thread de rendu pourrait faire son travail.
Cependant, ce n'est pas la bonne façon de faire pour ces choses. Vous devriez utiliser l'Animation + de Liaison pour des choses comme ça, comme c'est le hack de façon libre de faire ce genre de choses dans WPF.
0
```
for (int i = 0; i < 50; i++)
        {
            System.Threading.Thread.Sleep(100);
            myTextBlock.Text = i.ToString();                
        }
```
Exécute le code ci-dessus à l'intérieur d'un contexte travailleur composant et à l'aide d'une liaison updatesourcetrigeer comme propertychanged reflètent les modifications immédiatement dans l'INTERFACE utilisateur de contrôle

Vous devez vous connecter pour publier un commentaire.