[MVVM][.net3.5] InputBinding, Binding Command et CommandParameter

Version imprimable

Bonjour,

Via le lien suivant j'avais presque trouver solution a mon problème.
http://joyfulwpf.blogspot.com/2009/0...eybinding.html

Petite explication:
On m'impose d'utiliser le Framework .net 3.5 et j'ai besoin d’exécuter dans mon logiciel des Command à partir d'InputBindings: KeyBinding et/ou MouseBinding.
Hors, avec ce Framework, il est impossible de Bindé une Command (chose qui par d'ailleurs as été résolue pour le Framework .net 4.0)
Code:

1 2 3 <MenuItem.InputBindings> <KeyBinding Modifiers="Control" Key="P" Command={Binding CommandPrint}" /> </MenuItem.InputBindings>
Afin d'éviter ce problème de compatibilité de Binding de Command sur un InputBinding en Framework 3.5, j'ai trouver sur le net une petite solution (le lien ci-dessus) qui utilise une class nommé CommandRéférence (à récupérer dans le sample) qui s'utilise de cette manière
Code:

1 2 3 4 5 6 <Window.Resources> <coreView:CommandReference x:Key="print" Command="{Binding CommandPrint}" /> </Window.Resources> <MenuItem.InputBindings> <KeyBinding Modifiers="Control" Key="P" Command="{StaticResource print}" /> </MenuItem.InputBindings>
Jusque la tout va bien.

Sauf que mon problème, j'aimerai allez plus loin dans mon code et y attacher des CommandParameter, chose que cette classe ne permet pas.
De plus, pour la structure MVVM de mon logiciel, j'utilise les RelayCommand (certains me diront que se n'est pas le must mais moi cela me suffit :P).
Cette classe ne comprend pas les Execute et CanExecute que j'utilise avec ces RelayCommand

Code:

<Button Content="Print" Command="{Binding CommandDo}" CommenParameter="Print" />

Quelqu'un aurait-il de meilleur solution a suggérer pour prendre en compte au moins les CommandParameter?

Merci.

21/06/2011, 11h55
Invité

Salut,

La solution que je vois est de modifier le code en y ajoutant une propriété attachée qui te servira de CommandParameter :ccool:
21/06/2011, 14h53
tomlev

Citation:

Envoyé par h2s84

La solution que je vois est de modifier le code en y ajoutant une propriété attachée qui te servira de CommandParameter :ccool:

Tu peux préciser ton idée ? Je vois pas trop comment ça va pouvoir marcher... ou alors tu mets la propriété sur le CommandReference, mais dans ce cas ça fait que le paramètre est lié à la commande et non plus au InputBinding, donc c'est pas très clean
21/06/2011, 15h02
Invité

Citation:

Envoyé par tomlev

Tu peux préciser ton idée ? Je vois pas trop comment ça va pouvoir marcher... ou alors tu mets la propriété sur le CommandReference, mais dans ce cas ça fait que le paramètre est lié à la commande et non plus au InputBinding, donc c'est pas très clean

Précision : je parle de la création de la propriété CommandParameter dans la classe CommandReference. Du coup je suis d'accords ce sera lié à cette dernière et pas à la classe KeyBinding Ce n'est pas ce qu'il veut ?

Citation:

Envoyé par h2s84

Du coup je suis d'accords ce sera lié à cette dernière et pas à la classe KeyBinding Ce n'est pas ce qu'il veut ?

Pour part se serai mieux. Je ne voit pas en quoi ce ne serai pas clean de faire comme ceci:

Code:

1
2
3
4
5
6
<Window.Resources>
    <coreView:CommandReference x:Key="print" Command="{Binding CommandDo}" CommandParameter="Print" />
</Window.Resources>
<MenuItem.InputBindings>
    <KeyBinding Modifiers="Control" Key="P" Command="{StaticResource print}" />
</MenuItem.InputBindings>

De plus, un CommandParameter dans un KeyBinding, lui non plus n'accepte pas de recevoir un élément bindé :?.

Sinon j'ai essayer d'ajouter une propriété CommandParameter il as pas aimer 8O

Code:

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
public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("Command", typeof(ICommand), typeof(CommandReference), new PropertyMetadata(new PropertyChangedCallback(OnCommandChanged)));
public static readonly DependencyProperty CommandParameterProperty = DependencyProperty.Register("CommandParameter", typeof(object), typeof(CommandReference), new PropertyMetadata(null));
 
public ICommand Command
{
    get { return (ICommand)GetValue(CommandProperty); }
    set { SetValue(CommandProperty, value); }
}
public object CommandParameter
{
    get { return (object)GetValue(CommandParameterProperty); }
    set { SetValue(CommandParameterProperty, value); }
}
 
#region ICommand Members
 
[DebuggerStepThrough]
public bool CanExecute()
{
    if (Command != null)
        return Command.CanExecute(CommandParameter);
    return false;
}
 
public void Execute()
{
    Command.Execute(CommandParameter);
}

voici le code complet d'origine

Code:

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;
using System.Windows;
using System.Diagnostics;
//Crédit Josh Smith
 
namespace Common.WPF.MVVMHelpers
{
    public class CommandReference : Freezable, ICommand
    {
        public CommandReference()
        {
            // Blank
        }
 
        public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("Command", typeof(ICommand), typeof(CommandReference), new PropertyMetadata(new PropertyChangedCallback(OnCommandChanged)));
 
