非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

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

（错误）将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;
    }

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

Answer 4

具体针对您的情况

    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 ，但是显然它可以是任何数据类型。