Discussion :

[kerinel]

Bonjour,
je lisais la (le ? ) msdn pour faire des événements personnalisés et plus particulièrement cette page.
Or il y a un truc qui m'a interpellé, c'est ceci qui est dans l'exemple, classe Publisher:

Code :

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

1
2
3
4
// Make a temporary copy of the event to avoid possibility of
// a race condition if the last subscriber unsubscribes
// immediately after the null check and before the event is raised.
EventHandler<CustomEventArgs> handler = RaiseCustomEvent;

et plus particulièrement l'affirmation que l'opérateur = réalise une copie de l'objet et non une assignation.
D'où ma question : comment sait-on lorsque = est une assignation et lorsque = est un clonage ? Car du coup j'ai un peu l'impression de ne plus trop coder objet là.
Merci
Bon code,
kerinel

[Er3van]

On devrait dire "le" MSDN (car MS Developer Network), mais j'ai toujours dit "la", sans doute car c'est une documentation en ligne et qu'on dit "la" JavaDoc...

...mais revenons à la question initiale :

RaiseCustomEvent étant un évènement, en faisant cette assignation tu crées en réalité un nouveau délégué, tu ne fais pas une affectation.

Cet article te l'expliquera mieux que moi je pense :Delegates are immutable

[kerinel]

Bonjour,
merci pour la réponse tardive et désolé pour le retour tardif

Ici je n'utilise pas l'opérande += ou -= mais bien = l'objectif étant de faire une "copie de". Or pour moi si j'écris :

Code :

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

1
2
3
4
 
myObject o1 = new MyObject();
 
myObject o2 = o1;

o2 et o1 sont bien deux références sur le même objet. et dans le code précédent il n'y a donc pas de duplication ou de modification de l'event.

Merci,
Bon code,
kerinel

[Nathanael Marchand]

Bonjour,
merci pour la réponse tardive et désolé pour le retour tardif

Ici je n'utilise pas l'opérande += ou -= mais bien = l'objectif étant de faire une "copie de". Or pour moi si j'écris :

Code :

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

1
2
3
4
 
myObject o1 = new MyObject();
 
myObject o2 = o1;

o2 et o1 sont bien deux références sur le même objet. et dans le code précédent il n'y a donc pas de duplication ou de modification de l'event.

Merci,
Bon code,
kerinel

C'est pas toujours vrai! C'est uniquement les types références qui sont concernés par ton affirmation

Exemple avec un type valeur:

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
void Main()
{
	MyType a = new MyType();
	MyType b = a;
 
	Console.WriteLine(a.i); //0
	Console.WriteLine(b.i); //0
 
	b.Foo();
 
	Console.WriteLine(a.i); //0
	Console.WriteLine(b.i); //1
}
 
public struct MyType
{
	public int i;
 
	public void Foo()
	{
		i++;
	}
}

[DonQuiche]

Il n'y a rien de magique, il s'agit bien ici d'une simple assignation et non d'une copie. Quand un abonné va se désabonner (via -=), il va créer un nouveau délégué.
* Avant le désabonnement : RaiseCustomEvent = A = { X, Y, Z }
* Après le désabonnement : RaiseCustomEvent = B = A - Z = { X, Y }
Donc, après l'appel à -= RaiseCustomEvent contiendra bien une référence différente, B, et non plus A.

Dans le code ci-dessous, tiré de MSDN, imaginons qu'il y ait au début de la méthode un seul abonné. RaiseCustomEvent est une référence vers X, le handler de cet abonné. Si entre la première et le dernière ligne l'abonné se désabonne, RaiseCustomEvent aura désormais la valeur null. Mais la variable locale, elle, contiendra toujours X. Si l'on n'avait pas utilisé cette variable locale et que l'on avait directement testé puis appelé RaiseCustomEvent, le test aurait pu être validé mais l'invocation échouer car entretemps l'unique abonné se serait désabonné.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
            EventHandler<CustomEventArgs> handler = RaiseCustomEvent;
 
            // Event will be null if there are no subscribers
            if (handler != null)
            {
                // Format the string to send inside the CustomEventArgs parameter
                e.Message += String.Format(" at {0}", DateTime.Now.ToString());
 
                // Use the () operator to raise the event.
                handler(this, e);
            }

Tout réside dans le fait que les opérateurs "+" et "-" ne modifient pas les références existantes (puisque les délégués sont immutables) mais en créent de nouvelles. Et c'est cette nouvelle référence qui est assignée quand on utilise "+=" et "-="

[kerinel]

Merci a tous, je crois que je viens de comprendre. En faisant EventHandler<CustomEventArgs> handler = RaiseCustomEvent; handler et RaiseCustomEvent désignent toujours le même objet.
Et, si rien ne se passe pendant les notifications "on s'en moque un peu".

Par contre, si il y a un désabonnement (ou un abonnement) pendant l'opération de notification, c'est la variable RaiseCustomEvent qui dès lors désignera un nouvel objet et handler continuera à désigner le premier EventHandler, ce qui évitera les problèmes.

(et en fait l'explication donnée en commentaire de code dans le msdn est erronée puisqu'il ne s'agit à aucun moment d'une copie de l'objet).

merci à tous,
Bon code,
kerinel

[Nathanael Marchand]

Euh non non, le commentaire est correcte.
Il faut voir un évènement comme un tableau de personnes à contacter.
"Si l'évènement se produit, appelle Toto, Titi et Tutu."
Sauf que tu récupères toujours une copie dudit tableau, jamais l'original.
Et c'est bien pour ca que ca marche car en cas de changement du tableau original, avec ta copie soit t'oublies d'appeller quelqu'un (qui s'est abonné entre temps), soit t'appelles quelqu'un en trop (qui s'est désabonné entre temps) mais tu aurais eu quelque chose de non null.
Ca aurait été une référence, ca aurait pu devenir null entre temps et ca aurait levé une erreur.