        public ICommand Command
        {
            get { return (ICommand)GetValue(CommandProperty); }
            set { SetValue(CommandProperty, value); }
        }
 
        #region ICommand Members
 
        [DebuggerStepThrough]
        public bool CanExecute(object parameter)
        {
            if (Command != null)
                return Command.CanExecute(parameter);
            return false;
        }
 
        public void Execute(object parameter)
        {
            Command.Execute(parameter);
        }
 
        public event EventHandler CanExecuteChanged;
 
        private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            CommandReference commandReference = d as CommandReference;
            ICommand oldCommand = e.OldValue as ICommand;
            ICommand newCommand = e.NewValue as ICommand;
 
            if (oldCommand != null)
            {
                oldCommand.CanExecuteChanged -= commandReference.CanExecuteChanged;
            }
            if (newCommand != null)
            {
                newCommand.CanExecuteChanged += commandReference.CanExecuteChanged;
            }
        }
 
        #endregion
 
        #region Freezable
 
        protected override Freezable CreateInstanceCore()
        {
            throw new NotImplementedException();
        }
 
        #endregion
    }
}

21/06/2011, 16h45
tomlev

Citation:

Envoyé par Monkey56

Je ne voit pas en quoi ce ne serai pas clean de faire comme ceci:

C'est pas clean parce que si tu veux utiliser plusieurs fois la même commande avec des paramètres différents, tu es obligé de déclarer plusieurs CommandReference. C'est un peu comme si en C#, au lieu de faire une méthode Add(int x), tu faisais une méthode Add pour chaque valeur du paramètre x (Add1(), Add2(), Add3()...)

Citation:

Envoyé par Monkey56

De plus, un CommandParameter dans un KeyBinding, lui non plus n'accepte pas de recevoir un élément bindé :?.

Bah oui, c'est bien le problème... Mais je ne vois pas de meilleure solution que celle proposée par h2s84, même si elle me parait pas très propre

Citation:

Envoyé par Monkey56

Sinon j'ai essayer d'ajouter une propriété CommandParameter il as pas aimer 8O

C'est à dire ? Perso je ne vois pas de problème dans ton code... quelle est l'erreur ?

Citation:

Erreur 1:
'MonNameSpace.CommandReference' n'implémente pas le membre d'interface 'System.Windows.Input.ICommand.CanExecute(object)'
...\CommandReference.cs
ligne 12
colone 18

Erreur 2:
'MonNameSpace.CommandReference' n'implémente pas le membre d'interface 'System.Windows.Input.ICommand.Execute(object)'
...\CommandReference.cs
ligne 12
colone 18

... et je vient de penser une idée bête:
écrire les méthode CanExecute et Execute de cette manière (une peu null car la parametre ne sera pas utilisé, mais l'erreur disparai):
Code:

1 2 3 4 5 6 7 8 9 10 11 public bool CanExecute(object parameter) { if (Command != null) return Command.CanExecute(CommandParameter); return false; } public void Execute(object parameter) { Command.Execute(CommandParameter); }
Par contre je n'ai pas le temps de tester la je suis sur autre chose ... dès que j'aurais tester, je vous tient au courant.

Bon finalement j'ai mis de côté l'autre chose que je codais :P je n'ai pas résister longtemps...

Donc ce petit bout de code transformer marche finalement.
Je me retrouve donc avec du code ressemblant a ceci
Code:

1 2 3 4 5 6 <Window.Resources> <coreView:CommandReference x:Key="print" Command="{Binding CommandDo}" CommandParameter="Print" /> </Window.Resources> <MenuItem.InputBindings> <KeyBinding Modifiers="Control" Key="P" Command="{StaticResource print}" /> </MenuItem.InputBindings>
Est ce que cela vous semble correct que je clôture le sujet?

21/06/2011, 17h35
tomlev

Citation:

Envoyé par Monkey56

une peu null car la parametre ne sera pas utilisé

C'est aussi pour ça que j'aime pas beaucoup cette approche : tu ignores complètement le paramètre qu'on te passe, et tu en utilises un autre à la place... Donc si tu mets un paramètre sur le KeyBinding, il ne sera pas pris en compte, ce qui peut être un peu perturbant

Citation:

Envoyé par tomlev

C'est aussi pour ça que j'aime pas beaucoup cette approche : tu ignores complètement le paramètre qu'on te passe, et tu en utilises un autre à la place... Donc si tu mets un paramètre sur le KeyBinding, il ne sera pas pris en compte, ce qui peut être un peu perturbant

Je vient d'y remédier, plus ou moins
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public bool CanExecute(object parameter) { if (Command != null) { if(CommandParameter != null) return Command.CanExecute(CommandParameter); else return Command.CanExecute(parameter); } return false; } public void Execute(object parameter) { if (CommandParameter != null) Command.Execute(CommandParameter); else Command.Execute(parameter); }
Si CommandParameter de la classe CommandReference n'est pas utiliser(soit null), il prendra le CommandParameter du Input Binding.

Code:

<KeyBinding Modifiers="Control" Key="P" Command="{StaticResource print}" CommandParameter="Print" />

Fonctionne, j'ai tester.

21/06/2011, 18h09
tomlev

Citation:

Envoyé par Monkey56

Si CommandParameter de la classe CommandReference n'est pas utiliser(soit null), il prendra le CommandParameter du Input Binding.

Bien vu :ccool: