à l'aide de ref avec classe C#

Pour ce que vous faites, vous n'avez pas besoin d'utiliser la ref. Si vous avez fait passer la liste à l'aide de ref, vous seriez en permettant à l'appelant pour modifier la liste, vous faites référence, plutôt que de simplement en changeant le contenu de la liste.

OriginalL'auteur Jon B

Le seul moment où vous devez utiliser la ref avec un type de référence est si vous avez l'intention de créer un nouvel objet à l'intérieur d'une fonction.

Exemple #1: ref mot-clé n'est pas nécessaire.

//...
   List myList = new List();
   PopulateList(myList);
//...
void PopulateList(List AList)
{
   AList.Add("Hello");
   AList.Add("World");
}

Exemple #2: ref mot-clé nécessaire.

//...
   List myList;
   PopulateList(ref myList);
//...
void PopulateList(ref List AList)
{
   AList = new List();
   AList.Add("Hello");
   AList.Add("World");
}

OriginalL'auteur Spencer Ruport

Je suis l'ajout de cette réponse pour les programmeurs qui sont utilisés pour le C++, comme moi.

Des Classes, des interfaces, delegatess et les tableaux sont reference types, ce qui signifie qu'ils ont sous-jacente d'un pointeur. Normal appels de la fonction de copie de ce pointeur(de référence), en valeur, tout en envoyant par référence envoie envoie une référence à cette référence:

//C# code:
void Foo(ClassA     input)
void Bar(ClassA ref input)

//equivalent C++ code:
void Foo(ClassA*  input)
void Bar(ClassA*& input)

Primitives telles que int, double, etc les structures et les chaînes de caractères(string sont une exception, mais fonctionne de manière similaire), sont allouées sur le tas, de sorte que les choses fonctionnent un peu différent:

//C# code:
void Foo(StructA     input)
void Bar(StructA ref input)

//equivalent C++ code:
void Foo(StructA  input)
void Bar(StructA& input)

la ref mot-clé doit être utilisé à la fois dans la déclaration de la méthode et lors de l'appel, de sorte qu'il serait clair qu'il est référencé:

//C# code:
void Foobar(ClassB ref input)
...
ClassB instance = new ClassB();
Foobar(ref instance);

//equivalent C++ code:
void Foobar(ClassB*& input)
...
ClassB instance* = new ClassB();
Foobar(instance);

Comme l'a dit avant, veuillez lire cette explication détaillée. Il explique également à propos des chaînes.

Il est intéressant de noter que l'appel par les ouvrages de référence d'un pointeur, donc nous arrivons à ce code:

//C# code:
void Foo(ClassA input){
    input = input + 3;
}
void Bar(ClassA ref input){
    input = input + 3;
}
//equivalent C++ code:
void Foo(ClassA&  input){
    input = input + 3;
}
void Bar(ClassA*&  input){
    *input = *input + 3;
}
//equivalent pure C code:
void Fun(ClassA* input){
    *input = *input + 3;
}
void Fun(ClassA** input){
    *(*input) = *(*input) + 3;
}

c'est un équivalent, mais c'est un peu vrai.

OriginalL'auteur Nefzen

Je sais que c'est une vieille question, mais aucune des réponses donner une bonne raison à mon avis.

Vous n'avez pas besoin d'utiliser ref dans ce cas, et voici pourquoi. Prenons cette fonction:

void Foo(MyClass a1, ref MyClass a2, out MyClass b1, int c1, MyStruct d1, ref MyStruct d2)
{
}

Maintenant appeler cette fonction en tant que

MyClass  a = new MyClass();
MyClass  b = null
int      c = 3;
MyStruct d = new MyStruct();

Foo(a, ref a, b, c, d, ref d);

Voici ce que vous obtenez à l'intérieur de la fonction:

void Foo(MyClass a1, ref MyClass a2, 
         out MyClass b1, 
         int c1, 
         MyStruct d1, ref MyStruct d2)
{
   a1 is a copy in memory of the pointer to the instantiated class a;
   a2 is the pointer to the instantiated class a;

   b1 is the pointer to b, but has the additional check of having to be set within this function - and cannot be used before being set;

   c1 is a copy in memory of the variable c;

   d1 is a copy in memory of the struct d;
   d2 is the struct d;
}

Choses importantes à réaliser:

1. réglage a1 à null sera pas ensemble a à null.
2. réglage a2 à null sera mis a à null.
3. réglage b1 est nécessaire.
4. réglage c1 sera pas changement c.
5. réglage d1 sera pas changement d.
6. réglage d2 va changer d.

Cela permet de "bizarre" comme ceci:

void Foo(MyClass x, ref MyClass y)
{
    x = null;
    y.Bar("hi");
}

Appelé comme:

MyClass a = new MyClass();
Foo(a, ref a);

Vous utilisez une classe, et donc votre situation est plus variable a1 dans l'appel de fonction. Ce qui signifie ref n'est pas strictement nécessaire.

Jon Skeet article ne vous aidera pas beaucoup, parce que son exemple avec IntHolder est un struct pas un class. Struct est le type de valeur comme int et doivent être traitées de la même manière.

OriginalL'auteur bueller