Discussion :

[Monkey56]

Bonjour.

J'ai dans un premier temps un formulaire de données client. Celui-ci possède une Grid pour laquelle j'ai mis en DataContext l'instance de mon client récupérer de mon ViewModel.

Code xml :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
<UserControl ...>
    <UserControl.DataContext>
        <ViewModels:MyViewModel />
    </UserControl.DataContext>
 
    <Grid>
        <Grid DataContext="{Binding Path=Customer}">
            <TextBox Text="{Binding Path=FirstName, UpdateSourceTrigger=PropertyChanged}" />
        </Grid>
        <Button Command="{Binding Path=SaveCommand}" />
    </Grid>
</UserControl>

Le problème est que la modification de la propriété FirstName de mon Client ne se répercute pas. J'ai placer un point d'arrêt dans le setter mais il ne passe pas à l'intérieur.

Code csharp :

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
 
public class MyViewModel : NotificationObject
{
    public MyViewModel()
    {
        this.SaveCommand = new DelegateCommand(this.Save, this.CanSave);
    }
 
    public ICustomer Customer
    {
        get { return this.customer; }
        set
        {
            this.customer = value;
            this.SaveCommand.RaiseCanExecuteChanged();
        }
    }
 
    public DelegateCommand SaveCommand { get; private set; }
 
    public bool CanSave()
    {
        return this.Customer != null && !string.IsNullOrWhiteSpace(this.Customer.FirstName)
    }
 
    public void Save ()
    {
    }
}

Pour info, je travail avec les bibliothèque de Prism pour la gestion MVVM.

Merci de votre aide

[micka132]

Il faut préciser que le BindingMode=TwoWay.

[Monkey56]

Mode TwoWay ne fonctionne pas

Code :

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

1
2
DataContext="{Binding Path=Customer, Mode=TwoWay}"
Text="{Binding Path=FirstName, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"

[Lordinaire]

Dans ton code je ne vois aucun appel du genre NotifyPropertyChanged ou RaisePropertyChanged pour dire à ta vue que le contexte a changé.

Code :

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

1
2
3
4
5
6
7
8
9
10
public ICustomer Customer
    {
        get { return this.customer; }
        set
        {
            this.customer = value;
            RaisPropertyChanged("Customer");
            this.SaveCommand.RaiseCanExecuteChanged();
        }
    }

[Monkey56]

Certes en effet je n'ai pas mis ce code, mais celui-ci ne sert qu'à mettre à jour du ViewModel vers la View. Hors mon problème se situe dans l'autre sens.

[Lordinaire]

Tu peux mettre le code de ta classe Customer ? J'imagine que ça doit ressembler à ça :

Code c# :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Customer : ICustomer
{
        private string _firstName;
        public string FirstName
        {
            get { return _firstName; }
            set
            {
                _firstName= value;
                RaisePropertyChanged("FirstName");
            }
        }
}

[Monkey56]

C'est à peu près ça sans le RaisePropertyChanged("FirstName");

Cette classe Customer sert pour d'autre projet non forcement WPF, donc aucune dépendance à Prism ou autre méthodologie PropertyChanged de ce genre.

