Discussion :

[obito]

Bonjour,

comme vous pouvez vous en douter mon problème concerne le propriété Command d'un contrôle Button.

Pour développer mon appli je suis parti de ce tuto : http://japf.developpez.com/tutoriels...-et-testables/ très utile au niveau de la structure "idéal" pour une appli WPF. J'ai un usercontrol nommé indicateur, et dans mon dossier ViewModel une classe indicateurViewwModel, comme dans l'exemple du tuto.

Dans indicateur.xaml, j'ai bien :

Code :

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

1
2
3
xmlns:ViewModel="clr-namespace:atDemo.ViewModel"
<!-- ... -->
            <Button Style="{StaticResource Bouton}" Command="{Binding Maj}"  Height="21.96" VerticalAlignment="Bottom" Margin="128,0,120,-16">Button</Button>

Donc mon usercontrol récupère bien les informations d'un objet en revanche lors du click sur le bouton rien ne se passe. Voici mon code dans ma classe indicateurViewModel:

Code C# :

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

1
2
3
4
5
6
7
8
9
10
public ICommand Maj
        {
            get
            {
                if (this.majCommand==null)
                    this.majCommand = new RelayCommand(() => this.SelectedServeur.Variation+=5);
 
                return this.majCommand;
            }
        }

Si je met un point d'arrêt au début de la fonction, je constate qu'il ne rentre jamais dedans. Pourtant dans ma fenetre principal j'ai bien :

Code C# :

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

1
2
3
 Database db = new Database();
            indicateurViewModel c = new indicateurViewModel(db);
            listView1.DataContext = c;

Pour info j'ai un listView qui va contenir plusieurs fois le même usercontrol. (car un indicateur - mon usercontrol- ne concerne qu'une instance)

Si vous avez besoin de plus de code pas de soucis, je voulais pas tout mettre en bloc d'un coup, j'aimerais surtout savoir si quelqu'un avait djéà eu ce problème et dans ce cas m'orienter dans ma recherche de solution.

Merci d'avance.

EDIT: En debug voici le message :

System.Windows.Data Error: 39 : BindingExpression path error: 'Maj' property not found on 'object' ''ServeurViewModel' (HashCode=63349250)'. BindingExpressionath=Maj; DataItem='ServeurViewModel' (HashCode=63349250); target element is 'Button' (Name='Button1'); target property is 'Command' (type 'ICommand')

Ca veut dire que j'ai mal lié mon bouton ?... Puisqu'il devrait êter lié à indicateurViewModel et pas ServeurViewModel si j'ai bien compris. Ca vient peut être de la ? :

Window1.xaml.cs

Code C# :

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

1
2
3
4
5
6
7
8
foreach (Control ctrl in listView1.Items) 
            {
                if (ctrl.GetType() == typeof(Controler.indicateur))
                {
                    ctrl.DataContext = c.Serveurs[j];
                }
                j++;
            }

Donc la en gros je met en datacontext de mes usercontrol un objet serveur...

[obito]

J'avance sur mon problème, maintenant il rentre bien dans la méthode mais j'ai le message d'erreur suivant :

'CommandConverter' ne peut pas convertir 'atDemo.ViewModel.RelayCommand' en 'System.String'.

Sachant que ma méthode est comme ça:

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
public ICommand Maj
        {
            get
            {
                if (this.majCommand==null)
                    this.majCommand = new RelayCommand(this.Modif);
 
 
                return this.majCommand;
            }
        }

Et le void :

Code C# :

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

1
2
3
4
5
 private void Modif()
        {
 
            this.SelectedServeur.VariationHit += 5;
        }

Any idea ?

EDIT : Si j'implémente ce code dans la source du tutoriel cité plus haut, aucune erreur (même si rien ne se passe :s ) donc la j'avoue avoir du mal à comprendre...

[obito]

