Discussion :

[Edtech]

Bonjour,

J'ai cherché unpeu partout sur le site mais rien ne vient résoudre mon problème.

J'ai créé une classe qui contient une propriété de type ObservableCollection. Je lie ensuite cette collection à mon interface WPF via le ItemsSource d'un ListBox.

Si dans le contructeur de ma classe, j'ajoute quelques enregistrements à ma collection, ils apparaissent bien (même en conception) dans mon ListBox.

Si j'ajoute à l'exécution des enregistrements à la collection, ils ne sont pas pris en compte (il sont bien dans la collection mais pas affichés).

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
    public class Batch : INotifyPropertyChanged
    {
        private ObservableCollection<Document> _documents = new ObservableCollection<Document>();
 
        /// <summary>
        /// Event emit when a property change.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;
 
        /// <summary>
        /// List of the documents.
        /// </summary>
        public ObservableCollection<Document> documents
        {
            get { return _documents; }
            set { _documents = value; OnPropertyChanged("documents"); }
        }
 
        /// <summary>
        /// Event for a property changement.
        /// </summary>
        /// <param name="name">Name of the property.</param>
        protected void OnPropertyChanged(string name)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(name));
            }
        }
    }

J'ai ajouté les notifications par acquis de conscience, mais en toute logique, ça ne sert à rien dans ce cas, vu qu'il ne se déclenchera que quand je remplacerait la collection complètement (si je pige bien le mécanisme).

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
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
<Window x:Class="TestDocument.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:Documents;assembly=Documents"
        Title="MainWindow" Height="350" Width="525">
    <Window.Resources>
        <local:Batch x:Key="batch" />
        <CollectionViewSource 
                      Source="{Binding Source={StaticResource ResourceKey=batch}, Path=documents}"   
                      x:Key="documentsView" />        
    </Window.Resources>
    <Grid>
        <Button Content="Chèque" Height="23" HorizontalAlignment="Left" Margin="12,12,0,0" Name="button1" VerticalAlignment="Top" Width="104" Click="button1_Click" />
        <Button Content="Titre CMC7" Height="23" HorizontalAlignment="Left" Margin="122,12,0,0" Name="button2" VerticalAlignment="Top" Width="104" Click="button2_Click" />
        <Button Content="Titre Code-barres" Height="23" HorizontalAlignment="Left" Margin="232,12,0,0" Name="button3" VerticalAlignment="Top" Width="104" Click="button3_Click" />
        <Button Content="Lot" Height="23" HorizontalAlignment="Right" Margin="0,12,12,0" Name="button4" VerticalAlignment="Top" Width="75" Click="button4_Click" />
        <ListBox Margin="12,41,12,40" ItemsSource="{Binding Source={StaticResource documentsView}}" IsSynchronizedWithCurrentItem="True">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Grid>
                        <Grid.RowDefinitions>
                            <RowDefinition/>
                            <RowDefinition/>
                            <RowDefinition/>
                        </Grid.RowDefinitions>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="*"/>
                            <ColumnDefinition Width="*"/>
                        </Grid.ColumnDefinitions>
                        <TextBlock Grid.Row="0" Grid.Column="0" Margin="0,0,8,0" Name="codeline">Piste :</TextBlock>
                        <TextBlock Grid.Row="1" Grid.Column="0" Margin="0,0,8,0" Name="amount">Montant :</TextBlock>
                        <TextBlock Grid.Row="2" Grid.Column="0" Margin="0,0,8,0" Name="areas">Zones :</TextBlock>
                        <TextBlock Grid.Row="0" Grid.Column="1" Text="{Binding Path=codeline.value}"/>
                        <TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding Path=amount}" />                        
                    </Grid>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</Window>

Quelqu'un a t-il une idée ?

[Edtech]

Après encore pas mal de recherches, j'ai remarqué que certains renvoyait un événement PropertyChanged lorsqu'un CollectionChanged était émit par la collection. J'ai donc modifié mon code en conséquence.

Mais quand je mets un point d'arrêt sur l'évémenent, j'ai toujours PropertyChanged == null donc il ne l'émet pas plus loin...

Code :

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
 
namespace Documents
{
 
    #region Class Batch
 
    /// <summary>
    /// Batch of documents.
    /// </summary>
    public class Batch : INotifyPropertyChanged
    {
        private ObservableCollection<Document> _documents = new ObservableCollection<Document>();
 