Mes propriétés sont ainsi toutes écrites de cette façon (Et il n'y à que ça des propriétés dans cette classe)

Code :

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

public string FirstName { get; set; }

[Lordinaire]

J'ai recrée un petit projet pour reproduire ce que tu fais :

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
public class Customer
    {
        private string _firstName;
        public string FirstName
        {
            get { return _firstName; }
            set { _firstName = value; }
        }
    }
 
    public class MyViewModel
    {
        public MyViewModel()
        {
            Customer = new Customer();
            Customer.FirstName = "toto";
        }
 
        private Customer _customer;
        public Customer Customer
        {
            get { return _customer; }
            set
            {
                _customer = value;
            }
        }
    }

Code xml :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<Window x:Class="WpfApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
        xmlns:ViewModels="clr-namespace:WpfApplication1"
        Title="MainWindow" Height="350" Width="525">
    <Window.DataContext>
        <ViewModels:MyViewModel />
    </Window.DataContext>
 
    <Grid>
        <Grid DataContext="{Binding Path=Customer}">
            <TextBox Text="{Binding Path=FirstName, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}" />
        </Grid>
    </Grid>
</Window>

Ma propriété FirstName change bien quand je la modifie. Du coup je vois pas où est le soucis...

[Monkey56]

Bon du coup je vient de faire d'autres tests, non concluant mais ai une idée pour détourner le problème.

M'abonner à l'évènement TextChanged de tout mes champs en utilisant Systeme.Windows.Interactivity pour rester en MVVM.

De ce fait je vais avoir un commande supplémentaire qui un fois activée avec la méthode ci-dessus, va appelé le code suivant dont j'ai besoin.

Code :

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

this.SaveCommand.RaiseCanExecuteChanged();

Oui j'ai oublié de préciser que mon but étais de rentrer dans le set de la propriété Customer pour appeler cette méthode et ainsi dégriser mon Bouton Save; Dans la condition ou les champs FirstName et LastName sont bien remplis.

[micka132]

C'est peut etre simplement le nom de la variable qui est mal écrit.
N'y a-t-il pas d'erreur de binding dans la fenetre de sortie de VS ?

[Monkey56]

Aucunes erreurs de ce côté.

J'ai forcer ma méthode CanSave à vrai pour avoir mon bouton disponible. Après avoir cliqué sur celui-ci, ma méthode Save renvoi bien le bon Customer, qui plus est, avec les informations modifiées. C'est juste l'appel à la méthode RaiseCanExecuteChanged() citée précédemment qui me gêne.

[micka132]

Si tu as mis un breakpoint sur le setter de firstName et qu'il ne s'arrete jamais, je ne vois pas comment firstName peut avoir la bonne valeur quand tu clics sur ton bouton!

[Lordinaire]

Oui j'ai oublié de préciser que mon but étais de rentrer dans le set de la propriété Customer pour appeler cette méthode et ainsi dégriser mon Bouton Save; Dans la condition ou les champs FirstName et LastName sont bien remplis.

Ah ! Ça change tout Moi je pensais que tu ne rentrais pas dans FirstName. Tu n'as pas besoin d'utiliser RaiseCanExecuteChanged(); juste la méthode CanSave() et tout se fait automatiquement.

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
public class MyViewModel
    {
        public MyViewModel()
        {
            Customer = new Customer();
            Customer.FirstName = "toto";
        }
 
        private Customer _customer;
        public Customer Customer
        {
            get { return _customer; }
            set
            {
                _customer = value;
            }
        }
 
        RelayCommand _saveCommand;
        public ICommand SaveCommand
        {
            get
            {
                if (_saveCommand == null)
                {
                    _saveCommand = new RelayCommand(Save, CanSave);
                }
                return _saveCommand;
            }
        }
 
        public bool CanSave(object o)
        {
            return Customer.FirstName.Equals("titi");
        }
 
        public void Save(object o)
        {
 
        }
    }

[Monkey56]

En effet mon Breakpoint ne se situe pas dans FirstName mais Customer dans mon ViewModel.

Je vois que je me suis mal exprimer, je réexplique donc.

Je possède un formulaire ainsi qu'un ViewModel. Ce dernier possède un instance de Customer qui utilisé en tant que DataContext de ma vue. Pour la suite, les différent champ utilise des Binding sur les propriété de mon Customer.
J'avais en tête qu'une fois un champ de Customer changé, le setter de ce dernier situé dans le ViewModel serais appelé me permettant ainsi d’exécuter la méthode RaiseCanExecuteChanged de ma commande afin de forcer à refaire le test sur la méthode CanExecute associée : ici CanSave.
Hors je ne passe jamais dans le setter.
Dans mes tests unitaires, une propriété de Customer changé, la méthode CanSave me renvoi toujours le résultat attendu.

Euhh par contre en interne, nous avons une charte qui nous dit de rester sur Prism pour tout ce qui est gestion du MVVM, donc je n'utilise que les DelegateCommand . Le fonctionnement est différent des RelayCommand.

[Lordinaire]

Ok, dans ce cas une solution peut être de faire une nouvelle propriété dans MyViewModel de ce type là :

Code c# :

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

1
2
3
4
5
6
7
8
9
public string FirstName
{
     get { return Customer.FirstName; }
     set
     { 
         Customer.FirstName = value;
         SaveCommand.RaiseCanExecuteChanged();
     }
}

Certes, ça fait du travail en plus mais ça devrait fonctionner.

Autre solution :http://stackoverflow.com/a/7353704/1668669

[Monkey56]

Mince, moi qui voulais tout faire pour éviter cela .

Bon ba je suppose que la je n'ai plus d'autres choix.

Ou bien j'attache des AddEventHandler pour chacune des propriété du mon Customer. Dès qu'une propriété est modifié, elle appelle RaiseCanExecuteChanged.

J'ai à peu près le code en tête. Je test cela de suite et revient.

[micka132]

Ah je comprends mieux le soucis
En effet si tu modifies simplement le FirstName ca ne peut pas appeler le setter de Customer puisque tu ne modifie pas sa valeur, mais une de ses propriétés

Et si tu n'as pa le droit de modifier le code de Customer la solution de Lordinaire peut etre une solution si tu bindes directement sur le nouveau firstItem. En gros tu va faire un genre de wrapper partout ou tu utilises des objets "metier" que tu n'as pas le droit de toucher... Je sais pas si tu gagnes quelque chose . Enfin surtout qu'implenter InotifyPropertyChanged n'a rien avoir avec wpf et donc l'utiliser n'est pas bien dangereux! (enfin si tu restes dans un projet ou chaque milisecond n'est pas precieux! Mais dans ce cas là ca serait ptetre pas du C#.

[Monkey56]

La nouvelle idée est la suivante.

Etant donné que je passe au moins une fois dans le setter, et que ma classe Customer ne sert que pour diffusé les valeurs FirstName ... et autres, je vient de mettre en place le code suivant

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public ICustomer Customer
        {
            get { return this.customer; }
            set
            {
                this.customer = value;
                foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(this.customer))
                {
                    propertyDescriptor.AddValueChanged(this, (sender, e) => { this.SaveCommand.RaiseCanExecuteChanged(); });
                }
            }
        }

Simple à chaque fois que mon instance de Customer change, je m'abonne à toutes les propriétés pour qu'elle appellent la méthode si elles changent.

Malheureusement, cela n'a pas fonctionné .

Je tente de corriger le bug mais sinon voila l'idée.

Si celle-ci vous parait lourde, avertissez moi.

[Monkey56]

Bug corrigé

Code :

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

propertyDescriptor.AddValueChanged(this.customer, (sender, e) => { this.SaveCommand.RaiseCanExecuteChanged(); });

Merci en tout cas pour votre aide qui m'ont conduit au résultat voulu

[micka132]

Il vaudrait mieux que tu test si l'objet n'est pas null avant, et que tu te désabonne à tout tes petis event. (Donc ne pas utiliser une méthode anonyme). Tu risques d'avoir des surprises si le customer change beaucoup