Le code modifie la mauvaise variable ... pourquoi?

J'ai une chose étrange où un code que je suis en train de modifier à la fois la copie et la liste d'origine. J'ai réduit le problème autant que possible pour ne montrer l'erreur que dans un seul fichier. Bien que mon exemple du monde réel nous soit beaucoup plus complexe ... mais à la racine de tout cela, c'est le problème.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestingRandomShit
{
    class Program
    {
        private static string rawInput;
        private static List<string> rawList;
        private static List<string> modifiedList;

        static void Main(string[] args)
        {
            rawInput = "this is a listing of cats";

            rawList = new List<string>();
            rawList.Add("this");
            rawList.Add("is");
            rawList.Add("a");
            rawList.Add("listing");
            rawList.Add("of");
            rawList.Add("cats");

            PrintAll();

            modifiedList = ModIt(rawList);

            Console.WriteLine("\n\n**** Mod List Code has been run **** \n\n");
            PrintAll();
        }

        public static List<string> ModIt(List<string> wordlist)
        {

            List<string> huh = new List<string>();
            huh = wordlist;

            for (int i = 0; i < huh.Count; i++)
            {
                huh[i] = "wtf?";
            }
            return huh;
        }

//****************************************************************************************************************
//Below is just a print function.. all the action is above this line


        public static void PrintAll()
        {
            Console.WriteLine(": Raw Input :");
            Console.WriteLine(rawInput);

            if (rawList != null)
            {
                Console.WriteLine("\n: Original List :");
                foreach (string line in rawList)
                {
                    Console.WriteLine(line);
                }
            }

            if (modifiedList != null)
            {
                Console.WriteLine("\n: Modified List :");
                foreach (string wtf in modifiedList)
                {
                    Console.WriteLine(wtf);
                }
                Console.ReadKey();
            }
        }
    }
}

En gros, j'ai trois variables .... une chaîne et deux List . Le code original dose un peu de tokenisation sur la chaîne, mais pour cette démo, j'utilise simplement List.Add () pour le simuler afin de le rendre simple à lire.

J'ai donc maintenant une chaîne et une liste avec un seul mot dans chaque élément.

C'est la partie déroutante que je ne comprends pas .. Je sais qu'elle a quelque chose à faire avec des références mais je ne peux pas savoir comment l'adapter.

Il y a une méthode que j'ai appelée ModIt () ... il prend simplement dans une liste puis crée une liste complètement nouvelle appelée huh, copie la liste originale sur la nouvelle liste puis change chaque ligne en hein à "wtf?".

Maintenant si je comprends bien .. Je devrais me retrouver avec 3 variables ...

1) une chaîne 2) une liste avec un mot différent dans chaque élément 3) une liste de la même longueur que l'autre avec chaque élément étant "wtf?"

Mais, que se passe-t-il, c'est que j'essaye d'imprimer les deux listes qu'ils ont tous les deux mis à "WTF?" ".... alors ouais ... wtf mec? Je suis super confus. Je veux dire dans le ModIt, je construis même une toute nouvelle chaîne plutôt que de modifier celle qui est transmise, mais cela ne semble pas affecter quoi que ce soit.

Ceci est la sortie ...

: Raw Input: ceci est une liste de chats

: Liste d'origine: ceci est une liste de chats

**** Le code de la liste des mods a été exécuté ****

: Raw Input: ceci est une liste de chats

: Liste d'origine: wtf? wtf? wtf? wtf? wtf? wtf?

: Liste modifiée: wtf? wtf? wtf? wtf? wtf? wtf?