C# Foreach更改所有列表

在列表集合上使用foreach时，集合中的迭代对象会发生明显的变化。我希望保留一个集合“副本”供以后使用，但此“副本”似乎随原始列表集合一起更改

当我在原始列表集合中循环时，如何防止我的“副本”集合被更改

这就是我迄今为止所尝试的：

private List<T> _listCopy;
public Constructor(List<T> inputList)
{
    _listCopy = new List<T>(inputList);

    foreach(var obj in inputList) {
    // This changes both inputList and _listCopy.
    // How can i keep _listCopy, from being edited as well?
    }
}

private List\u listCopy；
公共构造函数（列表输入列表）
{
_listCopy=新列表（inputList）；
foreach（输入列表中的var obj）{
//这会同时更改inputList和_listCopy。
//我如何防止_listCopy也被编辑？
}
}

这是因为列表中的对象最有可能是引用类型（类）。它与列表无关，它与C#中引用类型的行为方式有关。如果要复制对象，应创建新对象并复制相应的状态。如果您自己编写这个类，最好的方法就是创建一个复制构造函数

class SomeType
{
    public string SomeState { get; set; }
    public SomeType()
    {
    }

    public SomeType(SomeType original)
    {
        this.SomeState = original.SomeState;
    }

}

然后，您可以通过各种方式复制列表。例如，使用LINQ

List<SomeType> copyList = originalList.Select(o => new SomeType(o)).ToList();

---

如果您不控制类型，也无法编写复制构造函数，则只需创建一个新对象并复制属性（假设您可以这样做，有时您不能这样做）。

这是因为列表中的对象很可能是引用类型（类）。它与列表无关，它与C#中引用类型的行为方式有关。如果要复制对象，应创建新对象并复制相应的状态。如果您自己编写这个类，最好的方法就是创建一个复制构造函数

class SomeType
{
    public string SomeState { get; set; }
    public SomeType()
    {
    }

    public SomeType(SomeType original)
    {
        this.SomeState = original.SomeState;
    }

}

然后，您可以通过各种方式复制列表。例如，使用LINQ

List<SomeType> copyList = originalList.Select(o => new SomeType(o)).ToList();

---

如果您不控制类型，也无法编写复制构造函数，则只需创建一个新对象并复制属性（假设您可以这样做，有时您不能这样做）。

这是因为列表中的对象很可能是引用类型（类）。它与列表无关，它与C#中引用类型的行为方式有关。如果要复制对象，应创建新对象并复制相应的状态。如果您自己编写这个类，最好的方法就是创建一个复制构造函数

class SomeType
{
    public string SomeState { get; set; }
    public SomeType()
    {
    }

    public SomeType(SomeType original)
    {
        this.SomeState = original.SomeState;
    }

}

然后，您可以通过各种方式复制列表。例如，使用LINQ

List<SomeType> copyList = originalList.Select(o => new SomeType(o)).ToList();

---

如果您不控制类型，也无法编写复制构造函数，则只需创建一个新对象并复制属性（假设您可以这样做，有时您不能这样做）。

这是因为列表中的对象很可能是引用类型（类）。它与列表无关，它与C#中引用类型的行为方式有关。如果要复制对象，应创建新对象并复制相应的状态。如果您自己编写这个类，最好的方法就是创建一个复制构造函数

class SomeType
{
    public string SomeState { get; set; }
    public SomeType()
    {
    }

    public SomeType(SomeType original)
    {
        this.SomeState = original.SomeState;
    }

}

然后，您可以通过各种方式复制列表。例如，使用LINQ

List<SomeType> copyList = originalList.Select(o => new SomeType(o)).ToList();

---

如果您不控制类型并且无法编写复制构造函数，则可以创建一个新对象并复制属性（假设您可以这样做，有时您不能这样做）。

如果您的类型t是引用类型，则数组副本是列表结构的副本，而不是列表项的副本！复制的列表仍然包含对原始项目的引用！如果要更改列表中的对象并保持原始对象不变，还必须克隆对象

