Подпишитесь на наблюдаемую не стрельбу при использовании асинхронного метода расширения - PullRequest
1 голос
/ 05 июля 2019

Для нового проекта я использую ReactiveUI.Я начинаю по-настоящему любить идеи реактивного программирования, но все еще испытываю трудности с тем, чтобы обдумать некоторые концепции и написать идиоматический код.

В этом примере у меня есть очень простое MainWindow сTextBox с именем "UserId":

<Window
    x:Class="ReactiveUiDemo.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow"
    Width="800"
    Height="450">
    <StackPanel>
        <TextBox x:Name="UserId" />
    </StackPanel>
</Window>

TextBox привязан к свойству соответствующей модели представления в конструкторе MainWindow:

using System.Reactive.Disposables;
using System.Windows;
using ReactiveUI;

namespace ReactiveUiDemo
{
    public partial class MainWindow : Window, IViewFor<MainWindowViewModel>
    {
        public MainWindowViewModel ViewModel { get; set; }

        object IViewFor.ViewModel
        {
            get => ViewModel;
            set => ViewModel = (MainWindowViewModel)value;
        }

        public MainWindow()
        {
            InitializeComponent();
            ViewModel = new MainWindowViewModel();

            this.WhenActivated(disposables =>
            {
                this
                    .Bind(ViewModel, vm => vm.UserId, v => v.UserId.Text)
                    .DisposeWith(disposables);
            });
        }
    }
}

Затем ViewModel за этим наблюдаетэто свойство (к которому применяется атрибут ReactiveUI.Fody [Reactive]).Когда 4 цифры были введены, он пытается найти пользователя, который либо преуспевает в случае UserId 1234, либо завершается неудачно.Затем этот результат отображается с использованием MessageBox.

using System;
using System.Reactive;
using System.Reactive.Linq;
using System.Threading.Tasks;
using System.Windows;
using ReactiveUI;
using ReactiveUI.Fody.Helpers;

namespace ReactiveUiDemo
{
    public sealed class MainWindowViewModel : ReactiveObject
    {
        [Reactive]
        public string UserId { get; private set; }

        public MainWindowViewModel()
        {
            this
                .WhenAnyValue(t => t.UserId)
                .Where(u => (u?.Length ?? 0) == 4)
                .Where(u => int.TryParse(u, out _))
                .Select(i => int.Parse(i))
                .Select(i => GetUserName(i))
                .Match(
                    userName => DisplaySuccess(userName),
                    failure => DisplayError(failure))
                .Do(_ => UserId = string.Empty)
                .Subscribe(
                    _ => MessageBox.Show("OnNext"),
                    _ => MessageBox.Show("OnError"),
                    () => MessageBox.Show("OnCompleted"));
        }

        private enum Failure { UserNotFound }

        private Result<string, Failure> GetUserName(int userId)
        {
            if (userId == 1234)
                return "Waldo";

            return Failure.UserNotFound;
        }

        private async Task<Unit> DisplayError(Failure failure)
        {
            MessageBox.Show($"Error: {failure}.");
            await Task.CompletedTask;

            return Unit.Default;
        }

        private async Task<Unit> DisplaySuccess(string userName)
        {
            MessageBox.Show($"Found {userName}!");
            await Task.CompletedTask;

            return Unit.Default;
        }
    }
}

Класс "Result" (или его удаленная версия) содержит TSuccess или TFailure:

using System;

namespace ReactiveUiDemo
{
    public sealed class Result<TSuccess, TFailure>
    {
        private readonly bool _isSuccess;
        private readonly TSuccess _success;
        private readonly TFailure _failure;

        private Result(TSuccess value)
        {
            _isSuccess = true;
            _success = value;
            _failure = default;
        }

        private Result(TFailure value)
        {
            _isSuccess = false;
            _success = default;
            _failure = value;
        }

        public TResult Match<TResult>(Func<TSuccess, TResult> successFunc, Func<TFailure, TResult> failureFunc)
            => _isSuccess ? successFunc(_success) : failureFunc(_failure);

        public static implicit operator Result<TSuccess, TFailure>(TSuccess value)
            => new Result<TSuccess, TFailure>(value);

        public static implicit operator Result<TSuccess, TFailure>(TFailure value)
            => new Result<TSuccess, TFailure>(value);
    }
}

Метод расширенияЧто вызывает у меня головную боль - это метод Match, который определяется следующим образом:

using System;
using System.Reactive.Linq;
using System.Reactive.Threading.Tasks;
using System.Threading.Tasks;

namespace ReactiveUiDemo
{
    public static class ObservableExtensions
    {
        public static IObservable<TResult> Match<TSuccess, TFailure, TResult>(
            this IObservable<Result<TSuccess, TFailure>> source,
            Func<TSuccess, Task<TResult>> success,
            Func<TFailure, Task<TResult>> failure)
            => Observable.FromAsync(async () => await source.SelectMany(result => result.Match(success, failure).ToObservable()));
    }
}

Код работает, как и ожидалось, до метода расширения Match.Вызывается DisplayError или DisplaySuccess, но это конец;действия в Do и Subscribe не выполняются.Я полагаю, что есть проблема с моим методом расширения Match, но я не знаю, как ее решить.

В качестве примечания, я думаю, есть лучший способ написать этот бит:

                .Where(u => (u?.Length ?? 0) == 4)
                .Where(u => int.TryParse(u, out _))
                .Select(int.Parse)

Я мог бы представить метод расширения TryParseInt, но, возможно, он не нужен?

edit

Обновлен метод расширения, основанный на ответе @GlennWatson, онработает, я бы ожидал сейчас:

public static IObservable<TResult> Match<TSuccess, TFailure, TResult>(
    this IObservable<Result<TSuccess, TFailure>> source,
    Func<TSuccess, Task<TResult>> success,
    Func<TFailure, Task<TResult>> failure)
    => source.SelectMany(r => r.Match(success, failure).ToObservable());

1 Ответ

1 голос
/ 05 июля 2019

Метод FromAsync () предназначен только для системы, основанной на задачах.

При использовании методов Observable и последующих стилей Linq старайтесь сохранять его в форме Observable в максимально возможной степени.

В вашем примере вы ожидаете Observable и упаковываете его в FromAsync.У SelectMany есть перегрузка, которая понимает операции на основе задач.

...