Wie kann ich aktualisieren Sie visual control-Eigenschaften (TextBlock.text) in einer Schleife?

Wenn Sie wirklich wollen die quick-and-dirty-Implementierung und kümmern sich nicht um die Pflege des Produkts in der Zukunft oder über die Benutzer-Erfahrung haben, können Sie einfach fügen Sie einen Verweis auf System.Windows.Formen und rufen 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();
}

Der Nachteil ist, dass es wirklich wirklich schlecht. Du gehst zu sperren der Benutzeroberfläche während der Thread.Sleep(), das nervt die Nutzer, und Sie könnten am Ende mit unvorhersehbaren Ergebnissen, abhängig von der Komplexität des Programms (die ich gesehen habe eine Anwendung, wo die zwei Methoden ausgeführt wurden, die auf dem UI-thread, jeder Aufruf von DoEvents() wiederholt...).

Dies ist, wie es getan werden sollte:

1. Jeder Zeit Ihre Anwendung zu warten, dass etwas passiert (also ein Datenträger Lesen, eine web-service-Aufruf, oder ein Sleep()), es sollte auf einer separaten thread.
2. Sie sollten nicht legen Sie TextBlock.Text manuell ein - binden Sie auf eine Eigenschaft und die INotifyPropertyChanged implementieren.

Hier ist ein Beispiel zeigt die Funktionalität, die Sie gebeten haben. Es dauert nur ein paar Sekunden länger dauern zu schreiben, und es ist so viel einfacher, mit zu arbeiten - und es nicht sperren, bis der Benutzeroberfläche.

Xaml:

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

CodeBehind:

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

Den code könnte scheinen ein bisschen kompliziert, aber es ist ein Grundstein von WPF, und es kommt zusammen mit ein bisschen übung - es lohnt zu lernen.

InformationsquelleAutor Greg Sansom

Dies ist, wie Sie es tun würde, in der Regel:

ThreadPool.QueueUserWorkItem(ignored =>
    {
        for (int i = 0; i < 50; i++) {
            System.Threading.Thread.Sleep(100);
            myTextBlock.Dispatcher.BeginInvoke(
                new Action(() => myTextBlock.Text = i.ToString()));
        }
    });

Diese Delegierten die operation zu einem worker-thread-pool, mit dessen Hilfe der UI-thread, um Nachrichten zu verarbeiten (und hält die UI einfrieren). Weil der thread keinen Zugriff myTextBlock direkt, es muss BeginInvoke.

Obwohl dieser Ansatz ist nicht "der WPF-Weg", Dinge zu tun, es ist nichts falsch mit ihm (und in der Tat, ich glaube nicht, dass es keine alternative mit diesem kleinen code). Aber einen anderen Weg, Dinge zu tun, die gehen würden, wie diese:

1. Binden die Text des TextBlock auf eine Eigenschaft eines Objektes, die INotifyPropertyChanged
2. In der Schleife, setzen Sie diese Eigenschaft auf den gewünschten Wert; die änderungen werden propagiert, um die Benutzeroberfläche automatisch
3. Keine Notwendigkeit für threads BeginInvoke oder sonst etwas

Wenn Sie bereits ein Objekt und die UI zugreifen kann, dies ist so einfach wie das schreiben Text="{Binding MyObject.MyProperty}".

Update: Zum Beispiel, nehmen wir an, Sie haben diese:

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

Die Bindung erfolgen würde, wie dies in XAML:

<TextBlock Text="{Binding PropertyName.Number}" />

InformationsquelleAutor Jon

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

Ausführen der oben genannten code in einem hintergrund-worker-Komponente und eine Bindung updatesourcetrigeer als propertychanged werden die änderungen sofort in der UI-Steuerelement.

InformationsquelleAutor Padmanaban