Je vais essayer une explication:
Je pense que nous comprenons comment fonctionnent les types de valeur? Les types de valeurs sont (int, long, struct etc.). Lorsque vous les envoyez dans une fonction sans commande ref, il COPIE les données . Tout ce que vous faites pour ces données dans la fonction affecte uniquement la copie, pas l'original. La commande ref envoie les données ACTUELLES et toute modification affectera les données en dehors de la fonction.
Ok sur la partie déroutante, types de référence:
Permet de créer un type de référence:
List<string> someobject = new List<string>()
Lorsque vous créez un nouvel objet , deux parties sont créées:
- Le bloc de mémoire qui contient les données de certains objets .
- Une référence (pointeur) vers ce bloc de données.
Maintenant, lorsque vous envoyez un objet dans une méthode sans référence, il COPIE le pointeur de référence , PAS les données. Vous avez donc maintenant ceci:
(outside method) reference1 => someobject
(inside method) reference2 => someobject
Deux références pointant vers le même objet. Si vous modifiez une propriété sur un objet en utilisant reference2, cela affectera les mêmes données pointées par reference1.
(inside method) reference2.Add("SomeString");
(outside method) reference1[0] == "SomeString" //this is true
Si vous annulez reference2 ou le pointez vers de nouvelles données, cela n'affectera pas reference1 ni les données reference1 pointées.
(inside method) reference2 = new List<string>();
(outside method) reference1 != null; reference1[0] == "SomeString" //this is true
The references are now pointing like this:
reference2 => new List<string>()
reference1 => someobject
Maintenant, que se passe-t-il lorsque vous envoyez un objet par référence à une méthode? La référence réelle à someobject est envoyée à la méthode. Vous n'avez donc plus qu'une seule référence aux données:
(outside method) reference1 => someobject;
(inside method) reference1 => someobject;
mais qu'est ce que ça veut dire? Cela revient exactement à envoyer un objet non par référence, sauf pour deux choses principales:
1) Lorsque vous annulez la référence à l'intérieur de la méthode, celle-ci sera annulée à l'extérieur de la méthode.
(inside method) reference1 = null;
(outside method) reference1 == null; //true
2) Vous pouvez maintenant pointer la référence vers un emplacement de données complètement différent et la référence en dehors de la fonction pointera maintenant vers le nouvel emplacement de données.
(inside method) reference1 = new List<string>();
(outside method) reference1.Count == 0; //this is true
MyClass
unclass
type, c'est-à-dire un type de référence. Dans ce cas, l'objet que vous passez peut être modifié par lemyFunction
même sans motref
-out
clé / .myFunction
recevra une nouvelle référence qui pointe vers le même objet, et il peut modifier ce même objet autant qu'il le souhaite. La différence queref
ferait le mot - clé serait qu'il recevraitmyFunction
la même référence au même objet. Cela ne serait important que si l'myFunction
on changeait la référence pour pointer vers un autre objet.