        /// <summary>
        /// Event emit when a property change.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;
 
        /// <summary>
        /// List of the documents.
        /// </summary>
        public ReadOnlyObservableCollection<Document> documents
        {
            get { return new ReadOnlyObservableCollection<Document>(_documents); }
        }
 
        /// <summary>
        /// Constructor.
        /// </summary>
        public Batch()
        {
            _documents.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(_documents_CollectionChanged);
        }
 
        private void _documents_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (PropertyChanged != null) 
            { 
                PropertyChanged(this, new PropertyChangedEventArgs("documents")); 
            }
        }
 
        /// <summary>
        /// Add a new document to the batch.
        /// </summary>
        /// <param name="document">Document to add.</param>
        public void Add(Document document)
        {
            _documents.Add(document);
        }
 
        /// <summary>
        /// Event for a property changement.
        /// </summary>
        /// <param name="name">Name of the property.</param>
        protected void OnPropertyChanged(string name)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(name));
            }
        }
    }
 
    #endregion
}

[Nathanael Marchand]

J'dirais que ca vient du fait que tu ne bindes pas directement ta collection mais que ta collection sert pour la collectionviewsource qui elle est bindé. Si tu bindes directement, ca devrait marcher.

[Edtech]

J'ai mis directement le binding dans la listbox, mais ça ne fonctionne toujours pas :

Code :

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

<ListBox Margin="12,41,12,40" ItemsSource="{Binding Source=batch, Path=documents}" IsSynchronizedWithCurrentItem="True">

[Cecile5]

Salut,

Voici un exemple qui fonctionne bien :

Ma classe métier Document :

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 Document : NotifyPropertyChanged
    {
        private string name;
        public string Name
        {
            get { return name; }
            set
            {
                name = value;
                RaisePropertyChanged(this, o => o.Name);
            }
        }
    }

Ma vue :

Code xml :

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

1
2
3
4
5
6
7
<ListBox ItemsSource="{Binding Docs}">
        <ListBox.ItemTemplate>
            <DataTemplate>
                <Label Content="{Binding Name}" />
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>

DataContext :

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
public class VM
    {
        public ObservableCollection<Document> Docs { get; set; }
 
        public VM()
        {
            Docs = new ObservableCollection<Document>();
 
            Document doc1 = new Document();
            doc1.Name = "nom 1";
 
            Docs.Add(doc1);
 
            doc1.Name = "nom 2";
        }
    }

A l'exécution le document est bien dans la liste et il a bien "nom 2".
Bon code.

[Edtech]

Quel assembly utilises-tu pour la première partie de ton exemple ?

Je n'ai ni NotifyPropertyChanged, ni RaisePropertyChanged, et ce même si j'ajoute System.ComponentModel et System.Collections.ObjectModel.

Je suis parti de cet exemple :

http://msdn.microsoft.com/query/dev1...SHARP)&rd=true

[Cecile5]

C'est une classe "maison" qui implémente INotifyPropertyChanged :

Code c# :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class NotifyPropertyChanged : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
 
        public void RaisePropertyChanged<T, P>(T source, Expression<Func<T, P>> pe)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged.Invoke(source, new PropertyChangedEventArgs(((MemberExpression)pe.Body).Member.Name));
            }
        }
    }

Je te renvoie au post traitant des implémentations de INotifyPropertyChanged :

http://www.developpez.net/forums/d10...mplementation/

[Edtech]

Voilà ce que j'ai écrit, mais ça n'affiche rien :

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
<Window x:Class="WpfApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <ListBox ItemsSource="{Binding Docs}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Label Content="{Binding Name}" />
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</Window>

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
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
 
namespace WpfApplication1
{
    public class VM
    {
        public ObservableCollection<Document> Docs { get; set; }
 
        public VM()
        {
            Docs = new ObservableCollection<Document>();
 
            Document doc1 = new Document();
            doc1.Name = "nom 1";
 
            Docs.Add(doc1);
 
            doc1.Name = "nom 2";
        }
    }
}

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace WpfApplication1
{
    public class Document : NotifyPropertyChanged
    {
        private string name;
        public string Name
        {
            get { return name; }
            set
            {
                name = value;
                RaisePropertyChanged(this, o => o.Name);
            }
        }
    }
}

Je n'ai aucun code que celui par défaut dans le MainWindows.xaml.cs. Je travaille en .NET 4/C# 4/WPF.

