在WPF中，如何在另一个线程（另一个Dispatcher）上设置Window构建的窗口所有者

问题描述 投票：2回答：4

我得到以下异常：InvalidOperationException：调用线程无法访问此对象，因为另一个线程拥有它。

当我尝试设置一个窗口的所有者，该窗口是在除了所有者之外的另一个线程上构建的。

我知道我只能从正确的线程更新UI对象，但为什么我不能只是设置所有者来自另一个线程？我可以用另一种方式吗？我想让进度窗口成为唯一可以输入条目的窗口。

这是发生错误的代码部分：

    public partial class DlgProgress : Window
{
    // ******************************************************************
    private readonly DlgProgressModel _dlgProgressModel;

    // ******************************************************************
    public static DlgProgress CreateProgressBar(Window owner, DlgProgressModel dlgProgressModel)
    {
        DlgProgress dlgProgressWithProgressStatus = null;
        var listDlgProgressWithProgressStatus = new List<DlgProgress>();
        var manualResetEvent = new ManualResetEvent(false);
        var workerThread = new ThreadEx(() => StartDlgProgress(owner, dlgProgressModel, manualResetEvent, listDlgProgressWithProgressStatus));
        workerThread.Thread.SetApartmentState(ApartmentState.STA);
        workerThread.Start();
        manualResetEvent.WaitOne(10000);
        if (listDlgProgressWithProgressStatus.Count > 0)
        {
            dlgProgressWithProgressStatus = listDlgProgressWithProgressStatus[0];
        }

        return dlgProgressWithProgressStatus;
    }

    // ******************************************************************
    private static void StartDlgProgress(Window owner, DlgProgressModel progressModel, ManualResetEvent manualResetEvent, List<DlgProgress> listDlgProgressWithProgressStatus)
    {
        DlgProgress dlgProgress = new DlgProgress(owner, progressModel);
        listDlgProgressWithProgressStatus.Add(dlgProgress);
        dlgProgress.ShowDialog();
        manualResetEvent.Set();
    }

    // ******************************************************************
    private DlgProgress(Window owner, DlgProgressModel dlgProgressModel)
    {
        if (owner == null)
        {
            throw new ArgumentNullException("Owner cannot be null");
        }

        InitializeComponent();
        this.Owner = owner; // Can't another threads owns it exception
c# wpf multithreading dispatcher
4个回答
2
投票

上面的答案是正确的。但我会试着总结一下：

     [DllImport("user32.dll")]
     static extern int SetWindowLong(IntPtr hwnd, int index, int newStyle);

  public static void SetOwnerWindowMultithread(IntPtr windowHandleOwned, IntPtr intPtrOwner)
  {
            if (windowHandleOwned != IntPtr.Zero && intPtrOwner != IntPtr.Zero)
            {
                SetWindowLong(windowHandleOwned, GWL_HWNDPARENT, intPtrOwner.ToInt32());
            }
 }

获取WPF处理程序的代码：

 public static IntPtr GetHandler(Window window)
        {
            var interop = new WindowInteropHelper(window);
            return interop.Handle;
        }

请注意，应在设置所有者调用之前初始化窗口！ （可以在window.Loaded或window.SourceInitialized事件中设置）

 var handler = User32.GetHandler(ownerForm);

        var thread = new Thread(() =>
        {
                var window = new DialogHost();
                popupKeyboardForm.Show();
                SetOwnerWindowMultithread(GetHandler(popupKeyboardForm), handler);
                Dispatcher.Run();
        });

        thread.IsBackground = true;
        thread.Start();

也可以使用SetParent。比你不需要转换处理程序：

[DllImport("user32.dll", SetLastError = true)]
static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndNewParent);

请注意，父级和所有者具有不同的含义。 Win32 window Owner vs window Parent?

2
投票

我是根据Hans Passant的建议制作的。重要的是，我怀疑这段代码只能在32位上运行，因为我在IntPtr上使用“ToInt32”。

这是代码：

WindowHelper功能：

        // ******************************************************************
    private const int GWL_HWNDPARENT = -8; // Owner --> not the parent

    [DllImport("user32.dll")]
    static extern int SetWindowLong(IntPtr hwnd, int index, int newStyle);

    // ******************************************************************
    public static void SetOwnerWindow(Window owned, IntPtr intPtrOwner)
    {
        try
        {
            IntPtr windowHandleOwned = new WindowInteropHelper(owned).Handle;
            if (windowHandleOwned != IntPtr.Zero && intPtrOwner != IntPtr.Zero)
            {
                SetWindowLong(windowHandleOwned, GWL_HWNDPARENT, intPtrOwner.ToInt32());
            }
        }
        catch (Exception ex)
        {
            Debug.Print(ex.Message);
        }
    }

