C# 重复列表<；T>；。添加（T项）项

为什么

aFooList

包含最后一项的五份副本，而不是我插入的五份副本

预期输出：

01234

实际输出：

44444

using System;
using System.Collections.Generic;

namespace myTestConsole {
    public class foo {
        public int bar;
    }

    class Program {
        static void Main(string[] args) {
            foo aFoo = new foo(); // Make a foo
            List<foo> aFooList = new List<foo>(); // Make a foo list

            for (int i = 0; i<5; i++) { 
                aFoo.bar = i;
                aFooList.Add(aFoo);
            }

            for (int i = 0; i<5; i++) {
                Console.Write(aFooList[i].bar);
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
名称空间myTestConsole{
公开课foo{
公共酒吧；
}
班级计划{
静态void Main（字符串[]参数）{
foo aFoo=new foo（）；//制作一个foo
List aFooList=new List（）；//制作一个foo列表
for（int i=0；i
List aFooList=new List（）；//制作一个foo列表
for（int i=0；i
List aFooList=new List（）；//制作一个foo列表
对于（int i=0；i您添加了相同的项，
aFoo
，5次。当您修改引用类型对象的内容时，您不创建新副本，您修改了相同的对象。
您添加了相同的项，
aFoo
，5次。当您修改引用类型对象的内容时，您不创建新副本，您修改了相同的对象。
aFoo
对象。
您的变量“aFoo”基本上是指向内存中某个位置的指针。如果不“更新”另一个实例（malloc），您将修改内存中的同一位置并添加同一指针5次

“new”关键字填充了C#中程序员所关心的函数，就像malloc在C中所做的那样。它将获得一个新的内存位置，并使aFoo指向该位置，而不是旧的位置

从MSDN：

The new operator is used to create objects and invoke constructors

您的变量“aFoo”基本上是指向内存中某个位置的指针。如果不“更新”另一个实例（malloc），您将修改内存中的同一位置并添加同一指针5次

“new”关键字填充了C#中程序员所关心的函数，就像malloc在C中所做的那样。它将获得一个新的内存位置，并使aFoo指向该位置，而不是旧的位置

从MSDN：

The new operator is used to create objects and invoke constructors

您已将对同一对象的引用添加到列表中5次，每次都修改
栏的值。
将这一行添加到
aFooList.Add（aFoo）；
之后，以查看每次向列表中添加
foo
时的效果

Console.WriteLine(string.Join("", foos.Select(f => f.bar)));

值得一提的是，它是一个带有Linq的单行程序（间距很小，便于阅读）

var foos = Enumerable.Range(0, 5)
                     .Select(n => new foo {bar = n})
                     .ToList();


完整示例：

foo aFoo = new foo(); // Make a foo
List<foo> aFooList = new List<foo>(); // Make a foo list
Console.WriteLine("\nUsing aFooList");
for (int i = 0; i < 5; i++)
{
    aFoo.bar = i;
    aFooList.Add(aFoo);
    Console.WriteLine(string.Join("", aFooList.Select(f => f.bar)));
}

var foos = Enumerable.Range(0, 5).Select(n => new foo { bar = n }).ToList();
Console.WriteLine("\nUsing foos");
Console.WriteLine(string.Join("", foos.Select(f => f.bar)));

Console.ReadLine();

foo-aFoo=new-foo（）；//制作一个foo
List aFooList=new List（）；//制作一个foo列表
Console.WriteLine（“\n使用Afolist”）；
对于（int i=0；i<5；i++）
{
aFoo.bar=i；
aFooList.Add（aFoo）；
Console.WriteLine（string.Join（“，aFooList.Select（f=>f.bar））；
}
var foos=Enumerable.Range（0，5）.Select（n=>newfoo{bar=n}）.ToList（）；
Console.WriteLine（“\n使用foos”）；
Console.WriteLine（string.Join（“，foos.Select（f=>f.bar））；
Console.ReadLine（）；

输出：

Using aFooList
0
11
222
3333
44444

Using foos
01234
使用无政府主义者
0
11
222
3333
44444
使用foos
01234
您已经向列表中添加了对同一对象的引用5次，每次都修改
bar
的值。请在
aFooList.Add（aFoo）；
之后添加此行，以查看每次向列表中添加
foo
时的效果

Console.WriteLine(string.Join("", foos.Select(f => f.bar)));

值得一提的是，它是一个带有Linq的单行程序（间距很小，便于阅读）

var foos = Enumerable.Range(0, 5)
                     .Select(n => new foo {bar = n})
                     .ToList();


完整示例：

foo aFoo = new foo(); // Make a foo
List<foo> aFooList = new List<foo>(); // Make a foo list
Console.WriteLine("\nUsing aFooList");
for (int i = 0; i < 5; i++)
{
    aFoo.bar = i;
    aFooList.Add(aFoo);
    Console.WriteLine(string.Join("", aFooList.Select(f => f.bar)));
}

var foos = Enumerable.Range(0, 5).Select(n => new foo { bar = n }).ToList();
Console.WriteLine("\nUsing foos");
Console.WriteLine(string.Join("", foos.Select(f => f.bar)));

Console.ReadLine();

foo-aFoo=new-foo（）；//制作一个foo
List aFooList=new List（）；//制作一个foo列表
Console.WriteLine（“\n使用Afolist”）；
对于（int i=0；i<5；i++）
{
aFoo.bar=i；
aFooList.Add（aFoo）；
Console.WriteLine（string.Join（“，aFooList.Select（f=>f.bar））；
}
var foos=Enumerable.Range（0，5）.Select（n=>newfoo{bar=n}）.ToList（）；
Console.WriteLine（“\n使用foos”）；
Console.WriteLine（string.Join（“，foos.Select（f=>f.bar））；
Console.ReadLine（）；

输出：

Using aFooList
0
11
222
3333
44444

Using foos
01234
使用无政府主义者
0
11
222
3333
44444
使用foos
01234
您只创建一个foo对象一次，并将其添加到列表中5次您只创建一个foo对象一次，并将其添加到列表中5次