Discussion :

[Bindy]

Bonjour,

j'ai un petit problème d'actualisation d'ObservableCollection.

Pour mon projet, j'ai 2 fichiers XML bindés, dont 1, les données s'affichent dans une listView(pas de problème d'actualisation de la collection) et l'autre fichier XML bindé, s'affiche dans des champs TextBox.

Malheureusement lors de modification des TextBox, je n'arrive pas à sérializer les changements, car l'ObservableCollection ne tient pas compte des changements.

Ce qui me déboussole un peu, c'est que pour la collection liée à la listView, j'ai pratiquement le même code et pourtant dès que je modifie un champ, la modification est bien reportée dans l'observableCollection...

J'ai testé : INotifyPropertyChanged mais sans résultat.

Voici les points principaux de mon projet :

XAML:

Code :

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

1
2
3
4
 
 
<c:ConfigCollection x:Key="Config"/>
<TextBox Name="tbOffset" Text='{Binding Source={StaticResource Config}, Path=Offset}' />

Classe ObservableCollection

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
 public class Config : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        public SetupFtpSsh SetupFtpSsh;
           
        public Config()
        {

        }
        
        private void OnPropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

        //Deserialize a XML file and send it in a collection
        public ConfigCollection LoadConfig(ConfigCollection pConfigCollection, string pFilePath)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(ConfigCollection));
            using (StreamReader streamReader = new StreamReader(pFilePath))
            {
                pConfigCollection = xmlSerializer.Deserialize(streamReader) as ConfigCollection;
            }
            return pConfigCollection;
        }
        //Serialize a XML file from a collection
        public void SaveConfig(ConfigCollection pConfigCollection, string pFilePath)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(ConfigCollection));
            using (StreamWriter streamWriter = new StreamWriter(pFilePath))
            {
                xmlSerializer.Serialize(streamWriter, pConfigCollection);
            }
        }

    }

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
public class SetupFtpSsh
       {
           public event PropertyChangedEventHandler PropertyChanged;
 
           private string offset;
 
 
           public SetupFtpSsh()
           {
 
           }
 
           private void OnPropertyChanged(string propertyName)
           {
               if (this.PropertyChanged != null)
                   this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
           }
 
           public SetupFtpSsh(string offset)
           {
               this.offset = offset;
           }
 
           public string Offset
           {
               get { return offset; }
               set { offset = value; }
           }

Code behind

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
        private Config config = new Config();
        private ConfigCollection configCollection = new ConfigCollection();

 public Window1()
        {
configCollection = config.LoadConfig(configCollection, filePathConfig);//Le load marche parfaitement

foreach (Config t_config in configCollection)
             {
            // SetupFtpSsh Part
                tbOffset.Text = t_config.SetupFtpSsh.Offset;
}

L'appel de la méthode Save où la collection ne se met pas à jour automatiquement

Code :

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

1
2
3
4
private void buttonSaveConfiguration_Click(object sender, RoutedEventArgs e)
        {
            config.SaveConfig(configCollection, filePathConfig);
        }

configCollection n'est jamais touché mis à part ces lignes ci-dessus.

D'où pourrait provenir le problème ??

J'ai pensé au binding qui est fait directement sur le TextBox(y'en a plusieurs dans mon programme bien sûr) à la place de faire le Binding sur un élément Group par exemple (StackPanel ou autres).

Sinon, j'ai tenté d'approfondir avec INotifyPropertyChanged(enlevé, déplacé). et là aucun changement.

Ce que je n'ai pas bien compris, pour ma listView, j'ai totalement enlevé les appels de INotifyPropertyChanged et pourtant, ma collection se mettait toujours à jour !!!!


Un grand merci d'avance pour votre aide.

[ikeas]

deja pour que ca marche il faudrait mettre

Code :

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

1
2
3
4
5
6
7
8
9
10
public string Offset
           {
               get { return offset; }
               set 
{ 
offset = value; 
OnPropertyChanged("Offset")
 
}
           }

et faire

Code :

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

public class SetupFtpSsh : INotifyPropertyChanged

[Bindy]

tester mais ca ne change rien.

Comment se fait-il, que même sans cela, j'arrive à "choper" les modifs de mon autre ObservableCollection bindé sur une ListView ???

J'ai testé cette ObservableCollection sans INotifyPropertyChanged et pourtant les modifications sont bien gérées...

[ikeas]

en fait la observable collection implemente deja inotifipropertychanged et la notification pour les collections

ce que j'arrive pas a comprendre dans ton code c'est comment tu distingue les deux (la collection et l'objet de la collection)

je ne te cache pas que si tu avais un petit source de base fonctionel montrant ton probleme ca serais deja resolu eheheheheheh

[Bindy]

ok pour ObservableCollection.

J'ai essayé de "résumer" mon projet et de ne mettre que le nécessaire.

Alors je vais essayer de montrer des autres parts du code, si tu as besoin d'autres infos, n'hésite pas et encore merci d'avance

le code XML de mon fichier config.xml donne quelquechose comme :

Code :

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

1
2
3
4
5
6
7
8
9
<ConfigCycling xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Config>
    <SetupFtpSsh>
      <Offset>1</Offset>
    </SetupFtpSsh>
    <NavigationSetup>
</NavigationSetup>
</Config>
</ConfigCycling>

L'affichage XAML du Bindage qui ne se met pas à jour (ConfigCollection)

Code :

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

1
2
<Window.Resources>
        <c:ConfigCollection x:Key="Config"/>

Code :

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

<TextBox Name="tbOffset" Text='{Binding Source={StaticResource Config}, Path=Offset}' />

L'initialisation de mes TextBox dans mon code behind.

Code :

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

1
2
3
4
5
6
7
8
9
public Window1()
        {
            InitializeComponent();
            //Load information inside filePathConfig and put into configCollection
            configCollection = config.LoadConfig(configCollection, filePathConfig);
 
         //parse of the configCollection and place into Textboxes
            foreach (Config t_config in configCollection)
            {  tbOffset.Text = t_config.NavigationSetup.Offset;

Le code ci-dessous est celui de mon autre ObservableCollection avec mon autre fichier XML et qui celui se met à jour parfaitement.

fichier XML :

Code :

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

1
2
3
4
5
6
7
<Cycling xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Track>
    <Order1>1</Order1>
    <Order2>Add</Order2>
    <Title>title</Title>
  </Track>
</Cycling>

La classe de l'ObservableCollection

Code :

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

1
2
3
4
5
6
7
8
9
[XmlRoot("Cycling")]
    public class TrackCollection : ObservableCollection<Track>
    {
        public TrackCollection()
            : base()
        {
 
        }
    }

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
70
71
72
73
74
75
76
77
78
 public class Track : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
 
        private string order1;
        private string order2;
        private string title;
 
        public Track()
        {
 
        }
 
public Track(string order1, string order2, string title)
        {
            this.order1 = order1;
            this.order2 = order2;
            this.title = title;
        }
 
public string Order1
        {
            get { return order1; }
            set
            {
                order1 = value;
            }
        }
 
        public string Order2
        {
            get { return order2; }
            set
            {
                order2 = value;
            }
        }
 
        public string Title
        {
            get { return title; }
            set { title = value; }
        }
 
rivate void OnPropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
 
        public void AddTrack(TrackCollection pTrackCollection)
        {
            int compteur = pTrackCollection.Count+1;
            Track track = new Track(Convert.ToString(compteur), "Add", "title");
 
            pTrackCollection.Add(track);
        }
 
//Serialize a XML file from a collection
        public void SaveTrack(TrackCollection pTrackCollection, string pFilePath)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(TrackCollection));
            using (StreamWriter streamWriter = new StreamWriter(pFilePath))
            {
                xmlSerializer.Serialize(streamWriter, pTrackCollection);
            }
        }
 
        //Deserialize a XML file and send it in a collection
        public TrackCollection LoadTrack(TrackCollection pTrackCollection,string pFilePath)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(TrackCollection));
            using (StreamReader streamReader = new StreamReader(pFilePath))
            {
                pTrackCollection = xmlSerializer.Deserialize(streamReader) as TrackCollection;
            }
            return pTrackCollection;
        }

