Est-ce que la conversion d’un object en C # renvoie toujours une référence à l’object initial

Je travaille actuellement sur un projet en C # utilisant des formulaires Windows. Au cours de celui-ci, j’ai fait ce qui suit

void HideButtons(object sender, EventArgs e) { Button hider = ((Button)sender); foreach(Button tohide in hider.Parent.Controls) tohide.Hide(); hider.Show(); hider.Text = "UnHide"; hider.Click -= new EventHandler(HideButtons); hider.Click += new EventHandler(ShowButtons); } 

Le but de ce code est d’avoir un bouton qui cache tous les autres boutons du conteneur dans lequel il se trouve, sauf le sien, puis de se transformer en bouton Unhide qui fait la même chose en sens inverse.

Maintenant, tout va bien, sauf que, en compilant ceci, je me rends compte que j’ai un problème. Hider est son object unique, étant le retour de (expéditeur (bouton)). Ce n’est pas nécessairement la référence à l’expéditeur, et ce code ne fera probablement rien.

Mais bas et voici, cela fonctionne exactement comme je le voulais et le pensais initialement. Ce qui m’a amené à me demander si un casting retourne toujours une référence à l’object d’origine? Si non, comment puis-je garantir que l’expéditeur (bouton) = l’expéditeur?

Je sais que ce n’est pas le cas pour les doubles / ints,

  public static int Main() { int a; double b; b = 10.5; a = (int)b; a++; return 0; } 

aboutit à un être 11 et un b à 10,5, mais cela peut être dû au fait que les doubles / entants sont des structures. Ce comportement m’inquiète et il serait bon de savoir qu’il renverra toujours une référence afin que je puisse mettre mon esprit inquiet au repos.

Pour les types de référence. si la dissortingbution est juste en haut ou en bas de la hiérarchie d’inheritance, alors oui. Ceci est une conversion de référence . Dans les spécifications de langage C # 3.0, section 6.2.4:

Les conversions de référence, implicites ou explicites, ne changent jamais l’identité référentielle de l’object à convertir. En d’autres termes, bien qu’une conversion de référence puisse changer le type de la référence, elle ne change jamais le type ou la valeur de l’object auquel il est fait référence.

C’est le cas que vous utilisez dans votre code WinForms.

Cependant, dans d’autres cas (encore du type de référence), il peut invoquer une conversion définie par l’ utilisateur . Par exemple:

 using System; class Foo { } class Bar { public static explicit operator Bar(Foo f) { return new Bar(); } } class Test { static void Main() { Foo f = new Foo(); Bar b = (Bar) f; Console.WriteLine(object.ReferenceEquals(f, b)); // Prints False } } 

Les conversions définies par l’utilisateur comme celle-ci sont relativement rares.

Pour les types de valeur, il existe des conversions boxing et unboxing, ainsi que d’autres conversions (par exemple, entre int et double ).

Pour les types de référence diffusés via la hiérarchie d’inheritance, il fera toujours référence à la même instance. Cependant, pour les types de valeur, les conversions peuvent impliquer la boxe et le déballage, ce qui permet de copier des contenus. En dehors de cela, les conversions ne sont pas uniquement dans la hiérarchie des inheritances. Vous pouvez déclarer votre propre opérateur de transtypage présentant les caractéristiques d’une méthode. Il peut retourner n’importe quel object qu’il aime.