How to update a progress bar while running on the UI thread
I have ProgressBar
and TreeView
.
I filled in with a TreeView
bunch of data as soon as it is applied. I run by visual tree
TreeView
basically making it generate each one TreeViewItems
. I would like to ProgressBar
show you how this happens.
This is the behavior code that I am running to create TreeViewItems
. It starts processing items if the property is ItemsLoaded
set to true. It, in turn, updates the property in the singleton class to update the progress.
public class TreeViewBehaviors
{
public static readonly DependencyProperty ItemsLoadedProperty =
DependencyProperty.RegisterAttached("ItemsLoaded", typeof(bool), typeof(TreeViewBehaviors),
new FrameworkPropertyMetadata(false, new PropertyChangedCallback(OnItemsLoadedPropertyChanged)));
public static bool GetItemsLoaded(DependencyObject obj)
{
return (bool)obj.GetValue(ItemsLoadedProperty);
}
public static void SetItemsLoaded(DependencyObject obj, bool value)
{
obj.SetValue(ItemsLoadedProperty, value);
}
private static void OnItemsLoadedPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
if ((bool)e.NewValue)
{
GetTotalNTreeViewItems((TreeView)sender, sender);
}
}
public static readonly DependencyProperty NodesProcessedProperty =
DependencyProperty.RegisterAttached("NodesProcessed", typeof(int), typeof(TreeViewBehaviors),
new FrameworkPropertyMetadata(default(int), new PropertyChangedCallback(OnNodesProcessedPropertyChanged)));
public static int GetNodesProcessed(DependencyObject obj)
{
return (int)obj.GetValue(NodesProcessedProperty);
}
public static void SetNodesProcessed(DependencyObject obj, int value)
{
if (GetNodesProcessed(obj) != value)
{
obj.SetValue(NodesProcessedProperty, value);
}
}
private static void OnNodesProcessedPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
if (e.NewValue != null)
{
double trouble = Math.Round(((GetProgressMaximum(sender) / GetTotalNodesToProcess(sender)) * (int)e.NewValue), 1);
TreeViewSingletonClass.Instance.DisplayProgress = trouble;
}
}
public static readonly DependencyProperty TotalNodesToProcessProperty =
DependencyProperty.RegisterAttached("TotalNodesToProcess", typeof(double), typeof(TreeViewBehaviors),
new FrameworkPropertyMetadata(default(double)));
public static double GetTotalNodesToProcess(DependencyObject obj)
{
return (double)obj.GetValue(TotalNodesToProcessProperty);
}
public static void SetTotalNodesToProcess(DependencyObject obj, double value)
{
obj.SetValue(TotalNodesToProcessProperty, value);
}
public static readonly DependencyProperty ProgressMaximumProperty =
DependencyProperty.RegisterAttached("ProgressMaximum", typeof(double), typeof(TreeViewBehaviors),
new FrameworkPropertyMetadata(default(double)));
public static double GetProgressMaximum(DependencyObject obj)
{
return (double)obj.GetValue(ProgressMaximumProperty);
}
public static void SetProgressMaximum(DependencyObject obj, double value)
{
obj.SetValue(ProgressMaximumProperty, value);
}
private static void GetTotalNTreeViewItems(ItemsControl container, DependencyObject sender)
{
if (container != null)
{
container.ApplyTemplate();
ItemsPresenter itemsPresenter = (ItemsPresenter)container.Template.FindName("ItemsHost", container);
if (itemsPresenter != null)
{
itemsPresenter.ApplyTemplate();
}
else
{
// The Tree template has not named the ItemsPresenter,
// so walk the descendents and find the child.
itemsPresenter = FindVisualChild<ItemsPresenter>(container);
if (itemsPresenter == null)
{
container.UpdateLayout();
itemsPresenter = FindVisualChild<ItemsPresenter>(container);
}
}
Panel itemsHostPanel = (Panel)VisualTreeHelper.GetChild(itemsPresenter, 0);
// Ensure that the generator for this panel has been created.
UIElementCollection children = itemsHostPanel.Children;
for (int i = 0, count = container.Items.Count; i < count; i++)
{
TreeViewItem subContainer = (TreeViewItem)container.ItemContainerGenerator.ContainerFromIndex(i);
GetTotalNTreeViewItems(subContainer, sender);
SetNodesProcessed(sender, GetNodesProcessed(sender) + 1);
}
}
}
private static T FindVisualChild<T>(Visual visual) where T : Visual
{
for (int i = 0; i < VisualTreeHelper.GetChildrenCount(visual); i++)
{
Visual child = (Visual)VisualTreeHelper.GetChild(visual, i);
if (child != null)
{
T correctlyTyped = child as T;
if (correctlyTyped != null)
return correctlyTyped;
T descendent = FindVisualChild<T>(child);
if (descendent != null)
return descendent;
}
}
return null;
}
}
Singleton Class
public class TreeViewSingletonClass : INotifyPropertyChanged
{
private static double m_DisplayProgress = 0;
public double DisplayProgress
{
get { return m_DisplayProgress; }
set
{
if (m_DisplayProgress == value)
return;
m_DisplayProgress = value;
NotifyPropertyChanged();
}
}
private static TreeViewSingletonClass m_Instance;
public static TreeViewSingletonClass Instance
{
get
{
if (m_Instance == null)
m_Instance = new TreeViewSingletonClass();
return m_Instance;
}
}
private TreeViewSingletonClass(){}
public event PropertyChangedEventHandler PropertyChanged;
private void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
{
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
XAML:
<ProgressBar Grid.Column="2" Grid.Row="1" Margin="5"
Width="20" Height="150"
VerticalAlignment="Top"
Value="{Binding Source={x:Static helpers:TreeViewSingletonClass.Instance}, Path=DisplayProgress}"
Maximum="{Binding ProgressMaximum}" />
My problem is that everything is handled correctly, just ProgressBar
not updated to the very end. I understand that they both work inline on the same thing UI thread
, so there will be a problem.
So my question is, both of these processes are running on the same thread, how can I update this one ProgressBar
.
[EDIT]
This WPF is UserControl
in WinForm
ElementHost
, I just put the following in WinForm so that I can accessApplication.Current
if ( null == System.Windows.Application.Current )
{
new System.Windows.Application();
}
After trying to implement Xavier's second suggestion: Divide the work into smaller pieces and keep them separate with the dispatcher using BeginInvoke (for example, convert the loop body to a dispatcher call)
So, inside the loop, for
I stuck with the following:
for (int i = 0, count = container.Items.Count; i < count; i++)
{
Application.Current.Dispatcher.BeginInvoke(new Action(delegate()
{
TreeViewItem subContainer = (TreeViewItem)container.ItemContainerGenerator.ContainerFromIndex(i);
GetTotalNTreeViewItems(subContainer, sender);
SetNodesProcessed(sender, GetNodesProcessed(sender) + 1);
}));
}
Unfortunately it didn't work, there must be something wrong.
source to share
The UI thread in WPF uses a Dispatcher to schedule and process all UI updates. The dispatcher basically maintains a queue of tasks to run on a thread. If you monopolize the thread, the queue will simply return until you give it a chance to start again.
There are several potential solutions to your problem. Here are a couple ...
Working on a separate thread
The solution I'm most likely going to look at first is moving your long running task to a different thread instead of intercepting the UI thread. Any updates that need to be made to the UI from this thread can be done by going through the Manager for the UI thread using the BeginInvoke method . For example, if I wanted to add 1 to the value of a progress bar, I could do something like this:
Dispatcher.BeginInvoke(new Action(delegate() { mProgress.Value += 1.0; }));
Note. Make sure your worker thread has a way to refer to the dispatcher from the UI thread. Do not call Dispatcher.CurrentDispatcher
from a worker thread, or instead you will get a dispatcher for that thread that cannot access the UI. Instead, you can stream to the dispatcher, or access it through an element or property that has been configured from the UI thread.
Use a dispatcher to share the UI thread
If you really want to do all the work on the UI thread for one reason or another (which you can if you're doing a lot of visual tree or other UI-focused tasks), consider one of the following:
-
Divide the work into smaller pieces and split them up in turns with the dispatcher using BeginInvoke . Make sure the priority is low enough so that UI updates don't get stuck all the way. For example:
for (int i = 0; i < 100; ++i) { Dispatcher.CurrentDispatcher.BeginInvoke(new Action(delegate() { mProgress.Value += 1.0; // Only sleeping to artificially simulate a long running operation Thread.Sleep(100); }), DispatcherPriority.Background); }
-
Process the dispatcher queue as needed during extended run. Below is an example of creating a method
DoEvents
for this purpose in the Remarks section of the documentation for the PushFrame method .
source to share