Bon je n'ai plus l'erreur mais rien ne se passe et pour cause dans ViewModelBase.cs lorsque je debug, jamais il ne rentre dans cette condition :

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
/// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="propertyName">The name of the property that has a new value.</param>
        protected virtual void OnPropertyChanged(string propertyName)
        {
            this.VerifyPropertyName(propertyName);
 
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

En gros propertyChanged vaut toujours null et j'avoue ne pas savoir pourquoi...

[Thomas Lebrun]

Faudrait que tu montres un peu plus de code car là, y'en a partout et c'est difficilement compréhensible

[obito]

C'est vrai c'est vrai, c'est un peu le foutoir je vais essayer de faire ça bien cette fois :

Au départ comme dit plus haut je m'appuis sur le tuto MVVM, j'ai donc bien séparé le Model, le View et le ViewModel:

Dans ma View j'ai un User Control nommé indicateur.xaml avec (entre autres) le bouton suivant :

Code :

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

<Button Name="Button1" Style="{StaticResource Bouton}" Command="{Binding Maj}"  Height="21.96" VerticalAlignment="Bottom" Margin="128,0,120,0">Button</Button>

Dans mon ViewModel j'ai le code suivant indicateurViewModel.cs :

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
 public ICommand Maj
        {
            get
            {
                if (this.majCommand==null)
                    this.majCommand = new RelayCommand(this.Modif); 
                return this.majCommand;
            }
        }
//...
private void Modif()
        {
            this.SelectedServeur.VariationHit += 5;
        }

ensuite dans ServeurViewModel (car ma classe s'appel Serveur), j'ai le code suivant :

Code C# :

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

1
2
3
4
5
6
7
 public double VariationHit
        {
            get { return this.serveur.VariationHit; }
            set { this.serveur.VariationHit = value; 
                //le OnPropertyChanged se charge de faire le test à null
                OnPropertyChanged("VariationHit"); }
        }

Le problème étant que dans mon Windows1.xaml, je génère plusieurs fois ce User Control en fonction d'un fichier XML :

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
 
List<ServeurViewModel> lstServeur = new List<ServeurViewModel>();
            int i = 1;
            //Méthode pour parser un XMl :
            //1- Charger le XML grace à la classe XElement implémenté dans System.Xml.Linq
            //2- Faire les requetes linq pour récuperer ce que l'on souhaite
            var xElem = XElement.Load(@"datas.xml");
            StackPanel g = new StackPanel();
            g.Orientation = System.Windows.Controls.Orientation.Horizontal;
 
            this.WindowState = System.Windows.WindowState.Maximized;
 
 
foreach (var o in xElem.Descendants("_x0031_"))
            {
 
 
 
                ServeurViewModel s = new ServeurViewModel(new Serveur { "blablabla ca fonctionne l'instanciation j'espargne les attributs"});
                lstServeur.Add(s);
                View.indicateur ind = new View.indicateur();
                ind.Name = "test" + i;
                ind.DataContext = s;
                ind.Button1.DataContext = new indicateurViewModel("attribut1...");
                if (j == 4)
                {
                    g.Children.Add(ind);
                    listView1.Items.Add(g);
                    g = new StackPanel();
                    g.Orientation = System.Windows.Controls.Orientation.Horizontal;
                    j = 0;
                }
                else {
                    g.Children.Add(ind);
                }
 
 
                i++;
                j++;
            }

J'explique ensuite le comportement, bon déjà voici le rendu à l'écran, à chaque control j'ai donc mon petit bouton :



Lorsque je clique dessus, si je met un point d'arrêt sur le OnPropertyChanged de mon Set, il arrive bien dessus, comme expliqué plus haut c'est PropertyChanged qui vaut toujours null.

Merci de vous interesser à mon problème

[jmix90]

Hello,

Quand tu créé ta commande si elle est null, n'oublie pas de d'appeler OnPropertyChanged("Maj") pour prévenir l'UI que ta commande a bien étée mise à jour...


Tiens nous au courant si cela marche...

[obito]

Salut,

Merci pour la proposition maheureusement rien n'y fait :s aucune réaction.

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
 
 public ICommand Maj
        {
            get
            {
                if (this.majCommand == null) { 
                    this.majCommand = new RelayCommand(this.Modif);
                    OnPropertyChanged("Maj");
                }
 
 
 
                return this.majCommand;
            }
        }

En revanche si je gère directement sur l'évènement du bouton en faisant :

Code C# :

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

1
2
3
4
5
6
7
 
private void Button1_Click(object sender, RoutedEventArgs e)
        {
            (radialBar.DataContext as ServeurViewModel).VariationHit += 5;
            (needle.DataContext as ServeurViewModel).VariationHit += 5; 
 
        }

Ca se met bien à jour à l'écran lorsque je clique. Je préfère ne pas me contenter de cette solution, parce que j'aimerais quand même arriver à bien maitriser les commands. Merci en tout cas de l'idée même si je n'ai pas compris pourquoi l'appliquer à un void au lieu d'une propriété

[shenron666]

est-ce que ton code dans le if est exécuté ?

le "OnPropertyChanged" est normalement appelé depuis un "set" et non un "get" vu qu'il prévient d'un changement de la donnée et une donnée change quand on la set, pas quand on la get

tu devrais donc logiquement la mettre dans le set de ton majCommand

[cinemania]

si tu veux coller à mvvm, en réalité, il est inutile de notifier un changement d'état de la propriété Maj car c'est une commande ICommand instanciée une fois à la première requête sur la propriété, ce qui signifie que techniquement pour l'UI en face, donc WPF, cette propriété ne changera jamais d'état ni de référence.

en revanche oui il est indispensable de notifier tout autre changement sur d'autres propriétés, sauf sur les propriétés qui donnent accès aux collections, en effet, là aussi, à priori l'instance de la collection n'a pas de raison de changer en cours de route donc inutile également de notifier un changement qui de toute façon n'aura jamais lieu.

De manière générale toute propriété valeur ou référence, dont la valeur ou la référence ne change pas pendant la durée de vie du ViewModel n'a pas besoin d'être soumis au PropertyChanged à la condition sin-equa-non que cette valeur soit "créée, calculée" soit à la construction du ViewModel, soit à la première requête sur la propriété.

Je serais plutôt curieux de savoir si
1. Ta relayCommand retourne toujours true si le prédicat n'est pas fourni.
2. Tu entre ou non dans le get de la propriété Maj... si tu veux le savoir, lève une exception de type Exception ou du type que tu veux te permettant de repérer du premier coup d'oeil l'entrée dans ce bloc...
3. Tu entre ou non dans la méthode Modif

Moi je n'inclu jamais le ViewModel depuis le XAML, je fait l'instanciation et la mise à disposition dans le DataContext depuis un constructeur général.
mais là encore c'est dans le cas de controls instanciés dès le début de vie de l'application... je n'ai jamais eu besoin de faire de la génération dynamique jusqu'ici en mvvm.

Ton symptôme ressemble fort à un problème de binding... plus qu'autre chose.
peut être soit le binding n'est pas correct, soit ton Bouton est situé dans un autre composant qui lui même bind déjà une propriété, dans ce cas ton binding sur command n'est plus relatif au DataContext général, mais à l'objet bindé par le controle conteneur...
il faut faire très attention à cela, et dans ce cas, il te faut faire une demande pour remonter la chaine des ancêtres (ancestors) pour remonter jusqu'au bon DataContext.

[obito]

est-ce que ton code dans le if est exécuté ?

le "OnPropertyChanged" est normalement appelé depuis un "set" et non un "get" vu qu'il prévient d'un changement de la donnée et une donnée change quand on la set, pas quand on la get

tu devrais donc logiquement la mettre dans le set de ton majCommand

Le code if est executé. En revanche je ne vois pas pourquoi je ferais un set, la propriété est de type ICommand et doit bien renvoyer une commande, aussi le fait de faire un OnPropertyChanged n'avait pas grand interêt je pense ( mais merci quand même à jmix90 pour avoir proposé ça, je ne fais du WPF que depuis une semaine et demie donc ...)

cinemania je suis d'accord bien sur avec ce que tu dit, j'avais déjà commencé le débogage, en me posant les mêmes questions :

1. Pour le relayCommand : OK
2. Je rentre bien dans le get de la propriété Maj
3. Je rentre bien dans Modif et surtout je met bien à jour le serveur concerné...

C'est comme si tout fonctionnait... Mais non en gros lorsque je vais dans :

Code C# :

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

1
2
3
4
5
6
7
  private void OnPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }

PropertyChanged vaut toujours null, je pense que ca vient surement du Binding aussi, mais ce qui est marrant c'est que je n'ai aucun message d'erreur (je sais pour le binding il dit rien mais pendant l'exécution j'ai quand même dans la fênetre d'exécution d'éventuelles erreurs de binding). Je pense que du fait que je génère à la "volé" les contrôles, il y a, à ce moment la, une perte du DataContext qui est pourtant affecté de base dans ma View, je vais donc me pencher la dessus.

Merci pour toutes ces pistes, et de votre aide, ca me permet de mieux comprendre le fonctionnement de ce modèle.

EDIT : Je n'ai pas le temps de tester mais je pense savoir d'où ca vient :

Lorsque je crée à la volé je pense que je bind mal puisque je bind mon user control sur ServeurViewModel au lieu de indicateurViewModel (indicateur étant mon usercontrol), dans l'exemple du tuto, il bind sur le ViewModel du control, je ne pense pas avoir fait pareil sur ce point, je vous tiens au courant demain mais j'ai bien compris ca devrait fonctionner comme je le souhaite.

Je vous dit encore merci et croisant les doigts pour demain.

[obito]

Bon, bonne et mauvaise nouvelle :

La bonne c'est que ca fonctionne...

La mauvaise ? Ca ne fonctionne pas comme il faut ! En fait quelque que soit le bouton sur lequel je clique c'est toujours le premier contrôle qui est mis à jour. En effet, la le tutoriel ne peut plus m'aider vu qu'il s'appuyait sur un seul contrôle qui est bindé à toutes les instances, la pour mon cas chaque controle est bindé une seule instance...

Voici le code que j'ai fait pour la génération, si vous avez des tuto ayant un rapport avec mon soucis je suis preneur

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
 indicateurViewModel indi = new indicateurViewModel(db);
 
            int i = 1;
            StackPanel f = new StackPanel();
            f.Orientation = System.Windows.Controls.Orientation.Horizontal;
            for (int j = 0; j < db.Serveurs.Count; j++) 
            {
 
                View.indicateur ind = new View.indicateur();
                ind.DataContext = indi.Serveurs[j];
                ind.Button1.DataContext = indi;
 
                if (i < 4)
                {
 
                    f.Children.Add(ind);
                }
                else
                {
                    f.Children.Add(ind);
                    listView1.Items.Add(f);
                    f = new StackPanel();
                    f.Orientation = System.Windows.Controls.Orientation.Horizontal;
                    i = 0;
                }
                i++;
            }

[jmix90]

Hello,

En fait il faut que tu instancies un ViewModel par contrôle pour que cela fonctionne je pense...

[cinemania]

non puisqu'il localise le DataContext de chaque controle à une instance d'objet référencé par sa propriété Serveur sur le ViewModel principal.

la question qu'il faut se poser, c'est est-ce que la propriété Serveur retourne une collection sur des ViewModels particuliers ? si oui sont ils tous instanciés.

[obito]

Merci des réponses, faut que je vois tout ça, le problème est laissé en suspend pour le moment, je dois m'occuper d'autres trucs mais je reviendrais dessus prochainement

[seiryujay]

Une piste à étudier...

Tu affectes le DataContext de tes boutons avec la même instance de "indicateurViewModel".
Et dans la méthode Modif() de ton "indicateurViewModel", tu fais :

Code :

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

this.SelectedServeur.VariationHit += 5;

Cette méthode étant appelée par ta commande, si tu ne modifies pas ta propriété SelectedServeur en fonction de l'"indicateur" sur lequel tu agis, il semble normal que ce soit toujours le même qui soit modifié.

Donc question : comment affectes-tu cette propriété SelectedServeur ?

[obito]

Le pire c'est que Modif a exactement ce que tu me propose de faire

Voici pour SelectedServeur :

Code C# :

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

1
2
3
4
5
 
 public ServeurViewModel SelectedServeur
        {
            get { return this.collectionView.CurrentItem as ServeurViewModel; }
        }

Sachant que la collection est rempli dans le constructeur :

Code C# :

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

1
2
3
4
 
 this.collectionView = CollectionViewSource.GetDefaultView(this.serveurs);
            if(this.collectionView == null)
                throw new NullReferenceException("collectionView");

Merci pour l'aide apporté, comme j'ai dit, malheureusement, je dois bosser sur autre chose ce qui fait que mon problème est en suspend, sachant que tout se fera par WCF, pas besoin de bouton pour mettre à jour et donc pas besoin de Command...

En revanche je compte quand même résoudre ce problème, ca me perturbe un peu^^

[obito]

Ca y est j'ai compris ! Je me trompais depuis le début. Dans mon indicateurViewModel j'avais une collection de ProgViewModel... Mais non ! Il me fallait juste un ProgViewModel par Indicateur (puis qu'un Indicateur affiche les infos d'un et un seul Prog)... Du coup dans mon Window1ViewModel j'ai une collection d'IndicateurViewModel et la (même si j'ai pas testé), c'est censé fonctionner !

Merci à tous pour vous être penché sur mon problème, je peux le mettre en résolu

EDIT : C'est la première fois que je me penchais à nouveau sur ce problème depuis un moment d'où le fait que je ne trouve qu'un mois après

EDIT 2 : Je confirme ca fonctionne nikel :

Un peu de code (plusclair qu'avant) :

Dans IndicateurViewModel :

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
 
public IndicateurViewModel(ProgViewModel pr)
        {
 
            if (pr == null)     
                throw new NullReferenceException("ProgViewModel null");
 
            this._prog = pr;         
        }
 
        public ICommand Modif
        {
            get
            {
                if (this.ModifCommand == null)
                    this.ModifCommand = new RelayCommand(() => this.modif_var());
 
                return this.ModifCommand;
            }
        }
 
        private void modif_var()
        {
            this._prog.VariationHit += 55;
 
        }

Dans Window1ViewModel: (appelé MonitoringViewModel) :

Code C# :

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

1
2
 
private Collection<IndicateurViewModel> _indi;

Et dans Window1.xaml.cs :

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
 
private MonitoringViewModel mwm = null;
 
//...
 
 private void traitement()
        {
 
            // Priority à Background car ca évite que la fenêtre soit "occupée" et ne freeze
            this.Dispatcher.BeginInvoke(DispatcherPriority.Background, (ThreadStart)delegate
            {
                p.Children.Clear();
                foreach (IndicateurViewModel o in mwm.IndicateursVM)
                {
 
                    Indicateur ind = new Indicateur();
 
 
                    ind.DataContext = o;
 
                    p.Children.Add(ind);
 
 
                }
 
            });
 
 
        }

Et Indicateur.xaml :

Code XAML :

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

1
2
 
        <Button Margin="0,1,74,73" Command="{Binding Modif}" Content="Modifier" FontSize="10" />