Discussion :

[Julien_G]

Bonjour,
J'utilise des Childwindows pour afficher les propriétés des objets.
J'utilise également les RIA Services, et j'aimerai que lorsque l'utilisateur clique sur :
- OK, la fenêtre ne se ferme que si il n'y a aucune ValidationError, ou que le SubmitChanges se soit bien passé.
- Cancel ou la X de fermeture de la childWindow, faire un RejectChanges

Le problème est que l'évènement des boutons est en Code Behind, et que si je bind une commande sur ces derniers en plus sur ces derniers, je ne pourrai pas empêcher la fermeture de la fenêtre.

Sachant que j'ai pas mal de fenêtres de propriétés j'aimerai une solution assez générique.

Merci d'avance

[tomlev]

Tu peux gérer l'évènement Closing de la ChildWindow, et appeler une méthode du ViewModel (par exemple OnClosing) pour autoriser ou non la fermeture

[Julien_G]

Hum, donc je serai obligé de passer par le codeBehind ? c'est ce que je craignez car je voulais une solution 100% MVVM (sauf pour les 2 boutons automatiquement générés). De plus le submit est asynchrone, j'ai peur que ca soit un peu crade :/

Car j'avais étendu la classe ViewModelBase de Mvvmlight, afin d'inclure des commandes (OK, Cancel, Load)

[tomlev]

Hum, donc je serai obligé de passer par le codeBehind ? c'est ce que je craignez car je voulais une solution 100% MVVM (sauf pour les 2 boutons automatiquement générés).

"100% MVVM", ça veut pas dire "pas de code behind"... Si c'est plus simple de faire quelque chose en code-behind, fais le, à condition bien sûr que ce ne soit pas lié à la logique métier.

Si vraiment ça te gêne, tu peux créer un behavior :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public static class WindowBehavior
{
    public static ICommand GetClosingCommand(DependencyObject obj)
    {
        return (ICommand)obj.GetValue(ClosingCommandProperty);
    }
 
    public static void SetClosingCommand(DependencyObject obj, ICommand value)
    {
        obj.SetValue(ClosingCommandProperty, value);
    }
 
    // Using a DependencyProperty as the backing store for ClosingCommand.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty ClosingCommandProperty =
    DependencyProperty.RegisterAttached(
        "ClosingCommand",
        typeof(ICommand),
        typeof(WindowBehavior),
        new UIPropertyMetadata(
            null,
            ClosingCommandChanged));
 
    private static void ClosingCommandChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        var window = o as ChildWindow;
        if (window == null)
            return;
 
        var oldValue = (ICommand)e.OldValue;
        var newValue = (ICommand)e.NewValue;
 
        if (oldValue != null && newValue == null)
        {
            window.Closing -= window_Closing;
        }
        else if (newValue != null && oldValue == null)
        {
            window.Closing += window_Closing;
        }
    }
 
    private static void window_Closing(object sender, CancelEventArgs e)
    {
        var command = GetClosingCommand((ChildWindow)sender);
        if (command == null)
            return;
        if (command.CanExecute(e))
            command.Execute(e);
    }
 
}

Et dans le code XAML, tu bindes WindowBehavior.ClosingCommand à une commande de ton ViewModel

[Julien_G]

Merci tomlev
J'essayerai ta solution qui a l'air vraiment interresante.

En attendant, j'ai bindé mes boutons à des commandes. Mon viewmodel lève un évènement OnClose (lorsque je choisis que la fenetre peut être fermée) qui est capté par un behavior CallMethodAction,qui capte cet évènement et fais un close de la window.