• [WPF] 跨线程控制窗体UI


    呼叫线程无法存取此对象

    在WPF、WinForm这些应用程序中,必需是UI线程才能控制窗体。如果像是下列的范例程序一样,使用了非UI线程来控制窗体,那就会看到内容为「呼叫线程无法存取此对象,因为此对象属于另外一个线程」的InvalidOperationException例外错误。

    <Window x:Class="WpfApplication1.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="MainWindow" Height="350" Width="525">
        <TextBlock x:Name="TextBlock001"  FontSize="72" />
    </Window>
    
    namespace WpfApplication1
    {
        public partial class MainWindow : Window
        {
            // Fields
            private readonly System.Threading.Timer _timer = null;
    
            private int _count = 0;
                   
    
            // Constructors
            public MainWindow()
            {
                // Base
                InitializeComponent();
    
                // Timer
                _timer = new System.Threading.Timer(this.Timer_Ticked, null, 0, 100);
            }
    
    
            // Handlers
            private void Timer_Ticked(Object stateInfo)
            {
                _count++;            
                this.TextBlock001.Text = _count.ToString();
            }
        }
    }
    

    使用Dispatcher对象跨线程

    非UI线程如果要控制窗体,必须要将控制窗体的程序逻辑封装成为委派,再将这个委派提交给UI线程去执行,藉由这个流程非UI线程就能够跨线程控制窗体。而在WPF应用程序中,非UI线程可以透过WPF提供的Dispatcher对象来提交委派。

    参考数据:

    MSDN - 使用 Dispatcher 建置响应性更佳的应用程序
    昏睡领域 - [Object-oriented] 线程

    <Window x:Class="WpfApplication2.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="MainWindow" Height="350" Width="525">
        <TextBlock x:Name="TextBlock001"  FontSize="72" />
    </Window>
    
    namespace WpfApplication2
    {
        public partial class MainWindow : Window
        {
            // Fields
            private readonly System.Threading.Timer _timer = null;
    
            private int _count = 0;
    
    
            // Constructors
            public MainWindow()
            {
                // Base
                InitializeComponent();
    
                // Timer
                _timer = new System.Threading.Timer(this.Timer_Ticked, null, 0, 100);
            }
    
    
            // Handlers
            private void Timer_Ticked(Object stateInfo)
            {
                _count++;
                Action methodDelegate = delegate()
                {
                    this.TextBlock001.Text = _count.ToString();
                };
                this.Dispatcher.BeginInvoke(methodDelegate);            
            }
        }
    }
    

    使用SynchronizationContext类别跨线程

    在WPF应用程序中可以透过WPF提供的Dispatcher对象来完成跨线程工作,而在WinForm应用程序中则是需要透过WinForm提供的Invoke方法、BeginInvoke方法来完成跨线程工作。以此类推能得知Silverlight、Windows Phone等等应用程序平台,也会提供对应的解决方案来让开发人员完成跨线程工作。

    每个应用程序平台都提供各自的跨线程解决方案这件事,对于开发共享函式库、框架的开发人员来说,就代表了要花不少的精力才能让函式库、框架适用于各种应用程序平台。为了整合不同平台跨线程的解决方案,在.NET Framework中将这些解决方案抽象化为统一的SynchronizationContext类别,再由各个应用程序平台去提供对应的实作。自此之后开发共享函式库、共享框架的开发人员,只要透过SynchronizationContext类别,就能完成适用于不同平台的跨线程功能。

    必须值得一提的是,SynchronizationContext类别设计出来之后,应用范围已经不单单适用于跨线程控制窗体,在设计软件架构线程模型之类的场合,也会发现它的身影,非常推荐有兴趣的开发人员找相关的资料学习。

    参考数据:

    MSDN - 不可或缺的 SynchronizationContext

    <Window x:Class="WpfApplication3.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="MainWindow" Height="350" Width="525">
        <TextBlock x:Name="TextBlock001"  FontSize="72" />
    </Window>
    
    namespace WpfApplication3
    {
        public partial class MainWindow : Window
        {
            // Fields
            private readonly System.Threading.SynchronizationContext _syncContext = null;
    
            private readonly System.Threading.Timer _timer = null;
    
            private int _count = 0;
    
    
            // Constructors
            public MainWindow()
            {
                // Base
                InitializeComponent();
    
                // SyncContext
                _syncContext = System.Threading.SynchronizationContext.Current;
    
                // Timer
                _timer = new System.Threading.Timer(this.Timer_Ticked, null, 0, 100);
            }
    
    
            // Handlers
            private void Timer_Ticked(Object stateInfo)
            {
                _count++;
                System.Threading.SendOrPostCallback methodDelegate = delegate(object state)
                {
                    this.TextBlock001.Text = _count.ToString();
                };
                _syncContext.Post(methodDelegate, null);
            }
        }
    }
    

    跨线程Binding数据对象

    在WPF应用程序中提供了Binding数据对象的功能,透过这个功能就能将数据对象的属性直接呈现在窗体上。而数据对象如果有实作INotifyPropertyChanged接口、INotifyCollectionChanged接口...等等更新通知接口,就可以透过事件的方式用来通知资料内容更新,例如说:INotifyPropertyChanged接口就是藉由PropertyChanged事件来通知数据内容更新。

    Binding功能会去处理这些数据内容更新事件,并且在收到这些事件之后去取得数据内容来更新窗体。而也因为Binding功能会去更新窗体,所以引发这些通知事件的线程必须是UI线程,这样才能让整个Binding功能正常运作,不会产生「呼叫线程无法存取此对象,因为此对象属于另外一个线程」的InvalidOperationException例外错误。

    <Window x:Class="WpfApplication4.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="MainWindow" Height="350" Width="525">
        <TextBlock x:Name="TextBlock001"  FontSize="72" Text="{Binding Path=Count}" />
    </Window>
    
    namespace WpfApplication4
    {
        public partial class MainWindow : Window
        {
            // Fields
            private readonly System.Threading.SynchronizationContext _syncContext = null;
    
            private readonly DataObject _dataObject = null;
    
    
            // Constructors
            public MainWindow()
            {
                // Base
                InitializeComponent();
    
                // SyncContext
                _syncContext = System.Threading.SynchronizationContext.Current;
    
                // DataObject
                _dataObject = new DataObject();
                _dataObject.SetSynchronizationContext(_syncContext);
    
                // DataContext
                this.DataContext = _dataObject;
            }
        }
    }
    
    namespace WpfApplication4
    {
        public class DataObject : INotifyPropertyChanged
        {
            // Fields     
            private readonly System.Threading.Timer _timer = null;
    
            private System.Threading.SynchronizationContext _syncContext = null;
    
            private int _count = 0;
    
    
            // Constructors
            public DataObject()
            {
                // Timer
                _timer = new System.Threading.Timer(this.Timer_Ticked, null, 0, 100);
            }
            
    
            // Properties
            public int Count
            {
                get { return _count; }
                set
                {
                    _count = value;
                    this.OnPropertyChanged("Count");
                }
            }
    
    
            // Methods        
            public void SetSynchronizationContext(System.Threading.SynchronizationContext syncContext)
            {
                // SyncContext
                _syncContext = syncContext;
            }
    
    
            // Handlers
            private void Timer_Ticked(Object stateInfo)
            {
                this.Count++;
            }
    
    
            // Events
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string name)
            {
                System.Threading.SendOrPostCallback methodDelegate = delegate(object state)
                {
                    var handler = this.PropertyChanged;
                    if (handler != null)
                    {
                        handler(this, new PropertyChangedEventArgs(name));
                    }
                };
                _syncContext.Post(methodDelegate, null);            
            }
        }
    }
    

    前一个跨线程Binding数据对象范例中,做为数据对象的DataObject对象,设计上很理想的在数据对象内部透过SynchronizationContext类别完成跨线程的工作。而在真实的开发环境中,数据对象常常是由另外一个系统所提供、并且无法改写(也不应该改写,因为改写代表将显示功能污染进其他系统),这时可以套用装饰者模式(Decorator Pattern)的「精神」,来完成跨线程Binding数据对象的功能。

    <Window x:Class="WpfApplication5.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="MainWindow" Height="350" Width="525">
        <TextBlock x:Name="TextBlock001"  FontSize="72" Text="{Binding Path=Count}" />
    </Window>
    
    namespace WpfApplication5
    {
        public partial class MainWindow : Window
        {
            // Fields
            private readonly System.Threading.SynchronizationContext _syncContext = null;
    
            private readonly DataObject _dataObject = null;
    
            private readonly DataObjectDecorator _dataObjectDecorator = null;
    
    
            // Constructors
            public MainWindow()
            {
                // Base
                InitializeComponent();
    
                // SyncContext
                _syncContext = System.Threading.SynchronizationContext.Current;
    
                // DataObject
                _dataObject = new DataObject();
    
                // DataObjectDecorator
                _dataObjectDecorator = new DataObjectDecorator(_dataObject);
                _dataObjectDecorator.SetSynchronizationContext(_syncContext);
    
                // DataContext
                this.DataContext = _dataObjectDecorator;
            }
        }
    }
    
    namespace WpfApplication5
    {
        public class DataObject : INotifyPropertyChanged
        {
            // Fields     
            private readonly System.Threading.Timer _timer = null;
    
            private int _count = 0;
    
    
            // Constructors
            public DataObject()
            {
                // Timer
                _timer = new System.Threading.Timer(this.Timer_Ticked, null, 0, 100);
            }
    
    
            // Properties
            public int Count
            {
                get { return _count; }
                set
                {
                    _count = value;
                    this.OnPropertyChanged("Count");
                }
            }
    
    
            // Handlers
            private void Timer_Ticked(Object stateInfo)
            {
                this.Count++;
            }
    
    
            // Events
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string name)
            {
                var handler = this.PropertyChanged;
                if (handler != null)
                {
                    handler(this, new PropertyChangedEventArgs(name));
                }
            }
        }
    }
    
    namespace WpfApplication5
    {
        public class DataObjectDecorator : INotifyPropertyChanged
        {
            // Fields
            private readonly DataObject _dataObject = null;
    
            private System.Threading.SynchronizationContext _syncContext = null;
    
    
            // Constructors
            public DataObjectDecorator(DataObject dataObject)
            {
                // DataObject
                _dataObject = dataObject;
                _dataObject.PropertyChanged += this.DataObject_PropertyChanged;
            }
    
    
            // Properties
            public int Count
            {
                get { return _dataObject.Count; }
                set { _dataObject.Count = value; }
            }
    
    
            // Methods        
            public void SetSynchronizationContext(System.Threading.SynchronizationContext syncContext)
            {
                // SyncContext
                _syncContext = syncContext;
            }
    
    
            // Handlers
            private void DataObject_PropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                System.Threading.SendOrPostCallback methodDelegate = delegate(object state)
                {
                    this.OnPropertyChanged(e.PropertyName);
                };
                _syncContext.Post(methodDelegate, null);
            }
    
    
            // Events
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string name)
            {
                var handler = this.PropertyChanged;
                if (handler != null)
                {
                    handler(this, new PropertyChangedEventArgs(name));
                }
            }
        }
    }
    

    跨线程Binding数据对象(.NET 3.5之后、包含.NET3.5)

    上列套用装饰者模式(Decorator Pattern)的「精神」,来完成跨线程Binding数据对象的功能,其实要加入的唯一功能,就是将INotifyPropertyChanged接口的PropertyChanged事件,由非UI线程转换为UI线程来通知数据内容更新。这样的设计方式在对象种类少、对象属性不多的情景是可行的,但当对象属性多的场合,例如说有50个对象属性,那套用装饰者模式就必须要装饰出50个对象属性,这听起来光是打字工作量就会让人崩溃,一整个是很不符合人性的设计。

    最近经由老狗大大 (http://www.dotblogs.com.tw/sanctuary/)的提点,发现在.NET3.5之后、包含.NET3.5,在Binding数据对象的设计上,有了一些新的变更。其中一个变更就是在Binding数据对象的功能中,非UI线程所引发的资料内容更新事件,在背景会被转换为UI线程去执行。经由这样的特性,开发人员就不需要硬套装饰者模式来建立转换线程的数据对象,直接使用数据对象原生的线程就可以,这样能够减低程序对象的复杂度、并且大幅提升开发的效率。

    但要特别说的是,Binding功能这个跨线程的特性,虽然经由下列的范例程序验证是能够正常运作的,但在网络上或是MSDN中没有看到相关的技术文件(或是我没找到@@)。开发人员在使用这个特性做为设计依据时,必须要小心斟酌的使用。

    参考数据:

    WPF, Data Binding & Multithreading

    <Window x:Class="WpfApplication6.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="MainWindow" Height="350" Width="525">
        <TextBlock x:Name="TextBlock001"  FontSize="72" Text="{Binding Path=Count}" />
    </Window>
    
    namespace WpfApplication6
    {
        public partial class MainWindow : Window
        {
            // Fields
            private readonly DataObject _dataObject = null;
    
    
            // Constructors
            public MainWindow()
            {
                // Base
                InitializeComponent();
    
                // DataObject
                _dataObject = new DataObject();
    
                // DataContext
                this.DataContext = _dataObject;
            }
        }
    }
    
    namespace WpfApplication6
    {
        public class DataObject : INotifyPropertyChanged
        {
            // Fields     
            private readonly System.Threading.Timer _timer = null;
    
            private int _count = 0;
    
    
            // Constructors
            public DataObject()
            {
                // Timer
                _timer = new System.Threading.Timer(this.Timer_Ticked, null, 0, 100);
            }
    
    
            // Properties
            public int Count
            {
                get { return _count; }
                set
                {
                    _count = value;
                    this.OnPropertyChanged("Count");
                }
            }
    
    
            // Handlers
            private void Timer_Ticked(Object stateInfo)
            {
                this.Count++;
            }
    
    
            // Events
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string name)
            {
                var handler = this.PropertyChanged;
                if (handler != null)
                {
                    handler(this, new PropertyChangedEventArgs(name));
                }
            }
        }
    }
    

    原始码下载

    原始码下载:ThreadBindingDemo.rar


  • 相关阅读:
    aa
    ECS上搭建Docker(CentOS7)
    mysql时间戳转日期
    rsync用法
    docker安装mysql8
    使用Docker安装mysql,挂载外部配置和数据
    my.cnf
    Centos7通过yum安装jdk8
    maven添加本地包命令mvn install:install-file
    Mysql——查看数据库,表占用磁盘大小
  • 原文地址:https://www.cnblogs.com/clark159/p/3058667.html
Copyright © 2020-2023  润新知