WPF

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

public class MouseMoveCommandBehavior : CommandBehaviorBase<Control>
{
    private MouseOutCommandBehavior(Control control) : base(control)
    {
        control.MouseMove += (sender, args) => 
        {
            this.ExecuteCommand();
        };
    }
}

public class MouseMoveCommandBehavior : CommandBehaviorBase<Control>

{

private MouseOutCommandBehavior(Control control) : base(control)

{

control.MouseMove += (sender, args) =>

{

this.ExecuteCommand();

};

}

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)

public static class MouseMove 
{
    public static ICommand GetCommand(DependencyObject obj)
    {
        return (ICommand)obj.GetValue(CommandProperty);
    }

    public static void SetCommand(DependencyObject obj, ICommand value)
    {
        obj.SetValue(CommandProperty, value);
    }

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

public static class MouseMove

{

public static ICommand GetCommand(DependencyObject obj)

{

return (ICommand)obj.GetValue(CommandProperty);

}

public static void SetCommand(DependencyObject obj, ICommand value)

{

obj.SetValue(CommandProperty, value);

}

public static readonly DependencyProperty CommandProperty =

DependencyProperty.RegisterAttached("Command", typeof(ICommand), typeof(MouseMove), new PropertyMetadata(OnSetCustomCommandCallback));

}

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:

private static void OnSetCustomCommandCallback(DependencyObject dep, DependencyPropertyChangedEventArgs e)
{
    var control = dep as Control;
    if (control != null)
    {
        MouseMoveCommandBehavior behavior = GetorCreateMouseMoveBehavior(control);
        behavior.Command = e.NewValue as ICommand;
    }
}

private static void OnSetCustomCommandCallback(DependencyObject dep, DependencyPropertyChangedEventArgs e)

{

var control = dep as Control;

if (control != null)

{

MouseMoveCommandBehavior behavior = GetorCreateMouseMoveBehavior(control);

behavior.Command = e.NewValue as ICommand;

}

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:

private static MouseMoveCommandBehavior GetorCreateMouseMoveBehavior(Control listBox)
{
    var behavior = listBox.GetValue(MouseMoveBehaviorProperty) as
        MouseMoveCommandBehavior;
    if (behavior == null)
    {
        behavior = new MouseMoveCommandBehavior(listBox);
        listBox.SetValue(MouseMoveBehaviorProperty, behavior);
    }
    return behavior;
}

private static MouseMoveCommandBehavior GetorCreateMouseMoveBehavior(Control listBox)

{

var behavior = listBox.GetValue(MouseMoveBehaviorProperty) as

MouseMoveCommandBehavior;

if (behavior == null)

{

behavior = new MouseMoveCommandBehavior(listBox);

listBox.SetValue(MouseMoveBehaviorProperty, behavior);

}

return behavior;

}

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

public static MouseMoveCommandBehavior GetMouseMoveBehavior(DependencyObject obj)
{
    return (MouseMoveCommandBehavior)obj.GetValue(MouseMoveBehaviorProperty);
}

public static void SetMouseMoveBehavior(DependencyObject obj, MouseMoveCommandBehavior value)
{
    obj.SetValue(MouseMoveBehaviorProperty, value);
}

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

public static MouseMoveCommandBehavior GetMouseMoveBehavior(DependencyObject obj)

{

return (MouseMoveCommandBehavior)obj.GetValue(MouseMoveBehaviorProperty);

}

public static void SetMouseMoveBehavior(DependencyObject obj, MouseMoveCommandBehavior value)

{

obj.SetValue(MouseMoveBehaviorProperty, value);

}

public static readonly DependencyProperty MouseMoveBehaviorProperty =

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

public static object GetCommandParametr(DependencyObject obj)
{
    return (object)obj.GetValue(CommandParametrProperty);
}

public static void SetCommandParametr(DependencyObject obj, object value)
{
    obj.SetValue(CommandParametrProperty, value);
}

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

public static object GetCommandParametr(DependencyObject obj)

{

return (object)obj.GetValue(CommandParametrProperty);

}

public static void SetCommandParametr(DependencyObject obj, object value)

{

obj.SetValue(CommandParametrProperty, value);

}

public static readonly DependencyProperty CommandParametrProperty =

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

private static void OnSetCustomCommandParameterCallback(DependencyObject dep,DependencyPropertyChangedEventArgs e)
{
    var listBox = dep as Control;
    if (listBox != null)
    {
        MouseMoveCommandBehavior behavior = GetorCreateMouseMoveBehavior(listBox); ;
            behavior.CommandParameter = e.NewValue;
    }
}

private static void OnSetCustomCommandParameterCallback(DependencyObject dep,DependencyPropertyChangedEventArgs e)

{

var listBox = dep as Control;

if (listBox != null)

{

MouseMoveCommandBehavior behavior = GetorCreateMouseMoveBehavior(listBox); ;

behavior.CommandParameter = e.NewValue;

}

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:

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

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:

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

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.

Walidacja jest to technika sprawdzająca, czy dany obiekt spełnia pewne założenia poprawności danych. W WPF-ie oraz Silverlighcie istnieją trzy sposoby walidacji obiektów:

walidacja poprzez rzucanie wyjątków,
walidacja z użyciem interfejsu IDataErrorInfo,
walidacja z użyciem interfejsu INotifyDataErrorInfo

1. Walidacja poprzez rzucanie wyjątków

Walidacja poprzez rzucanie wyjątków odbywa się w następujący sposób. W seterze danej właściwości dodajemy warunek sprawdzający czy wpisane dane są poprawne. Jeżeli nie to najzwyczajniej w świecie rzucamy wyjątek, w którym podajemy komunikat błędu. Przykładowy properties z walidacją może wyglądać w ten sposób:

private string _name;
public string Name
{
    get { return _name; }
    set
    {
        _name = value;
        if (string.IsNullOrEmpty(_name))
            throw new Exception("Nazwa nei może być pusta");
    }
}

private string _name;

public string Name

{

get { return _name; }

set

{

_name = value;

if (string.IsNullOrEmpty(_name))

throw new Exception("Nazwa nei może być pusta");

}

W celu “wyłapania” tego wyjątku i pokazania odpowiedniego komunikatu,w bindingu musimy ustawić właściwość ValidatesOnExceptions na wartość true.

<TextBox Text="{Binding Name, ValidatesOnExceptions=True, Mode=TwoWay}" />

1	<TextBox Text="{Binding Name, ValidatesOnExceptions=True, Mode=TwoWay}" />

Taki sposób walidowania jest jednak rzadko stosowany i wielu programistów twierdzi, że rzucanie wyjątków powinno się odbywać tylko w przypadku nieprawidłowego działania aplikacji. Ponadto walidowane propertisy nie mogą być autopropertisami, co dodatkowo wydłuża czas tworzenia klas.

2. Walidacja z użyciem interfejsu IDataErrorInfo

public interface IDataErrorInfo
{
    string this[string columnName] { get; }
    string Error { get; }
}

public interface IDataErrorInfo

{

string this[string columnName] { get; }

string Error { get; }

}

W celu wyłapywania błędów w widoku, należy w bindingu ustawić ValidatesOnDataError = true

<TextBox Text="{Binding Name, ValidatesOnDataError=True, Mode=TwoWay}" />

1	<TextBox Text="{Binding Name, ValidatesOnDataError=True, Mode=TwoWay}" />

Przykładowa klasa implementująca interfejs IDataErrorInfo może wyglądać następująco:

public class Customer : IDataErrorInfo
{
    public string Name { get; set; }
    
    public string Error
    {
        get { return string.Empty; }
    }
    
    public string this[string propertyName]
    {
        get 
        {
            string result = string.Empty;
            if (propertyName == "Name")
            {
                if (string.IsNullOrEmpty(Name))
                    result = "Wartość nie moż być pusta";
            }
            
            return result;
        }
    }
}

public class Customer : IDataErrorInfo

{

public string Name { get; set; }

public string Error

{

get { return string.Empty; }

}

public string this[string propertyName]

{

get

{

string result = string.Empty;

if (propertyName == "Name")

{

if (string.IsNullOrEmpty(Name))

result = "Wartość nie moż być pusta";

}

return result;

}

Najważniejszą metodą w powyższej klasie jest indekser

string this[string propertyName]

1	string this[string propertyName]

to właśnie tutaj mogą zostać sprawdzone wszystkie właściwości danego obiektu – propertyName oznacza nazwę propertisu, który walidujemy. W przypadku, gdy wartość jakiejś właściwości jest nieprawidłowa, w pole result wpisujemy komunikat błędu. Komunikaty te “wyłapywane” są przez widok, a następnie wyświetlane w postaci komunikatów przy odpowiednich kontrolkach. Jeżeli wszystko jest OK zwracamy string.Empty.Walidacje przy pomocy interfejsu IDataErrorInfo idealnie nadają się do walidowania modelu.

3. Walidacja z użyciem interfejsu INotifyDataErrorInfo

Interfejs INotifyDataErrorInfo prezentuje się w następujący sposób:

public interface INotifyDataErrorInfo
{
     bool HasErrors { get; }
     event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
     IEnumerable GetErrors(string propertyName);
}

public interface INotifyDataErrorInfo

{

bool HasErrors { get; }

event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

IEnumerable GetErrors(string propertyName);

}

bool HasErrors – określa czy dany obiekt zawiera błędy
event EventHandler ErrorsChanged– zdarzenie informujące o zmienie ilości błędów w obiekcie
IEnumerable GetErrors(string propertyName) – funkcja pobierająca kolekcję błędów dla danego propertisa

W celu “wyłapania” błędów przez widok należy w bindingu ustawić properties
NotifyOnValidationError = true

<TextBox Text="{Binding Name, NotifyOnValidationError=True, Mode=TwoWay}" />

1	<TextBox Text="{Binding Name, NotifyOnValidationError=True, Mode=TwoWay}" />

Jak już wcześniej wspomniano funkcja GetErrors(string propertyName) zwraca kolekcję błędów dla danej właściwości. Zatem do klasy, która będzie implementowała interfejs INotifyDataErrorInfo należy dodać kolekcję przechowującą obiekty typu ValidationResult. Przykładowa implementacja interfejsu może wyglądać w następujący sposób:

public class BaseViewModel : INotifyDataErrorInfo
{
    private ICollection<ValidationResult> _validationResults;
    public IEnumerable GetErrors(string propertyName)
    {
        return _validationResults.Where(result => result.MemberNames.Contains(propertyName));
    }
 
    public bool HasErrors
    {
        get { return _validationResults.Count > 0; }
    }
 
    public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
    
    private void NotifyErrorsChanged(string propertyName)
    {
        if(ErrorsChanged!=null)
            ErrorsChanged(this, new DataErrorsChangedEventArgs(propertyName));
    }

    protected void Validate()
    {
        _validationResults.Clear();
        Validator.TryValidateObject(this, new ValidationContext(this, null, null), _validationResults, true);
     
        foreach (var result in _validationResults)
            NotifyErrorsChanged(result.MemberNames.First());
    }
    
    protected void Validate(string propertyName)
    {
        var validationResults = _validationResults.Where(result => result.MemberNames.Contains(propertyName)).ToList();
        foreach (var result in validationResults)
               _validationResults.Remove(result);
        
        Validator.TryValidateProperty(value, new ValidationContext(this, null, null) { MemberName = propertyName }, _validationResults);
           NotifyErrorsChanged(propertyName);
     }
}

public class BaseViewModel : INotifyDataErrorInfo

{

private ICollection<ValidationResult> _validationResults;

public IEnumerable GetErrors(string propertyName)

{

return _validationResults.Where(result => result.MemberNames.Contains(propertyName));

}

public bool HasErrors

{

get { return _validationResults.Count > 0; }

}

public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

private void NotifyErrorsChanged(string propertyName)

{

if(ErrorsChanged!=null)

ErrorsChanged(this, new DataErrorsChangedEventArgs(propertyName));

}

protected void Validate()

{

_validationResults.Clear();

Validator.TryValidateObject(this, new ValidationContext(this, null, null), _validationResults, true);

foreach (var result in _validationResults)

NotifyErrorsChanged(result.MemberNames.First());

}

protected void Validate(string propertyName)

{

var validationResults = _validationResults.Where(result => result.MemberNames.Contains(propertyName)).ToList();

foreach (var result in validationResults)

_validationResults.Remove(result);

Validator.TryValidateProperty(value, new ValidationContext(this, null, null) { MemberName = propertyName }, _validationResults);

NotifyErrorsChanged(propertyName);

}

Funkcja Validate() najpierw czyści wszystkie poprzednie wyniki walidacji, a następnie przy pomocy klasy Validator oraz funkcji TryValidateObject waliduje wszystkie właściwości, które zostały oznaczone atrybutem dziedziczącym po klasie ValidationAttribute.Z kolei funkcja Validate(string propertyName) waliduje tylko konkretną właściwość.
Przykładowe walidowanie właściwości przy pomocy atrybutów może wyglądać w następujący sposób:

[Required(ErrorMessage = "Pole nie może być puste")]
public string Subject
{
    get { return _subject; }
    set
    {
        _subject = value;
         Validate(“Subject”)
    }
}

[Required(ErrorMessage = "Pole nie może być puste")]

public string Subject

{

get { return _subject; }

set

{

_subject = value;

Validate(“Subject”)

}

W celu stworzenia własnych regół walidacji, nie uwzględnionych w zapewnionych przez framework atrybutach należy stworzyć własną klasę dziedziczącą po klasie ValidationAttribute, a następnie przeciążyć metodę IsValid. Przykładowa klasa może wyglądać w następujący sposób:

public class IntValidation : ValidationAttribute
{
    private bool allowNull;
    public IntValidation(bool allowNull)
    {
        this.allowNull = allowNull;
    }
    
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        if (value != null)
        {
            int resul;
            if (int.TryParse(value.ToString(), out resul))
                return ValidationResult.Success;
            else
                return new ValidationResult(ErrorMessage, new List{validationContext.MemberName });
        }
        
        return allowNull ? ValidationResult.Success : new ValidationResult(ErrorMessage);
    }
}

public class IntValidation : ValidationAttribute

{

private bool allowNull;

public IntValidation(bool allowNull)

{

this.allowNull = allowNull;

}

protected override ValidationResult IsValid(object value, ValidationContext validationContext)

{

if (value != null)

{

int resul;

if (int.TryParse(value.ToString(), out resul))

return ValidationResult.Success;

else

return new ValidationResult(ErrorMessage, new List{validationContext.MemberName });

}

return allowNull ? ValidationResult.Success : new ValidationResult(ErrorMessage);

}

Walidacja przy użyciu interfejsu INotifyDataErrorInfo idealnie nadaje się (wg mnie) do walidowaniu całych ViewModeli. Przy zamykaniu okna wystarczy wywołać funkcję Validate() z bazowego ViewModelu, a w przypadku gdy zwróci ona false zatrzymać zamykanie okna. Jako, że walidacja zostanie przeprowadzona na wszystkich wybranych przez nas propertisach, widok automatycznie się zaktualizuje i pokaże komunikaty błędów na odpowiednich kontrolkach okna.

.NET BLOG

.NET, C# blog

Prism – CommandBehaviors

Prism – Komendy

1. DelegateCommands

2. CompositeCommands

Kolekcje wspierające sortowanie, grupowanie oraz filtrowanie

1. ListViewCollection (WPF)

2. PagedCollectionView (Silverlight)

Walidacja

1. Walidacja poprzez rzucanie wyjątków

2. Walidacja z użyciem interfejsu IDataErrorInfo

3. Walidacja z użyciem interfejsu INotifyDataErrorInfo

Routed Events – nowy rodzaj zdarzeń w WPF-ie