Modification d'un paramètre réel en C#

Question

En C++, j'ai une fonction:

void MyFunction(int p) 
{ 
    p=5; 
} 

Supposons, je:

int x = 10; 
MyFunction(x); // x = 10 
MyFunction(&x); // x = 5 

Comment archieve cela en C# avec la condition: je crée un seul MyFunction .

Answer 1

Votre fonction C++ ne fonctionne pas comme vous le pensez. En fait, votre code ne compilera pas.

En C#, vous pouvez utiliser les ref ou out mots-clés:

void MyFunction1(out int p) 
{ 
    p = 5; 
} 

void MyFunction2(ref int p) 
{ 
    p = p + 1; 
} 

int x; 
MyFunction1(out x); // x == 5 
MyFunction2(ref x); // x == 6 

Answer 2

C# ne pas la fonctionnalité équivalente. Si vous déclarez la méthode pour avoir un paramètre ref, vous devez également spécifier que le paramètre est de type ref lorsque vous appelez la méthode.

Answer 3

En C# vous devez déclarer la méthode avec un paramètre ref, comme ceci:

void MyFunction(ref int p) 
{ 
    p=5; 
} 

Si vous appelez alors comme MyFunction(ref x) la valeur de x dans l'appelant sera modifié. Si vous ne voulez pas qu'il soit modifié, il suffit de le copier dans une variable fictive. Vous pouvez créer une surcharge de MyFunction qui fait cela en interne:

void MyFunction(int p) 
{ 
    MyFunction(ref p); 
} 

Il serait techniquement pas « une fonction », comme vous voulez, mais le code ne serait pas dupliqué et à toute lecture humaine de votre code, il serait apparaître comme un - mais pour le compilateur c'est deux. Vous les appeler comme ceci:

int x = 10; 
MyFunction(x); // x = 10 
MyFunction(ref x); // x = 5 

Answer 4

Vous devez passer le paramètre comme référence. Si vous ne le spécifiez pas, il crée automatiquement une copie pour travailler dans le paramètre au lieu d'utiliser la même référence.

Comment faire? Il suffit de spécifier avec le mot « ref » dans la déclaration de la méthode:

void MyFunction(ref int p) 
{ 
    p=5; 
} 

int x = 10; 
MyFunction(ref x); // x = 5 

Answer 5

Le point est que beaucoup de gens pensent que les types de référence sont passés par référence et les types valeur sont passés par valeur. C'est le cas du point de vue de l'utilisateur, en interne, les types Reference et Value sont transmis uniquement par Value. Lorsqu'un type de référence est passé en paramètre, sa valeur, qui est une référence à l'objet réel, est transmise. Dans le cas des types de valeur, leur valeur est la valeur elle-même (par exemple 5).

StringBuilder sb = new StringBuilder(); 
SetNull(sb); 
SetNull(ref sb); 

si SetNull (...) définit le paramètre à NULL, alors le second appel sera fixé le passé en paramètre StringBuilder à null.