C# 丢失嵌套列表中的值

Question

我的 int 嵌套列表(List<List<int>>)遇到了一个非常奇怪的问题。在我放入超过 100 万个列表后的某个时刻，它们都失去了它们的值，即它们中有 0 个元素..真的很奇怪，对吗？我怀疑我在里面放了太多的 list 。不过，我添加了一个 if 语句来检查嵌套列表长度是否正好为 100 万，并在其中添加了一个断点。最终，超出嵌套列表能力并非如此，这完全让我的头脑困惑。我将在这里发布代码，以便我可以尝试解释

        //it will iterate 8^8 times - 16.7 million times
        private static List<List<int>> minMinatRed = new List<List<int>>();
        private static List<List<int>> minMinataKolona = new List<List<int>>();
        var tempHodove = new List<Tuple<bool, int[]>>();
        int novMinatRed = red;
        int novaMinataKolona = kolona;
        for (int i = 0; i < numberOfVariations; i++)
        {
            tempHodove.Clear();
            var hodove = UpdateList(novMinatRed, novaMinataKolona);
            int x = i;
            for (int j = 0; j < size; ++j)
            {
                result[j] = tempArr[x % size];
                x /= size;
            }
            for (int k = result.Length - 1; k >= 0; k--)
            {
                tempHodove.Add(hodove[result[k]]);
            }
            bool trueValue = tempHodove.Any(c => c.Item1);
            while (trueValue)
            {
                foreach (var hod in tempHodove.Where(hod => hod.Item1))
                {
                    novMinatRed += hod.Item2[0];
                    novaMinataKolona += hod.Item2[1];
                    minatRed.Add(novMinatRed);
                    minataKolona.Add(novaMinataKolona);
                    count++;
                    break;
                }
                if (novMinatRed == kraenRed && novaMinataKolona == krainaKolona)
                {
                    if (minCount > count)
                    {
                        minCount = count;
                    }
                    minMinatRed.Add(minatRed);
                    minMinataKolona.Add(minataKolona);
                }
                hodove = UpdateList(novMinatRed, novaMinataKolona);
                tempHodove.Clear();
                for (int k = result.Length - 1; k >= 0; k--)
                {
                    tempHodove.Add(hodove[result[k]]);
                }
                trueValue = tempHodove.Any(c => c.Item1);
            }
            if (minMinatRed.Count == 1000000)
            {

            }
            minataKolona.Clear();
            minatRed.Clear();
            count = 0;
            novMinatRed = nachalenRed;
            novaMinataKolona = nachalnaKolona;
        }

问题出在 minMinatRed 和 minMinataKolona 列表中，正如您所看到的，我只有在其中添加一些值的地方:

if (novMinatRed == kraenRed && novaMinataKolona == krainaKolona)
{
     if (minCount > count)
     {
          minCount = count;
     }
     minMinatRed.Add(minatRed); //here
     minMinataKolona.Add(minataKolona); //and here
}

一旦断点被​​触发:

if (minMinatRed.Count == 1000000){ }

我开始检查发生了什么。我发现一旦代码到达此点:

minataKolona.Clear();
minatRed.Clear();

它不仅删除 minatRed 值，还删除 minMinatRed 值，同样适用于 minataKolona 和 minMinataKolona ..此外，一旦它返回到循环并将一些值添加到 minatRed 和 minataKolona 中，它还会将相同的值添加到嵌套列表中，更具体地说:

foreach (var hod in tempHodove.Where(hod => hod.Item1))
{
     novMinatRed += hod.Item2[0];
     novaMinataKolona += hod.Item2[1];
     minatRed.Add(novMinatRed);  //here
     minataKolona.Add(novaMinataKolona);  //and here
     count++;
     break;
}

现在，由于我们之前删除了 minatRed 中的所有值，因此它显然不会包含任何内容，一旦我们向其中添加 1 个项目，它就会包含 1 个项目(笑).. 现在的问题是，它还添加了这个确切的值minMinatRed 嵌套列表中的每个列表中都有 1 个项目，即所有 100 万个列表的长度均为 1，并且其中只有 1 个重复变量。这就是我能够找到的关于我当前问题的信息，但是我不知道为什么会发生这种情况或如何解决它。我还阅读了 Mystical 撰写的一些问答，他也是 StackOverFlow 用户。在他们讨论分支预测的地方，我不确定这是否是我的情况，但可能是相关的。欢迎任何建议和解释。英语不是我的母语..

更新 1 忘记包含 minataKolona 和 minatRed && numberOfVariations 的初始化

    private static readonly List<int> minatRed = new List<int>();
    private static readonly List<int> minataKolona = new List<int>();
    private static readonly double numberOfVariations = Math.Pow(size, size);

更新 2 包含 UpdateList 方法

 private static List<Tuple<bool, int[]>> UpdateList(int red, int kolona)
    {
        var vsichkiHodove = new List<Tuple<bool, int[]>>()
        {
            new Tuple<bool, int[]>(Nadqsno(red, 1) && Napred(kolona, 2), new[]
            {
                +1,
                +2
            }),
            new Tuple<bool, int[]>(Nadqsno(red, 2) && Napred(kolona, 1), new[]
            {
                +2,
                +1
            }),
            new Tuple<bool, int[]>(Nalqvo(red, 1) && Napred(kolona, 2), new[]
            {
                -1,
                +2
            }),
            new Tuple<bool, int[]>(Nalqvo(red, 2) && Napred(kolona, 1), new[]
            {
                -2,
                +1
            }),
            new Tuple<bool, int[]>(Nadqsno(red, 2) && Nazad(kolona, 1), new[]
            {
                +2,
                -1
            }),
            new Tuple<bool, int[]>(Nalqvo(red, 2) && Nazad(kolona, 1), new[]
            {
                -2,
                -1
            }),
            new Tuple<bool, int[]>(Nadqsno(red, 1) && Nazad(kolona, 2), new[]
            {
                +1,
                -2
            }),
            new Tuple<bool, int[]>(Nalqvo(red, 1) && Nazad(kolona, 2), new[]
            {
                -1,
                -2
            }),
        };
        return vsichkiHodove;
    }

Answer 1

问题是List<T>是引用类型，因此，当您添加列表 minatRed 时和minataKolona至minMinatRed和minMinataKolona分别，您没有创建新的(克隆的)列表。

minMinatRed中的所有列表( minMinataKolona ) 指向同一个: minatRed ( minataKolona )，所以当您清除 minatRed 时(或 minataKolona )，minMinatRed 中的所有列表(或 minMinataKolona )也被清除，因为实际上是相同的列表。

您可以通过声明 minatRed 来解决此问题和minataKolona里面for循环:

for (int i = 0; i < numberOfVariations; i++)
{
    var minatRed = new List<int>();
    var minataKolona = new List<int>();
    ...

当然你不能清空列表:

//minataKolona.Clear();  Comment this lines or just remove it
//minatRed.Clear();      Comment this lines or just remove it