Вам не придется волноваться о выполнении этого самим. У меня есть многопоточные приложения.NET, работающие на двойных квадратических машинах, и неважно как потоки запускаются, вижу ли через ThreadPool или вручную, я хорошее ровное распределение работы через все ядра.
Я написал фреймворк, который представляет мои исследования в этом вопросе под названием ReactiveUI
. Он реализует как Observable ICommand, так и объекты ViewModel, которые сигнализируют об изменениях через IObservable, а также возможность " назначить "объект IObservable свойству, который затем будет запускать INotifyPropertyChange всякий раз, когда его IObservable изменяется. Он также инкапсулирует множество общих шаблонов, таких как наличие ICommand, который запускает задачу в фоновом режиме, а затем маршалирует результат обратно в пользовательский интерфейс.
У меня сейчас нет абсолютно никакой документации, но я буду работать над добавлением этой информации в ближайшие дни, а также над примером приложения, которое я закодировал.
ОБНОВЛЕНИЕ: Теперь у меня довольно много много документации, проверьте http://www.reactiveui.net
Это также должно быть идеально выполнено с помощью ReactiveFramework.
Единственное изменение. Требуется создать для этого поведение, а затем подключить его к Command. Это будет выглядеть примерно так:
<Button Content="Click Me">
<Behaviors:Events.Commands>
<Behaviors:EventCommandCollection>
<Behaviors:ReactiveEventCommand CommandName="MouseEnterCommand" EventName="MouseEnter" />
<Behaviors:ReactiveEventCommand CommandName="MouseLeaveCommand" EventName="MouseLeave" />
<Behaviors:ReactiveEventCommand CommandName="ClickCommand" EventName="Click" />
</Behaviors:EventCommandCollection>
</Behaviors:Events.Commands>
</Button>
Просто поймите, что EventCommand работает очень похоже на то, как будет работать ReactiveFramework в этом сценарии. Вы действительно не увидите разницы, хотя реализация EventCommand будет упрощена.
EventCommand уже предоставляет вам модель push - когда событие происходит, она запускает вашу команду. Это основной сценарий использования Rx, но он упрощает реализацию.
Я думаю, что идея заключалась в том, чтобы создать событие "аккорд", в данном случае, вероятно, операцию перетаскивания, которая приводит к вызову команды? Это будет сделано примерно так же, как в коде, но с кодом в поведении. Например, создайте DragBehavior, который использует Rx для объединения событий MouseDown / MouseMove / MouseUp с командой, вызываемой для обработки нового «события».
Решением моей проблемы оказалось создание класса, реализующего как ICommand, так и IObservable
ICommand используется для привязки пользовательского интерфейса (с использованием поведения), а затем IObservable может использоваться в модели представления для создания составных потоков событий.
using System;
using System.Windows.Input;
namespace Jesperll
{
class ObservableCommand<T> : Observable<T>, ICommand where T : EventArgs
{
bool ICommand.CanExecute(object parameter)
{
return true;
}
event EventHandler ICommand.CanExecuteChanged
{
add { }
remove { }
}
void ICommand.Execute(object parameter)
{
try
{
OnNext((T)parameter);
}
catch (InvalidCastException e)
{
OnError(e);
}
}
}
}
Где Observable
Когда я начал думать о том, как "поженить" MVVM и RX, первое, о чем я подумал, была 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);
}
}
Но потом я подумал, что "стандартный" MVVM способ привязки элементов управления к свойствам ICommand не очень подходит для RX, он разбивает поток событий на довольно статичные соединения. RX - это больше про события, и прослушивание Executed маршрутизируемого события кажется подходящим. Вот что я придумал:
1) У вас есть поведение CommandRelay, которое вы устанавливаете в корне каждого пользовательского элемента управления, который должен реагировать на команды:
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, обслуживающая пользовательский элемент управления, наследуется от 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) Вы не привязываете элементы управления к свойствам ICommand, а вместо этого используете RoutedCommand'ы:
public static class MyCommands
{
private static readonly RoutedUICommand _testCommand
= new RoutedUICommand();
public static RoutedUICommand TestCommand
{ get { return _testCommand; } }
}
И в XAML:
<Button x:Name="btn" Content="Test" Command="ViewModel:MyCommands.TestCommand"/>
В результате, на вашей ViewModel вы можете слушать команды очень RX способом:
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"));
}
Теперь, у вас есть сила маршрутизируемых команд (вы можете выбрать обработку команды на любой или даже нескольких ViewModel в иерархии), плюс у вас есть "единый поток" для всех команд, что приятнее для RX, чем отдельные IObservable'ы.