Liste in c #

Je pense que vous avez une hypothèse défectueuse dans votre première balle. L'objet de liste générique est définitivement un type de référence (sur le tas, pas la pile). Je ne sais pas pourquoi vous pensez que vous devez passer via ref code>. Ceci imprime "2" comme il devrait:

namespace ConsoleApplication1 {
   class Program {
      static void Main(string[] args) {
         List<int> listIsARefType = new List<int>();
         ModifyIt(listIsARefType);
         ModifyIt(listIsARefType);
         Console.WriteLine(listIsARefType.Count); // 2!
         Console.ReadKey(true);
      }

      static void ModifyIt(List<int> l) {
         l.Add(0);
      }
   }
}

Vous devez comprendre la différence entre passer par référence em>, passer par valeur em> et transmettez-la par valeur em>.

dans le Code Sample Vous avez publié, vous passez la em> référence em> à la liste code> objet par valeur em>. Cela signifie que vous pouvez muter l'objet indiqué par la référence, et le code d'appel verra ces modifications. Cependant, la référence elle-même est transmise par valeur, de sorte que si vous modifiez la référence à un objet différent à un objet différent, le code d'appel ne verra pas les modifications. P>

Lorsque vous utilisez le ref Code> Mot clé, vous passez la référence elle-même par référence. Cela signifie que non seulement vous pouvez modifier l'objet que la référence indique, mais vous pouvez également modifier la référence elle-même. P>

considère cet exemple: p>

class Program
{
    static void Main()
    {
        int foo = 0;
        DoSomething1(foo);
        Console.WriteLine(foo); // Outputs 0.

        DoSomething1(ref foo);
        Console.WriteLine(foo); // Outputs 1.

        var bar = new List<int>();
        DoSomething2(bar);
        Console.WriteLine(bar.Count); // Outputs 1.

        DoSomething2(ref bar);
        Console.WriteLine(bar.Count); // Outputs 0.
    }

    // Pass by value.
    static void DoSomething1(int number)
    {
        // Can't modify the number!
        number++;
    }

    // Pass by value.
    static void DoSomething1(ref int number)
    {
        // Can modify the number!
        number++;
    }

    // Pass reference by value.
    static void DoSomething2(List<int> list)
    {
        // Can't change the reference, but can mutate the object.
        list.Add(25);
    }

    // Pass reference by reference.
    static void DoSomething2(ref List<int> list)
    {
        // Can change the reference (and mutate the object).
        list = new List<int>();
    }
}

En plus des hypothèses erronées traitées dans d'autres réponses, vous dites:

Liste doit être initialisé par un nouvel opérateur ... cela implique un Comportement de type de référence.

Non, en C # L'opérateur Nouveau n'est que la syntaxe pour appeler le constructeur d'un type. Il est utilisé pour les types de valeur de référence et définis par l'utilisateur ( struct s).