可以使用以下接口定义将克隆方法添加到类中，如下所示：

public interface IShallowClonable<T>
{
    T ShallowClone();
}

public MyClass : IShallowClonable<MyClass>
{
    //TODO: define class members.

    public T ShallowClone()
    {
        return (T)MemberwiseClone(this);
    }
}

公共接口允许克隆
{
T浅克隆（）；
}
公共MyClass:IsAllowClonable
{
//TODO:定义类成员。
公共浅水区（）
{
返回（T）MemberwiseClone（此）；
}
}

像这样使用它

class Test<T> where T : IShallowClonable<T>
{
    private List<T> _listCopy;
    public Constructor(List<T> inputList)
    {
        _listCopy = new List<T>(inputList.Count);
        foreach(T obj in inputList) {
            _listCopy.Add(obj.ShallowClone());
        }
    }

    private void MakeChangesInListCopy()
    {
        foreach(T obj in _listCopy) {
            obj.ApplyChange((); // You'll need T to implement another interface or
                                // to inherit from another class for this to work.
        }
    }
}

类测试，其中T:IShallowClonable
{
私人清单(清单副本);；
公共构造函数（列表输入列表）
{
_listCopy=新列表（inputList.Count）；
foreach（输入列表中的目标）{
_Add（obj.ShallowClone（））；
}
}
私有void MakeChangesInListCopy（）
{
foreach（列表副本中的目标）{
obj.ApplyChange（（）；//实现另一个接口或
//从另一个类继承以使其工作。
}
}
}

如果类型T是引用类型，则数组副本是列表结构的副本，但不是列表项的副本！复制的列表仍然包含对原始项的引用！如果要更改列表中的对象并保持原始对象的完整性，则还必须克隆对象

可以使用以下接口定义将克隆方法添加到类中，如下所示：

public interface IShallowClonable<T>
{
    T ShallowClone();
}

public MyClass : IShallowClonable<MyClass>
{
    //TODO: define class members.

    public T ShallowClone()
    {
        return (T)MemberwiseClone(this);
    }
}

公共接口允许克隆
{
T浅克隆（）；
}
公共MyClass:IsAllowClonable
{
//TODO:定义类成员。
公共浅水区（）
{
返回（T）MemberwiseClone（此）；
}
}

像这样使用它

class Test<T> where T : IShallowClonable<T>
{
    private List<T> _listCopy;
    public Constructor(List<T> inputList)
    {
        _listCopy = new List<T>(inputList.Count);
        foreach(T obj in inputList) {
            _listCopy.Add(obj.ShallowClone());
        }
    }

    private void MakeChangesInListCopy()
    {
        foreach(T obj in _listCopy) {
            obj.ApplyChange((); // You'll need T to implement another interface or
                                // to inherit from another class for this to work.
        }
    }
}

类测试，其中T:IShallowClonable
{
私人清单(清单副本);；
公共构造函数（列表输入列表）
{
_listCopy=新列表（inputList.Count）；
foreach（输入列表中的目标）{
_Add（obj.ShallowClone（））；
}
}
私有void MakeChangesInListCopy（）
{
foreach（列表副本中的目标）{
obj.ApplyChange（（）；//实现另一个接口或
//从另一个类继承以使其工作。
}
}
}

如果类型T是引用类型，则数组副本是列表结构的副本，但不是列表项的副本！复制的列表仍然包含对原始项的引用！如果要更改列表中的对象并保持原始对象的完整性，则还必须克隆对象

可以使用以下接口定义将克隆方法添加到类中，如下所示：

public interface IShallowClonable<T>
{
    T ShallowClone();
}

public MyClass : IShallowClonable<MyClass>
{
    //TODO: define class members.

    public T ShallowClone()
    {
        return (T)MemberwiseClone(this);
    }
}

公共接口I