非 UI 线程中的用户交互？

Question

在我的 WPF - C# 应用程序中，我有一个耗时的函数，我使用 BackgroundWorker 执行该函数。此函数的工作是将给定数据从文件添加到数据库中。有时，我需要一些用户反馈，例如数据已经在存储中，我想问用户，他是要合并数据还是创建新对象或完全跳过数据。就像对话框窗口显示的一样，如果我尝试将文件复制到已存在同名文件的位置。

问题是，我不能从非 GUI 线程调用 GUI 窗口。我该如何实现这种行为？

提前致谢，
弗兰克

Answer 1

您可以使用 EventWaitHandle 或 AutoResetEvent，然后每当您想提示用户时，您可以向 UI 发出信号，然后等待响应。有关文件的信息可以存储在变量中。

Answer 2

如果可能...我的建议是将您的长期运行任务构建为原子操作。然后，您可以创建一个可由后台线程和 UI 线程访问的项目队列。

public class WorkItem<T>
{
    public T Data { get; set; }
    public Func<bool> Validate { get; set; }
    public Func<T, bool> Action { get; set; }
}

你可以使用类似这个类的东西。它使用队列来管理工作项的执行，并使用可观察的集合来向 UI 发出信号：

public class TaskRunner<T>
{
    private readonly Queue<WorkItem<T>> _queue;

    public ObservableCollection<WorkItem<T>> NeedsAttention { get; private set; }

    public bool WorkRemaining
    {
        get { return NeedsAttention.Count > 0 && _queue.Count > 0; }
    }

    public TaskRunner(IEnumerable<WorkItem<T>> items)
    {
        _queue = new Queue<WorkItem<T>>(items);
        NeedsAttention = new ObservableCollection<WorkItem<T>>();
    }

    public event EventHandler WorkCompleted;

    public void LongRunningTask()
    {
        while (WorkRemaining)
        {
            if (_queue.Any())
            {
                var workItem = _queue.Dequeue();

                if (workItem.Validate())
                {
                    workItem.Action(workItem.Data);
                }
                else
                {
                    NeedsAttention.Add(workItem);
                }
            }
            else
            {
                Thread.Sleep(500); // check if the queue has items every 500ms
            }
        }

        var completedEvent = WorkCompleted;
        if (completedEvent != null)
        {
            completedEvent(this, EventArgs.Empty);
        }
    }

    public void Queue(WorkItem<T> item)
    {
        // TODO remove the item from the NeedsAttention collection
        _queue.Enqueue(item);
    }
}

您的 UI 代码隐藏可能类似于

public class TaskRunnerPage : Page
{
    private TaskRunner<XElement> _taskrunner;

    public void DoWork()
    {
        var work = Enumerable.Empty<WorkItem<XElement>>(); // TODO create your workItems

        _taskrunner = new TaskRunner<XElement>(work);

        _taskrunner.NeedsAttention.CollectionChanged += OnItemNeedsAttention;

        Task.Run(() => _taskrunner.LongRunningTask()); // run this on a non-UI thread
    }

    private void OnItemNeedsAttention(object sender, NotifyCollectionChangedEventArgs e)
    {
        // e.NewItems contains items that need attention.
        foreach (var item in e.NewItems)
        {
            var workItem = (WorkItem<XElement>) item;
            // do something with workItem
            PromptUser();
        }
    }

    /// <summary>
    /// TODO Use this callback from your UI
    /// </summary>
    private void OnUserAction()
    {
        // TODO create a new workItem with your changed parameters
        var workItem = new WorkItem<XElement>();
        _taskrunner.Queue(workItem);
    }
}

此代码未经测试！但基本原则应该适合你。

Answer 3

具体到你的情况

    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
    {
        Thread.Sleep(1000);
        var a = Test1("a");
        Thread.Sleep(1000);
        var b = (string)Invoke(new Func<string>(() => Test2("b")));
        MessageBox.Show(a + b);
    }

    private string Test1(string text)
    {
        if (this.InvokeRequired)
            return (string)this.Invoke(new Func<string>(() => Test1(text)));
        else
        {
            MessageBox.Show(text);
            return "test1";
        }
    }

    private string Test2(string text)
    {
        MessageBox.Show(text);
        return "test2";
    }

Test2 是您必须从后台工作人员调用 的常规方法。 Test1 可以直接调用，并使用安全模式调用自身。

MessageBox.Show 类似于yourForm.ShowDialog（都是模态的），你向它传递参数（text）然后你返回值（可以是yourForm 的属性值，它是在表单关闭时设置的）。我使用的是string，但显然它可以是任何数据类型。

Answer 4

从这里输入的答案，我得出以下解决方案：

（错误）将 Backgroundworker 的 ReportProgress 方法与 EventWaitHandle 结合使用。如果我想与用户交互，我会调用 ReportProgress 方法并将后台进程设置为等待。在 ReportProgress 事件的处理程序中，我进行交互，完成后，我释放 EventWaitHandle。

    BackgroundWorker bgw;

    public MainWindow()
    {
        InitializeComponent();

        bgw = new BackgroundWorker();
        bgw.DoWork += new DoWorkEventHandler(bgw_DoWork);
        bgw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bgw_RunWorkerCompleted);
        bgw.WorkerReportsProgress = true;
        bgw.ProgressChanged += new ProgressChangedEventHandler(bgw_ProgressChanged);
    }

    // Starting the time consuming operation
    private void Button_Click(object sender, RoutedEventArgs e)
    {
        bgw.RunWorkerAsync();
    }

    // using the ProgressChanged-Handler to execute the user interaction
    void bgw_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        UserStateData usd = e.UserState as UserStateData;

        // UserStateData.Message is used to see **who** called the method
        if (usd.Message == "X")
        {
            // do the user interaction here
            UserInteraction wnd = new UserInteraction();
            wnd.ShowDialog();

            // A global variable to carry the information and the EventWaitHandle
            Controller.instance.TWS.Message = wnd.TextBox_Message.Text;
            Controller.instance.TWS.Background.Set();
        }
    }

    void bgw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        MessageBox.Show(e.Result.ToString());
    }

    // our time consuming operation
    void bgw_DoWork(object sender, DoWorkEventArgs e)
    {
        Thread.Sleep(2000);

        // need 4 userinteraction: raise the ReportProgress event and Wait
        bgw.ReportProgress(0, new UserStateData() { Message = "X", Data = "Test" });
        Controller.instance.TWS.Background.WaitOne();

        // The WaitHandle was released, the needed information should be written to global variable
        string first = Controller.instance.TWS.Message.ToString();

        // ... and again
        Thread.Sleep(2000);

        bgw.ReportProgress(0, new UserStateData() { Message = "X", Data = "Test" });
        Controller.instance.TWS.Background.WaitOne();

        e.Result = first + Controller.instance.TWS.Message;
    }

我希望我没有忽略一些关键问题。我对多线程不太熟悉——也许某处应该有一些锁（对象）？