Discussion :

[Ishizaki]

Bonjour, je viens vers vous car je ne sais pas comment résoudre un problème sur un SelectedItem d'une ListBox.

Je vous décris le contexte:

J'ai une liste d'objets Employee sur laquelle se binde ma ListBox (CollectionEmployee). J'ai une propriété SelectedEmployee, de type Employee, qui représente l'Employee sélectionné dans ma ListBox (se binde sur le SelectedItem de cette dernière, en TwoWay).

Mon objet Employee contient deux propriétés dates: StartDate et EndDate. Sur changement de sélection dans ma ListBox, je contrôle les dates, c'est à dire, je vérifie que la StartDate ne soit pas supérieure à la EndDate.

Pour ce faire, dans la propriété SelectedEmployee, je vérifie, avant d'assigner le nouvel Employee, que celui en cours n'ait pas cette erreur de dates. Si oui, je garde l'Employee en cours et j'affiche une ChildWindow montrant l'erreur, sinon, j'assigne la nouvelle valeur à mon SelectedEmployee.

Au niveau données, cela fonctionne, le problème, c'est qu'à l'affichage, même s'il y a une erreur, il passe à l'item sélectionné dans la ListBox, alors que le SelectedItem est pourtant bien conservé.

Je vous montre mon code:

Objet Employee:

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
 
public class Employee
{
 
public string Name{get;set;}
public DateTime EndDate{get;set}
public DateTime StartDate{get;set}
 
/// <summary>
/// Erreurs de date ?
/// </summary>
public bool HasErrorDate
{
            get
            {
                return this.StartDate > this.EndDate;
            }
}
 
}

Classe utilisée en DataContext:

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
 
/// <summary>
        /// Collection d'Employee Sélectionnés
        /// </summary>
        public ObservableCollection<Employee> CollectionEmployee        {
            get
            {
                return this._CollectionEmployee;
            }
            set
            {
                if (this._CollectionEmployee != value)
                {
                    this._CollectionEmployee = value;
                    this.OnNotifyPropertyChanged("CollectionEmployee");
                }
            }
        }
 
        private ObservableCollection<Employee> _CollectionEmployeeA = new ObservableCollection<Employee>();
 
/// <summary>
        /// Salarié sélectionné 
        /// </summary>
        public Employee SelectedEmployee
        {
            get
            {
                return this._SelectedEmployee;
            }
            set
            {
                if (this._SelectedEmployee != value)
                {
                    //On va d'abord regarder si on a des erreurs de date
                    if (this._SelectedEmployee != null)
                    {
                        if (this._SelectedEmployee.HasErrorDate)
                        {
                            //Si oui, on reste sur le même salarié
                            ChildWindow child = new ChildWindow();
                            child.Content = "La date de début est supérieure à la date de fin !";
                            child.Show();
                        }
                        else
                        {
                            this._SelectedEmployee = value;
                        }
                    }
                    else
                    {
                        this._SelectedEmployee = value;
                    }
 
                    //On notifie à chaque fois pour être sûr que la ListBox prenne en compte
                    this.OnNotifyPropertyChanged("SelectedEmployee");
                }
            }
        }
 
        private EmployeeAbsence _SelectedEmployeeAbsence = null;
 
/// <summary>
        /// Evènement de changement de propriété
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;
 
        /// <summary>
        /// Notifier qu'une propriété a changé
        /// </summary>
        /// <param name="propertyName"></param>
        protected virtual void OnNotifyPropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

Le XAML avec la ListBox:

Code :

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

1
2
3
4
5
6
 
 
<ListBox x:Name="ListBoxEmployeeList"  ItemsSource="{Binding CollectionEmployee}"                                               
SelectedItem="{Binding SelectedEmployee, Mode=TwoWay}"
SelectionMode="Single">
</ListBox>

Les dates sont déjà remplies (pour mes tests).

Si vous avez une idée , merci.

[Nathanael Marchand]

Je ne vais pas t'aider sur ton problème car j'ai pas d'idée qui me vient néanmoins je vais te donner un conseil sur le mvvm:
La child window ne devrait pas êtré crée dans le view model: imagine instancier cette classe pour des tests unitaires, comment le test unitaire peut il gérer la popup?

L'idée serait de déleguer tout ce qui est interaction user/interface à la vue. Pour cela il faut que ton viewmodel envoie un message à la vue et que la vue montre la childwindow.

Bon courage pour ton problème qui me semble bien étrange...

[Ishizaki]

J'ai résolu mon problème en oubliant le binding sur le SelectedItem et en me basant sur l'évènement SelectionChanged de ma ListBox.

Code:

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
 
private void ListBoxEmployeeList_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
//ViewModel
if (this.ViewModel != null)
            {
                if (e.AddedItems != null)
                {
                    if (e.AddedItems.Count == 1)
                    {
                        bool canSelectCurrent = true;
 
                        //On va regarder si on a une erreur dans l'élément sélectionné précédemment
                        if (e.RemovedItems != null)
                        {
                            if (e.RemovedItems.Count == 1)
                            {
                                Employee previousEmp = e.RemovedItems[0] as Employee;
 
                                if (previousEmp.HasErrorDate)
                                {
                                    //On alerte
                                    AlertWindow.Show("La date de début est supérieure à la date de fin !");
                                    this.ListBoxEmployeeList.SelectedItem = previousEmp;
                                    this.ViewModel.SelectedEmployee = previousEmp;
                                    canSelectCurrent = false;
                                }
                            }
                        }
 
                        //Si on peut sélectionner celui qui a été choisi
                        if (canSelectCurrent == true)
                        {
                            this.ViewModel.SelectedEmployee = this.ListBoxEmployeeList.SelectedItem as Employee;
                        }
}
}
}
}

Merci pour l'intervention.