    // ******************************************************************

通话功能：

  using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Threading;
using HQ.Util.General.Threading;
using HQ.Util.Unmanaged;

namespace HQ.Wpf.Util.Dialog
{
    /// <summary>
    /// Interaction logic for DlgProgressWithProgressStatus.xaml
    /// </summary>
    public partial class DlgProgress : Window
    {
        // ******************************************************************
        private readonly DlgProgressModel _dlgProgressModel;

        // ******************************************************************
        public static DlgProgress CreateProgressBar(Window owner, DlgProgressModel dlgProgressModel)
        {
            DlgProgress dlgProgressWithProgressStatus = null;
            var listDlgProgressWithProgressStatus = new List<DlgProgress>();
            var resetEvent = new ManualResetEvent(false);

            IntPtr windowHandleOwner = new WindowInteropHelper(owner).Handle;
            dlgProgressModel.Owner = owner;
            dlgProgressModel.IntPtrOwner = windowHandleOwner;

            var workerThread = new ThreadEx(() => StartDlgProgress(dlgProgressModel, resetEvent, listDlgProgressWithProgressStatus));
            workerThread.Thread.SetApartmentState(ApartmentState.STA);
            workerThread.Start();
            resetEvent.WaitOne(10000);
            if (listDlgProgressWithProgressStatus.Count > 0)
            {
                dlgProgressWithProgressStatus = listDlgProgressWithProgressStatus[0];
            }

            return dlgProgressWithProgressStatus;
        }

        // ******************************************************************
        private static void StartDlgProgress(DlgProgressModel progressModel, ManualResetEvent resetEvent, List<DlgProgress> listDlgProgressWithProgressStatus)
        {
            DlgProgress dlgProgress = new DlgProgress(progressModel);
            listDlgProgressWithProgressStatus.Add(dlgProgress);
            resetEvent.Set();
            dlgProgress.ShowDialog();
        }

        // ******************************************************************
        private DlgProgress(DlgProgressModel dlgProgressModel)
        {
            if (dlgProgressModel.Owner == null)
            {
                throw new ArgumentNullException("Owner cannot be null");
            }

            InitializeComponent();
            // this.Owner = owner; // Can't another threads owns it exception

            if (dlgProgressModel == null)
            {
                throw new ArgumentNullException("dlgProgressModel");
            }

            _dlgProgressModel = dlgProgressModel;
            _dlgProgressModel.Dispatcher = this.Dispatcher;
            _dlgProgressModel.PropertyChanged += _dlgProgressModel_PropertyChanged;
            DataContext = _dlgProgressModel;
        }

        // ******************************************************************
        // Should be call as a modal dialog
        private new void Show()
        {
            throw new Exception("Should only be used as modal dialog");
        }

        // ******************************************************************
        void _dlgProgressModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {

            //          if (e.PropertyName == "IsJobCanceled" || e.PropertyName == "IsJobCompleted" || e.PropertyName == "IsProgressCompleted")
            // Faster if we don't check strings and check condition directly 
            {
                if (_dlgProgressModel.HaveConditionToClose())
                {
                    if (_dlgProgressModel.IsJobCanceled == true)
                    {
                        SetDialogResult(false);
                    }
                    else
                    {
                        SetDialogResult(true);
                    }
                }
            }
        }

        // ******************************************************************
        private void SetDialogResult(bool result)
        {
            this._dlgProgressModel.Dispatcher.BeginInvoke(new Action(() =>
                {
                    this.DialogResult = result;
                }), DispatcherPriority.Background);
        }

        // ******************************************************************
        private bool _isFirstTimeLoaded = true;

        private Timer _timer = null;
        // ******************************************************************
        private void WindowLoaded(object sender, RoutedEventArgs e)
        {
            if (_isFirstTimeLoaded)
            {
                WindowHelper.SetOwnerWindow(this, _dlgProgressModel.IntPtrOwner);
                Dispatcher.BeginInvoke(new Action(ExecuteDelayedAfterWindowDisplayed), DispatcherPriority.Background);
                _isFirstTimeLoaded = false;

                if (_dlgProgressModel.FuncGetProgressPercentageValue != null)
                {
                    TimerCallback(null);
                    _timer = new Timer(TimerCallback, null, _dlgProgressModel.MilliSecDelayBetweenCall, _dlgProgressModel.MilliSecDelayBetweenCall);
                }
            }
        }

