Discussion :

[agparchitecture]

Bonjour à tous,

Je me pose une question pratique dans la manière de coder un événement d'un point de vue mémoire, rapidité, maintenabilité, ...

Si je développe un usercontrol avec event de type selectionChanged comment vaut-il mieux le gerer :

1. J'ai un evenement avec des arguments vide et je recupère la selection du control par une propriété
2. Je mets la selection dans les argument de l'évenement ce qui me permet de les avoir directement

Merci pour l'éclaircissement.

[Noxen]

Voici une manière relativement classique de gérer ce genre de situation :

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
    public class SelectionChangedEventArgs : EventArgs
    {
        public object OldItem { get; set; }
        public object NewItem { get; set; }
    }
 
    public delegate void SelectionChangedEventHandler(object sender, SelectionChangedEventArgs eventArgs);
 
    public interface INotifySelectionChanged
    {
        event SelectionChangedEventHandler SelectionChanged;
    }
 
    public class SelectionContainer : INotifySelectionChanged
    {
        private readonly List<object> _items = new List<object>();
        public object[] Items { get { return _items.ToArray(); } }
        public object Current { get; private set; }
 
        public void Add(object item) { if (!_items.Contains(item)) _items.Add(item); }
        public void Remove(object item)
        {
            if (_items.Contains(item))
            {
                _items.Remove(item);
                if (item == Current)
                {
                    Current = null;
                    OnSelectionChanged(item, null);
                }
            }
        }
        public bool Contains(object item)
        {
            return _items.Contains(item);
        }
 
        public void Select(object item)
        {
            if (!_items.Contains(item)) throw new InvalidOperationException("Item is not in container");
            var old = Current;
            Current = item;
            OnSelectionChanged(old, Current);
        }
 
        public event SelectionChangedEventHandler SelectionChanged;
 
        protected void OnSelectionChanged(object oldItem, object newItem)
        {
            var handler = SelectionChanged;
            if (handler != null) handler(this, new SelectionChangedEventArgs { OldItem = oldItem, NewItem = newItem });
        }
    }

En l'occurrence j'ai une sélection d'un seul item (propriété Current), mais il ne devrait pas être trop difficile d'adapter pour prendre charge une sélection multiple. Il te faudra de toute façon transposer ce code sur un UserControl.

[agparchitecture]

E fait je me demande si il vaut mieux faire

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
 
class EventArgsChanged
{
		private readonly list<String> _selection;
 
		public list<String> Selection
		{
			get{ return _selection; }
		}
 
		public EventArgsReadWriteError(list<String> selection)
		{
			_selection = selection;
		}
}
 
class test1
{
public list<String> prop1
{ ... }
 
public event EventHandler<EventArgsChanged> SelectionChanged;
private void OnReadWriteError(EventArgsChanged ev)
{
if (SelectionChanged != null) SelectionChanged(this, new ev(prop1));
}
 
}
 
 
//traitement dans une autre class suite à l'évenement
		void SelectionChanged(object sender, EventArgsChanged e)
		{
			List<string> temp = e.Selection;
//Reste traitement
		}

ou

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
 
class test1
{
public list<String> prop1
{ ... }
 
public event EventHandler SelectionChanged;
private void OnReadWriteError(EventArgsChanged ev)
{
if (SelectionChanged != null) SelectionChanged(this, Args.Empty);
}
 
}
 
 
//traitement dans une autre class suite à l'évenement
 
private test1 objectAvecEvent; //est initialisé et fonctionne
 
		void SelectionChanged(object sender, EventArgs e)
		{
			List<string> temp = objectAvecEvent.prop1;
//Reste traitement
		}

La différence entre les deux est que mon evenement a un paramètre(1) tandis que l'autre a un argument vide(2).

Du coup quelle est la meilleure manière de procéder d'un point de vue mémoire, rapidité, maintenabilité, ...

[MABROUKI]

bonjour

2. Je mets la selection dans les argument de l'évenement ce qui me permet de les avoir directement

MSDN Help Lib Fr à propos du class EventArgs :
"Cette classe ne contient pas de données d'événement ; elle est utilisée par des événements qui ne passent pas d'informations d'état à un gestionnaire d'événements lorsqu'un événement est déclenché. Si le gestionnaire d'événements nécessite des informations d'état, l'application doit dériver une classe à partir de cette classe pour contenir les données.

Par exemple, la classe System.AssemblyLoadEventArgs est utilisée pour contenir les données pour les événements de chargement d'assembly et contient System.Reflection.Assembly décrivant l'assembly chargé. "
Cette méthode est nécessaire si on veut avoir des informations d'état sur l'évènement en plus de l'occurrence de l'évènement lui-même ...
Avec la méthode 1. , après l'occurrence de l'évènement ,la dite propriété peut avoir changé entre temps ..