WPF Bind add new item dans une DataGrid

Version imprimable

Bonjour,

Je suis toujours en cours d'apprentissage en WPF et le MVVM.

je bloque :

J'ai une datagrid, j'aimerai détecter l'ajout d'une ligne dans cette datagrid pour pouvoir l'insérer dans la DB, comment puis-je faire cela sans code-behind, seulement VM ?

J'ai donc lié ma datagrid à une collection

View Model :
Code:

1 2 3 4 5 6 7 ObservableCollection<Activite> actiColl = new ObservableCollection<Activite>(); public ObservableCollection<Activite> ActiColl { get { return actiColl; } set { actiColl = value; } }
XAML :

Code:

ItemsSource="{Binding ActiColl} "

J'ai ensuite lié l'élement sélectionné à une propriété du VM

XAML :

Code:

SelectedItem="{Binding Acti, UpdateSourceTrigger=PropertyChanged}

VM :
Code:

1 2 3 4 5 6 7 8 9 Activite acti; public Activite Acti { get { return acti; } set { acti = value; } }
A quel moment ET comment puis-je réceptionner le fait que j'ajout une ligne dans la datagrid ? Ma "ObservableCollection" se met bien a jour mais je n'arrive pas à trouver le moment ou cela se fait pour mettre à jour ma DB.

Tu as un évènement très utile pour ça : CollectionChanged
Grâce à lui, tu vas pouvoir connaitre si un élément a été ajouté, supprimé, modifié.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public MyViewModel()
        {
            ActiColl= new ObservableCollection<Activite>();
            ActiColl.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(ActiColl_CollectionChanged);
        }
 
        void ActiColl_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (e.NewItems != null)
            {
                // Add
            }
 
            if (e.OldItems != null)
            {
                // Remove
            }
        }

24/01/2013, 16h15
draco951

Bonjour Lordinaire,

Merci beaucoup, c'est merveilleux, en effet cela fonctionne :-)
Il reconnais bien un nouvel objet ou un objet supprimé.

Est-ce qu'on peux faire cela pour d'autres event ?
Par exemple "EndEdit" ?
24/01/2013, 16h33
Lordinaire

Le cas du EndEdit est un peu différent car c'est une méthode appelée par le contrôle directement. Dans ce cas, le plus simple est d'utiliser le code-behind pour faire l'ajout ou appeler une méthode dans le ViewModel qui s'en chargera.
24/01/2013, 16h42
draco951

Imaginons que je veuille réceptionner une valeur après l'avoir encodée (sans utilisée du code behind)

En fait avec la méthode donnée, je récupère le fait qu'un objet est ajouté.
Mais, je ne récupère pas les données ajoutées dans cet objet.

Comment puis-je faire pour les avoir ces données ? :oops:
24/01/2013, 16h50
draco951

De ce que j'ai pu remarque avec :

Code:

ActiColl_CollectionChanged

Je n'ai la possibilité de voir que si :

ma collection à été :

-ajoutée
-déplacée
-supprimée
-remplacée
-reset

Mais je ne vois pas de possibilité de check une modification dans l'objet lui même

C'est après avoir inséré les données que je voudrais faire mon insertion dans ma db :-)
25/01/2013, 09h45
Lordinaire

Citation:

Envoyé par draco951

Imaginons que je veuille réceptionner une valeur après l'avoir encodée (sans utilisée du code behind)

En fait avec la méthode donnée, je récupère le fait qu'un objet est ajouté.
Mais, je ne récupère pas les données ajoutées dans cet objet.

Comment puis-je faire pour les avoir ces données ? :oops:

e.NewItems contient la liste des nouveaux éléments, tu as donc accès à toutes les données de ces objets.

Dans ton scénario, tu veux forcement sauvegarder dès la fin de la modification d'une ligne ? Pas d'appuie sur un bouton Save ?
25/01/2013, 09h50
draco951

Oui :-)

Mais je ne parviens pas à intercepter ce changement :?
04/02/2013, 10h35
draco951

Personne ne saurait m'aider ?

J'ai lu plein de tutoriaux, de forum, ...
Je ne parviens pas à connaître les éléments modifié dans ma datagrid, je bloque vraiment :cry:

La méthode de Lordinaire fonctionne seulement pour les points que j'ai cités, pas pour le modification d'un élément de l'objet.

Et si je voulais faire une sauvegarde de la datagrid, je ne comprend pas comment je fais pour connaitre les éléments ajouté.

Au secours
04/02/2013, 11h51
Sokhz

Cette fonctionnalité n'est pas contenue dans l'ObservableCollection basique.

Il faut que tu fasses hériter une classe de celle-ci afin de pouvoir ajouter un évènement ItemPropertyChanged par exemple :

-Héritage de ObservableCollection.
-Ajout d'un évènement ItemPropertyChanged
-Dans le CollectionChanged, tu viens abonner/désabonner l'évènement element.PropertyChanged sur un handler dans lequel tu lévera l'évènement ItemPropertyChanged (Ne pas oublier de faire le traitement de base du CollectionChanged également).

Ensuite, tu pourras venir t'abonner à l'évènement ItemPropertyChanged de ta collection :)
04/02/2013, 12h01
draco951

Bonjour Sokhz,

Je vais tenter ca, merci pour ces informations :ccool:
Il n'est pas facile de trouver de la bonne documentation sur le wpf et le MVVM :?

Je post dès que j'ai quelques chose de concluant :-)
04/02/2013, 12h15
Sokhz

Voici un exemple :

ObservableCollection avec écoute de changement des propriétés d'un élément

Un grand merci à tous les 2 :ccool:
Vos informations m'ont permises d'arriver à mes fin :-)