        // ******************************************************************
        private void TimerCallback(Object state)
        {
            Dispatcher.BeginInvoke(new Action(() =>
                {
                    _dlgProgressModel.ValueCurrent = _dlgProgressModel.FuncGetProgressPercentageValue();
                }));
        }

        // ******************************************************************
        private void ExecuteDelayedAfterWindowDisplayed()
        {
            if (_dlgProgressModel._actionStarted == false)
            {
                _dlgProgressModel._actionStarted = true;
                Task.Factory.StartNew(ExecuteAction);
            }
        }

        // ******************************************************************
        private void ExecuteAction()
        {
            _dlgProgressModel.ExecuteAction();
            _dlgProgressModel._actionTerminated = true;
            _dlgProgressModel.IsJobCompleted = true;
        }

        // ******************************************************************
        private void CmdCancel_Click(object sender, RoutedEventArgs e)
        {
            this._dlgProgressModel.IsJobCanceled = true;
        }

        // ******************************************************************
        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            if (! _dlgProgressModel.HaveConditionToClose())
            {
                e.Cancel = true;
                return;
            }

            WindowHelper.SetOwnerWindow(this, 0);

            this.CmdCancel.IsEnabled = false;
            this.CmdCancel.Content = "Canceling...";
            this._dlgProgressModel.Dispose();
        }

        // ******************************************************************
    }
}
0
投票
internal class WindowHelp
{
    private const int GWL_HWNDPARENT = -8;
    [DllImport("user32.dll")]
    private static extern IntPtr SetWindowLong(IntPtr hwnd, int index, int newStyle);
    public static void SetOwnerWindow(IntPtr hwndOwned, IntPtr intPtrOwner)
    {
        try
        {
            if (hwndOwned != IntPtr.Zero && intPtrOwner != IntPtr.Zero)
            {
                SetWindowLong(hwndOwned, GWL_HWNDPARENT, intPtrOwner.ToInt32());
            }
        }
        catch { }
    }
}
WindowInteropHelper helper = new WindowInteropHelper(owner);
_messageBox.Loaded += (sender, e) =>
{
    IntPtr windowHandleOwned = new WindowInteropHelper(_messageBox).Handle;
    owner.Dispatcher.Invoke(new Action(() =>
    {
        WindowHelp.SetOwnerWindow(windowHandleOwned, helper.Handle);
    }));
};

这个问题是，当应用程序关闭并且拥有的窗口仍然打开时，它将尝试执行可能失败的东西，我的猜测是它正在尝试关闭所有拥有的窗口。

System.ComponentModel.Win32Exception
  HResult=0x80004005
  Message=Invalid window handle
  Source=WindowsBase
  StackTrace:
   at MS.Win32.ManagedWndProcTracker.HookUpDefWindowProc(IntPtr hwnd)
   at MS.Win32.ManagedWndProcTracker.OnAppDomainProcessExit()
   at MS.Win32.ManagedWndProcTracker.ManagedWndProcTrackerShutDownListener.OnShutDown(Object target, Object sender, EventArgs e)
   at MS.Internal.ShutDownListener.HandleShutDown(Object sender, EventArgs e)

给它自己的线程的一个缺点是你必须跟踪子窗口并在主窗口关闭之前关闭它，然后应用程序才会到达关闭的后期阶段：

private void View_Closing(object sender, CancelEventArgs e)
{
    UIGlobal.SelfThreadedDialogs.ForEach(k =>
    {
        try
        {
            if (k != null && !k.Dispatcher.HasShutdownStarted)
            {
                k.Dispatcher.InvokeShutdown();
                //k.Dispatcher.Invoke(new Action(() => { k.Close(); }));
            }
        }
        catch { }
    });
}

拥有这种“多线程和相关”行为的代价。

有时不需要跟踪和/或所有者的View_Closing代码。有时您只需要跟踪以保持对拥有的窗口的引用，以便在应用程序关闭发生之前不会对它们进行垃圾回收。这取决于。看看哪种方法适合您的情况。

-1
投票

这不是关于设置所有者。如果要从另一个线程操作WPF中的控件，则需要创建一个委托并将其传递给控件的调度程序。

if(Control.Dispatcher.CheckAccess())
{
    //The control can be accessed without using the dispatcher.
    Control.DoSomething();
}
else{
     //The dispatcher of the control needs to be informed
     MyDelegate md = new MyDelegate( delegate() { Control.DoSomething(); });
     Control.Dispatcher.Invoke(md, null);
}

见this帖子。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.