Prism - CommandBehaviors

Analizując wcześniejsze przykłady pokazujące użycie DelegateCommand można odnieść wrażenie, że mimo tego iż są one bardzo użyteczne, ich użycie jest niestety bardzo ograniczone. Jedynie niektóre komponenty WPF-a i Silverlight-a mają właściwość Command do której można zbindować nasz obiekt DelegateCommand. Ponadto właściwość ta reaguje jedynie na wybrane zahardcodowane w kontrolce zdarzenie (zdarzenie Click). Co w przypadku gdybyśmy chcieli zareagować np. na zdarzenie MouseMove za pomocą komendy? Nasz problem możemy rozwiązać poprzez:

Interactivity
Interactions
CommandBehaviors

W tym poście zostanie przedstawione rozwiązanie trzecie - CommandBehaviors

Pierwszą rzeczą jaką należy zrobić w celu stworzenia komendy reagującej na inne zdarzenie niż Click jest stworzenie klasy dziedziczącej po CommandBehaviorBase. Załóżmy, że zrobimy komendę reagującą na zdarzenie MouseMove

1
public class MouseMoveCommandBehavior : CommandBehaviorBase<Control>
2
{
3
    private MouseOutCommandBehavior(Control control) : base(control)
4
    {
5
        control.MouseMove += (sender, args) =>
6
        {
7
            this.ExecuteCommand();
8
        };
9
    }
10
}

Piersza część już za nami, ale pojawia się teraz pytanie jak z tego skorzystać. Żeby mieć możliwość użycia powyżej klasy wykorzytamy attached dependency property. Musimy sobie stworzyć pomocniczą statyczną klasę, w której to zarejestrujemy nasze właściwości. Zacznijmy od zarejestrowania dependency property o nazwie Command - do tego obiektu będziemy bindowali komendy z ViewModelu (komendy reagujące na zdarzenie MouseMove)

1
public static class MouseMove
2
{
3
    public static ICommand GetCommand(DependencyObject obj)
4
    {
5
        return (ICommand)obj.GetValue(CommandProperty);
6
    }
7

8
    public static void SetCommand(DependencyObject obj, ICommand value)
9
    {
10
        obj.SetValue(CommandProperty, value);
11
    }
12

13
    public static readonly DependencyProperty CommandProperty =
14
            DependencyProperty.RegisterAttached("Command", typeof(ICommand), typeof(MouseMove), new PropertyMetadata(OnSetCustomCommandCallback));
15
}

zauważmy, że podłączyliśmy event handlera reagującego na zmianę naszej nowo stworzonej właściwości Command. Funkcja OnSetCustomCommandCallback wygląda następująco:

1
private static void OnSetCustomCommandCallback(DependencyObject dep, DependencyPropertyChangedEventArgs e)
2
{
3
    var control = dep as Control;
4
    if (control != null)
5
    {
6
        MouseMoveCommandBehavior behavior = GetorCreateMouseMoveBehavior(control);
7
        behavior.Command = e.NewValue as ICommand;
8
    }
9
}

Funkcja ta po prostu w razie potrzeby tworzy nowy obiekt typu MouseMoveCommandBehavior (gdy ktoś zbinduje komende) i dopina go do naszej kontrolki. Pomocnicza funkcja GetorCreateMouseMoveBehavior wygląda tak:

1
private static MouseMoveCommandBehavior GetorCreateMouseMoveBehavior(Control listBox)
2
{
3
    var behavior = listBox.GetValue(MouseMoveBehaviorProperty) as
4
        MouseMoveCommandBehavior;
5
    if (behavior == null)
6
    {
7
        behavior = new MouseMoveCommandBehavior(listBox);
8
        listBox.SetValue(MouseMoveBehaviorProperty, behavior);
9
    }
10
    return behavior;
11
}

Obiekt rejestrowany poprzez funkcję GetorCreateMouseMoveBehavior jest dopinany do kolejnej attached property, która również została zadeklarowana w tym pliku

1
public static MouseMoveCommandBehavior GetMouseMoveBehavior(DependencyObject obj)
2
{
3
    return (MouseMoveCommandBehavior)obj.GetValue(MouseMoveBehaviorProperty);
4
}
5

6
public static void SetMouseMoveBehavior(DependencyObject obj, MouseMoveCommandBehavior value)
7
{
8
    obj.SetValue(MouseMoveBehaviorProperty, value);
9
}
10

11
public static readonly DependencyProperty MouseMoveBehaviorProperty =
12
    DependencyProperty.RegisterAttached("MouseMoveBehavior", typeof(MouseMoveCommandBehavior), typeof(MouseMove), null );

Mając zdefiniowane wszystkie powyższe właściwości możemy już wykorzystać naszą komendę. Jednakże przydałoby się dodać jeszcze jedną właściwość (opcjonalnie), mianowicie właściwość CommandParameters

1
public static object GetCommandParametr(DependencyObject obj)
2
{
3
    return (object)obj.GetValue(CommandParametrProperty);
4
}
5

6
public static void SetCommandParametr(DependencyObject obj, object value)
7
{
8
    obj.SetValue(CommandParametrProperty, value);
9
}
10

11
public static readonly DependencyProperty CommandParametrProperty =
12
    DependencyProperty.RegisterAttached("CommandParametr", typeof(object), typeof(MouseMove), new PropertyMetadata(OnSetCustomCommandParameterCallback));`

W tym propertisie również reagujemy na przypisnie obiektu. Handler OnSetCustomCommandParameterCallback wygląda następująco

1
private static void OnSetCustomCommandParameterCallback(DependencyObject dep,DependencyPropertyChangedEventArgs e)
2
{
3
    var listBox = dep as Control;
4
    if (listBox != null)
5
    {
6
        MouseMoveCommandBehavior behavior = GetorCreateMouseMoveBehavior(listBox); ;
7
            behavior.CommandParameter = e.NewValue;
8
    }
9
}

Mając już zdefiniowane wszystkie niezbędne właściwości możemy użyć ich w XAML-u. Po pierwsze musimy dodać alias do namespaca gdzie znajduje się nasza statycza klasa MouseMove. W moim przypadku wygląda to następująco:

1
xmlns:AttachedCommands="clr-namespace:MainModule.Commands"

Następnie bindujemy jakąś kontrolkę do naszego attached property Command. Wygląda to w następujący sposób:

1
<Button Name="txtButton" Grid.Column="2" AttachedCommands:MouseMove.Command="{Binding SomeCommandFromViewModel}"></Button>

Od teraz za każdym razem jak najedziemy na txtButton wywoła się komenda SomeCommandFromViewModel. Podsumowując trzeba się całkiem sporo napisać żeby zmusić do działania CommandBehaviors . W następnym poście przedstawię dwa sposoby na osiągnięcie tego samego efektu mniejszym kosztem.