Метод, ожидающий действие пользователя

Question

Пишу WPF-приложение на C#. Есть метод, показывающий окошко с сообщением и 2-мя кнопками. Он должен возвращать 0 или 1 (например), в зависимости от нажатой кнопки, как это делает метод ShowDialog() класса Form. Так вот как собственно это реализовать? Вот примерный макет метода:

public int ShowMessage()
    {
        OpenWindow();
        //каким-то образом ожидаем действия пользователя
        //отслеживаем нажатую кнопку
        //и возвращаем соответствующее значение
        return (/* if pressedKey1*/) ? 1 : 0;
    } 

Answer 1

У Влада какой-то сложный способ, я предлагаю сделать всё просто и топорно. По сути, у диалогов по-хорошему должно быть два способа вызова: модальный и немодальный.

• Модальный режим предполагает вызов ShowModal, блокировку основного окна и вызывающей функции.
• Немодальный режим предполагает вызов Show, доступность основного окна и ожидание с помощью await.

Использование будет выглядеть так (давайте числа не возвращать, это дурной тон):

private async void ShowPopups ()
{
    Result modalResult = YesNoPopup.ShowPopupModal("Modal");
    // UI блокирован
    MessageBox.Show(modalResult.ToString());

    Result notModalResult = await YesNoPopup.ShowPopup("Not modal");
    // UI не блокирован
    MessageBox.Show(notModalResult.ToString());
}

public enum Result
{
    Yes,
    No,
    Cancel,
}

Добавим в класс попапа свойство с результатом вызова, кнопкам назначим соответствующие обработчики.

using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using static WpfDialogSample.Result;

public class YesNoPopup : Window
{
    private Result? _result;

    public YesNoPopup ()
    {
        Button btnYes, btnNo, btnCancel;
        SizeToContent = SizeToContent.WidthAndHeight;
        WindowStartupLocation = WindowStartupLocation.CenterScreen;
        Content = new UniformGrid {
            Columns = 3,
            Children = {
                (btnYes = new Button { Content = "Yes" }),
                (btnNo = new Button { Content = "No" }),
                (btnCancel = new Button { Content = "Cancel" }),
            }
        };
        btnYes.Click += (s, a) => SetResult(Yes);
        btnNo.Click += (s, a) => SetResult(No);
        btnCancel.Click += (s, a) => SetResult(Cancel);
    }

    private void SetResult (Result result)
    {
        _result = result;
        Close();
    }

    // ...
}

А дальше в пару строчек реализуем модальную и немодальную версию. Здесь считается, что закрытие диалога эквивалентно нажатию на Cancel.

public class YesNoPopup : Window
{
    // ...

    public static Result ShowPopupModal (string title)
    {
        var popup = new YesNoPopup { Title = title };
        popup.ShowDialog();
        return popup._result ?? Cancel;
    }

    public static async Task<Result> ShowPopup (string title)
    {
        var completion = new TaskCompletionSource<Result?>();
        var popup = new YesNoPopup { Title = title };
        popup.Closed += (s, a) => completion.SetResult(popup._result);
        popup.Show();
        return await completion.Task ?? Cancel;
    }
}

Собственно, вот и весь код вместе со всеми элементами управления.

Answer 2

Можно сделать это через через ShowDialog, но мне кажется более чистым метод с async/await.

Вот простой вариант:

public Task<int> ShowMessage()
{
    var tcs = new TaskCompletionSource<int>();
    var w = new YourWindow();
    w.Closed += (o, args) => tcs.TrySetResult(w.ClickedButtonIndex)
    w.Show();
    return tcs.Task;
}

Для этого, понятно, YourWindow должно в публичном свойстве PressedButtonIndex запоминать, какая кнопка была нажата. И закрываться по нажатию любой из кнопок. Это делается так:

<Button Click="OnButtonClicked" Name="Button1">1</Button>
<Button Click="OnButtonClicked" Name="Button2">2</Button>

и в code-behind окна YourWindow

void OnButtonClicked(object sender, RoutedEventArgs e)
{
    if (sender == Button1)
        ClickedButtonIndex = 1;
    else
        ClickedButtonIndex = 2;
    Close();
}

public int ClickedButtonIndex { get; private set; }

Давайте попробуем более изощрённый вариант Для начала, научимся дожидаться нажатия на кнопку:

async Task<Button> ClickOnButton(Button b, CancellationToken ct)
{
    var tcs = new TaskCompletionSource<Button>();
    RoutedEventHandler handler = (sender, args) => tcs.TrySetResult(b);
    b.Click += handler;
    try
    {
        using (ct.Register(() => tcs.TrySetCanceled()))
            return await tcs.Task;
    }
    finally
    {
        b.Click -= handler;
    }
}

async Task<Button> ClickOnAny(IEnumerable<Button> buttons, CancellationToken ct)
{
    using (var innerCts = CancellationTokenSource.CreateLinkedTokenSource(ct))
    {
        var tasks = buttons.Select(el => ClickOnButton(el, innerCts.Token)).ToList();
        var winningTask = await Task.WhenAny(tasks);
        var clickedControl = await winningTask;
        innerCts.Cancel();
        return clickedControl;
    }
}

Теперь можно навешивать ожидание на любое окно:

public async Task<int> ShowMessage()
{
    var w = new YourWindow();
    w.Show();
    var clickedButton = await ClickOnAny(
           new[] { w.Button1, w.Button2 }, CancellationToken.None);
    w.Close();
    return clickedButton == w.Button1 ? 1 : 2;
}

При таком подходе окно не обязано «сотрудничать».

И в заключение стандартный (на мой вкус, устаревший) вариант с ShowDialog:

int ShowMessage()
{
    var dw = new YourWindow();
    var result = dw.ShowDialog();
    if (result == true)
        return dw.ClickedButtonIndex;
    else
        return -1;
}

Для этого в YourWindow должен быть такой code-behind:

void OnButtonClicked(object sender, RoutedEventArgs e)
{
    if (sender == Button1)
        ClickedButtonIndex = 1;
    else
        ClickedButtonIndex = 2;
    DialogResult = true;
}

public int ClickedButtonIndex { get; private set; }