La fenêtre du code behind :

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
public partial class Window1 : Window
    {
//Declaration of track and trackCollection
        private Track track = new Track();
        private TrackCollection trackCollection = new TrackCollection();
 
public Window1()
        {
            InitializeComponent();
 
 //Load information inside filePathData and put into trackCollection
            trackCollection = track.LoadTrack(trackCollection, filePathData);
            listView.ItemsSource = trackCollection;
 
/*
         * Add of a Track
         */
        private void Add_Click(object sender, RoutedEventArgs e)
        {
            trackCollection = (TrackCollection)listView.ItemsSource;
            track.AddTrack(trackCollection);
        }
        /*
         * save the modification of the listView in the XML file
         */
        private void Save_Click(object sender, RoutedEventArgs e)
        {
           // TrackCollection trackCollection;
            //trackCollection = (TrackCollection)listView.ItemsSource;
 
            track.SaveTrack(trackCollection, filePathData);         
        }

au niveau XAML, l'affichage se fait dans 1 listView comme ceci.

Code :

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

1
2
<Window.Resources>
        <c:TrackCollection x:Key="TrackListData"/>

Code :

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

 <ListView x:Name="listView" ItemsSource='{Binding Source={StaticResource TrackListData}}'>

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
<ListView.View>
                                    <GridView>
                                        <GridViewColumn Width="150" >
                                            <!--tag is useful to sort the listview by column-->
                                            <GridViewColumnHeader Content="Order1" Click="SortClick"  Tag="Order1"/>
                                            <GridViewColumn.CellTemplate>
                                                <DataTemplate>
                                                    <Grid>
                                                        <TextBlock Style="{StaticResource GridBlockStyle}" Text="{Binding Path=Order1}" />
                                                        <TextBox Name="Order1" Style="{StaticResource GridEditStyle}" Text="{Binding Path=Order1, Mode=TwoWay}"/>
 
                                                    </Grid>
                                                </DataTemplate>
                                            </GridViewColumn.CellTemplate>
                                        </GridViewColumn>

ce que je peux encore préciser, c'est qu'il y a "1 étage" de différence entre mon premier fichier XML et le second et que dans 1(celui qui marche), on affiche le résultat dans 1 ListView, et l'autre dans des textBox

[Bindy]

je me rapproche du but!

j'ai remarqué que lorsque l'on quittait le TextBox avec une modification des données l'on passait (pour la partie qui fonctionne) dans la méthode:

Code :

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

1
2
3
4
5
6
7
8
9
 public string Order1
        {
            get { return order1; }
            set
            {  
                order1 = value;
                OnPropertyChanged("Order1");
            }
        }

mais jamais dans (autreObservableCollection qui ne fonctionne pas)

Code :

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

1
2
3
4
5
6
7
8
9
public string Offset
        {
            get { return offset; }
            set 
            {
                offset = value;
                OnPropertyChanged("Offset");
            }
        }

donc on set jamais la valeur et c'est pour ça que la Collection ne se met pas à jour. Maintenant reste à trouver pourquoi l'on passe 1x et pas l'autre sur l'événement perte de focus sur une textBox (que je n'ai jamais implémenté, c'est automatique)