je vous affiche le code final :
donc dans mon ViewModel

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
72
73
74
75
76
77
78
79
80
81
82
83
84
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Input;
using System.Collections.Specialized;
using System.ComponentModel;
using BibliDo.Classe;
using BibliDo.Interface;
using MicroMvvm;
 
namespace ControlDo.ViewModels
{
    class VMListeActivite : ObservableObject
    {
 
        Factory facto = new Factory();
        ObservableCollection<Activite> actiCliColl;
 
        public ObservableCollection<Activite> ActiCliColl
        {
            get { return actiCliColl; }
            set { actiCliColl = value; }
        }
 
        Activite acti;
        public Activite Acti
        {
            get { return acti; }
            set { acti = value; }
        }
 
        public VMListeActivite()
        {
            ActiCliColl = new ObservableCollection<Activite>();
            ActiCliColl.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(ActiColl_CollectionChanged);
 
            //Chargement de la liste des activité
            IActivite iact = this.facto.getIActivite();
            Activite[] listActi = iact.ListActiClient();
            foreach (Activite uneActi in listActi)
            {
                uneActi.PropertyChanged += onPropertyChanged; 
                this.actiCliColl.Add(uneActi);
            }
        }
 
        void onPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            //update dans la DB
            Console.WriteLine(this.acti.SActiviteFR + " || " + this.acti.NIdActivite +
                " || " + this.acti.SActiviteNL + " || " + this.acti.STypeActivite);   
        }
 
        void ActiColl_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            // Add
            if (e.NewItems != null)
            {
                Activite uneActi = (Activite)e.NewItems[0];
                if (uneActi.NIdActivite == 0)
                {
                    uneActi.PropertyChanged += onPropertyChanged; 
					//Insertion dans la DB
                }
            }
 
            // Remove
            if (e.OldItems != null)
            {
                Activite uneActi = (Activite)e.OldItems[0];
                uneActi.PropertyChanged -= onPropertyChanged;
				//suppression dans la db
            }
        }
 
        public ICommand RemoveActivite { get { return new RelayCommand(RemoveActiviteExecute, CanRemoveActiviteExecute); } }
        bool CanRemoveActiviteExecute() { return true; }
        void RemoveActiviteExecute() { actiCliColl.Remove(this.acti); }
 
    }
}

La View :

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
<UserControl x:Class="ControlDo.UC.UCListeActivite"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="395" >
 
 
    <Grid>
        <DataGrid AutoGenerateColumns="False" Margin="12" Name="dataGrid1" 
                  ItemsSource="{Binding ActiCliColl, NotifyOnSourceUpdated=True}"
                  SelectedItem="{Binding Acti,
                  Converter={StaticResource SentinelConverter}}" 
                  >
 
            <DataGrid.Columns>
                <DataGridTextColumn Binding="{Binding SActiviteFR, Mode=TwoWay,NotifyOnSourceUpdated=True}" Header="Activite FR" />
                <DataGridTextColumn Binding="{Binding SActiviteNL, Mode=TwoWay,NotifyOnSourceUpdated=True}" Header="Activite NL" />
                <DataGridTemplateColumn>
                    <DataGridTemplateColumn.CellTemplate>
                        <DataTemplate>
                            <Grid>
                                <Button Content="Remove..." Margin="3" 
                                        Command="{Binding DataContext.RemoveActivite,RelativeSource=
                                    {RelativeSource AncestorType={x:Type DataGrid}}}" />
                            </Grid>
                        </DataTemplate>
                    </DataGridTemplateColumn.CellTemplate>
                </DataGridTemplateColumn>
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
</UserControl>

Le Model :

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MicroMvvm;
 
namespace BibliDo.Classe
{
    public class Activite : ObservableObject
    {
        private int nIdActivite;
        private String sActiviteFR;
        private String sActiviteNL;
        /// <summary>
        /// On différencie plusieurs actité ;  'G' : Pour les garages ; 'D' : pour les clients
        /// </summary>
        private String sTypeActivite;
 
 
        public Activite()
        {
        }
 
        ~Activite()
        {
        }
 
        public Activite(Activite act)
        {
            this.nIdActivite = act.nIdActivite;
            this.sActiviteFR = act.sActiviteFR;
            this.sActiviteNL = act.sActiviteNL;
            this.sTypeActivite = act.sTypeActivite;
        }
        public String SActiviteNL
        {
            get { return sActiviteNL; }
            set { sActiviteNL = value; RaisePropertyChanged("SActiviteNL"); }
        }
 
        public String SActiviteFR
        {
            get { return sActiviteFR; }
            set { sActiviteFR = value; RaisePropertyChanged("SActiviteFR"); }
        }
 
        public int NIdActivite
        {
            get { return nIdActivite; }
            set { nIdActivite = value; RaisePropertyChanged("NIdActivite"); }
        }
 
        public String STypeActivite
        {
            get { return sTypeActivite; }
            set { sTypeActivite = value; RaisePropertyChanged("STypeActivite"); }
        }
    }
}

J'ai du aussi pour permettre l'ajout d'une ligne ajouter un converter :

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Data;
 
namespace ControlDo.ViewModels
{
    class SentinelConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter
            , System.Globalization.CultureInfo culture)
        {
            return value;
        }
 
        public object ConvertBack(object value, Type targetType, object parameter
            , System.Globalization.CultureInfo culture)
        {
            if (value != null && string.Equals("{NewItemPlaceholder}", value.ToString(), StringComparison.Ordinal))
            {
                return null;
            }
 
            return value;
        }
    }
}

Encore un grand merci :-)