Réactif Extensions (Rx) + MVVM =?

J'ai écrit un cadre qui représente mes explorations dans cette question appelle ReactiveUI

Il met en œuvre à la fois une Observable ICommand, ainsi que ViewModel objets qui les changements de signal par l'intermédiaire d'un IObservable, ainsi que la capacité à "attribuer" un IObservable à une propriété, qui sera alors le feu INotifyPropertyChange chaque fois que son IObservable changements. Il comprend par ailleurs un lot de modèles communs, comme d'avoir une ICommand qui exécute une Tâche en arrière-plan, puis marshalls les résultats de l'INTERFACE utilisateur.

Je n'ai absolument zéro de la documentation pour l'instant, mais je vais travailler sur l'ajout d'informations dans les prochains jours, ainsi qu'un exemple d'application que j'ai codé en place

Mise à JOUR: j'ai maintenant beaucoup de documentation, découvrez http://www.reactiveui.net

Quand j'ai commencé à penser à la façon de "se marier" MVVM et RX, la première chose que j'ai pensé était un ObservableCommand:

public class ObservableCommand : ICommand, IObservable<object>
{
    private readonly Subject<object> _subj = new Subject<object>();

    public void Execute(object parameter)
    {
        _subj.OnNext(parameter);
    }

    public bool CanExecute(object parameter)
    {
        return true;
    }

    public event EventHandler CanExecuteChanged;

    public IDisposable Subscribe(IObserver<object> observer)
    {
        return _subj.Subscribe(observer);
    }
}

Mais ensuite j'ai pensé que le "standard" MVVM façon de liaison de contrôles à ICommand de propriétés n'est pas très RX new'ish, il brise le flux d'événements en assez statique accouplements. RX est plus sur les événements, et en écoutant une Exécuté événement routé semble le plus approprié. Voici ce que j'ai trouvé:

1) Vous avez une CommandRelay comportement qui vous installer à la racine de chaque contrôle de l'utilisateur qui doit répondre à des commandes:

public class CommandRelay : Behavior<FrameworkElement>
{
    private ICommandSink _commandSink;

    protected override void OnAttached()
    {
        base.OnAttached();
        CommandManager.AddExecutedHandler(AssociatedObject, DoExecute);
        CommandManager.AddCanExecuteHandler(AssociatedObject, GetCanExecute);
        AssociatedObject.DataContextChanged 
          += AssociatedObject_DataContextChanged;
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
        CommandManager.RemoveExecutedHandler(AssociatedObject, DoExecute);
        CommandManager.RemoveCanExecuteHandler(AssociatedObject, GetCanExecute);
        AssociatedObject.DataContextChanged 
          -= AssociatedObject_DataContextChanged;
    }

    private static void GetCanExecute(object sender, 
        CanExecuteRoutedEventArgs e)
    {
        e.CanExecute = true;
    }

    private void DoExecute(object sender, ExecutedRoutedEventArgs e)
    {
        if (_commandSink != null)
            _commandSink.Execute(e);
    }

    void AssociatedObject_DataContextChanged(
       object sender, DependencyPropertyChangedEventArgs e)

    {
        _commandSink = e.NewValue as ICommandSink;
    }
}

public interface ICommandSink
{
    void Execute(ExecutedRoutedEventArgs args);
}

2) ViewModel desservant le contrôle de l'utilisateur est héritée de la ReactiveViewModel:

    public class ReactiveViewModel : INotifyPropertyChanged, ICommandSink
    {
        internal readonly Subject<ExecutedRoutedEventArgs> Commands;

        public ReactiveViewModel()
        {
            Commands = new Subject<ExecutedRoutedEventArgs>();
        }

...
        public void Execute(ExecutedRoutedEventArgs args)
        {
            args.Handled = true;  //to leave chance to handler 
                                  //to pass the event up
            Commands.OnNext(args);
        }
    }

3) Vous n'avez pas lier des contrôles ICommand propriétés, mais l'utilisation RoutedCommand de la place:

public static class MyCommands
{
    private static readonly RoutedUICommand _testCommand 
       = new RoutedUICommand();
    public static RoutedUICommand TestCommand 
      { get { return _testCommand; } }
}

Et en XAML:

<Button x:Name="btn" Content="Test" Command="ViewModel:MyCommands.TestCommand"/>

En conséquence, sur votre ViewModel vous pouvez écouter les commandes dans un très RX façon:

    public MyVM() : ReactiveViewModel 
    {
        Commands
            .Where(p => p.Command == MyCommands.TestCommand)
            .Subscribe(DoTestCommand);
        Commands
            .Where(p => p.Command == MyCommands.ChangeCommand)
            .Subscribe(DoChangeCommand);
        Commands.Subscribe(a => Console.WriteLine("command logged"));
    }

Maintenant, vous avez le pouvoir de commandes routées (vous êtes libre de choisir de traiter la commande sur l'un ou même plusieurs Viewmodel dans la hiérarchie), de plus, vous avez un "simple flux" pour toutes les commandes qui est nicier de RX que de les séparer IObservable de l'.

Je pense que l'idée était de créer un événement "corde", dans ce cas, une opération de glisser sans doute, ce qui entraîne une commande appelée? Ce serait faire peu de la même manière que vous feriez dans le code-behind, mais avec le code dans un comportement. Par exemple, créer un DragBehavior qui utilise Rx de combiner le MouseDown/MouseMove/MouseUp événements avec une commande appelée à gérer la nouvelle "événement".