J'ai du mal à comprendre comment on peut travailler sur Docs alors qu'il n'est jamais créé. Ou alors j'ai loupé quelque chose dans les explications !

Il ne doit vraiment pas me manquer grand chose !

Au passage, si je regarde la liaison par l'éditeur, il me dit que Docs ne peut pas être résolu...

[The_badger_man]

Dans ton dernier example tu as oublié de définir le datacontext de ta fenêtre.

[Cecile5]

Est-ce que tu as défini ta classe VM comme DataContext de ta vue, avec un truc du genre :

Code c# :

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

1
2
3
4
5
6
7
8
public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            DataContext = new VM();
        }
    }

[Edtech]

Ok, là ça s'affiche,merci.

Donc, si je comprends bien, maintenant, si je veux que l'interface puisse ajouter, il faut que je gère des commandes appelable depuis le XAML, c'est bien ça ?

[Cecile5]

Que veux-tu dire par :

si je veux que l'interface puisse ajouter

Tu voudrais que lorsque l'utilisateur clique sur un bouton par exemple, cela ajoute une ligne à ta liste?

[Edtech]

Oui, tout à fait, j'ai d'ailleurs trouvé quelques exemples, mais je vois mal comment on peut passer des paramètres.

[Cecile5]

Nouvel exemple :

Classe implémentant ICommand, trouvée sur le site Microsoft :

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
public class RelayCommand : ICommand
    {
        #region Fields
 
        readonly Action<object> _execute;
        readonly Predicate<object> _canExecute;
 
        #endregion
 
        #region Constructors
 
        public RelayCommand(Action<object> execute)
            : this(execute, null)
        {
        }
 
        public RelayCommand(Action<object> execute, Predicate<object> canExecute)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");
 
            _execute = execute;
            _canExecute = canExecute;
        }
 
        #endregion
 
        #region ICommand Members
 
        [DebuggerStepThrough]
        public bool CanExecute(object parameter)
        {
            return _canExecute == null ? true : _canExecute(parameter);
        }
 
        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }
 
        public void Execute(object parameter)
        {
            _execute(parameter);
        }
 
        #endregion
    }

Ma vue avec ajout d'un TextBox pour saisir un nom et d'un bouton pour l'ajout :

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
<StackPanel>
 
        <ListBox ItemsSource="{Binding Docs}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Label Content="{Binding Name}" />
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
 
        <TextBox Text="{Binding AddingName}" Margin="10" />
        <Button Content="Add" Margin="10" Command="{Binding AddCommand}" />
 
    </StackPanel>

La VM avec ajout du binding du TextBox et ajout d'une commande pour le bouton :

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
public class VM
    {
        public ObservableCollection<Document> Docs { get; set; }
 
        public string AddingName { get; set; }
 
        public VM()
        {
            Docs = new ObservableCollection<Document>();
 
            Document doc1 = new Document();
            doc1.Name = "nom 1";
 
            Docs.Add(doc1);
 
            doc1.Name = "nom 2";
        }
 
        private RelayCommand _addCommand;
        public ICommand AddCommand
        {
            get
            {
                if (_addCommand == null)
                    _addCommand = new RelayCommand(param => Add());
                return _addCommand;
            }
        }
 
        private void Add()
        {
            Document doc = new Document();
            doc.Name = AddingName;
            Docs.Add(doc);
        }
    }

NB : dans le xaml, on peut renseigner la propriété CommandParameter sur le bouton pour passer un paramètre à la commande depuis le XAML.
Ici je ne m'en suis pas servie car je bind le contenu de mon TextBox à la propriété AddingName du DataContext.

[Edtech]

Ok, ça fonctionne. Je vais analyser ça et finir ma bibliothèque

Merci d'avoir pris le temps de me répondre, ça m'a beaucoup aidé
Et comme ça, j'ai passé mon projet en MVVM, tant mieux !

[limalima]

Bonjour,
RaisePropertyChanged n'est pas reconnue!!, est ce une méthode de INotifyPropertyChanged?

[binoo]

Bonjour,
RaisePropertyChanged n'est pas reconnue!!, est ce une méthode de INotifyPropertyChanged?

Non, si tu lis tous les messages, tu peux voir post 7 que ça vient d'une classe NotifyPropertyChanged qui elle implémente INotifyPropertyChanged.

[Edtech]

Bonjour,

Au post #14, il est question d'utiliser CommandParameter. Quelqu'un aurait-il un exemple d'une telle utilisation ?