如何在修改副本時保持通用列表不被修改？

Question

當我在lstCopy中創建原始列表lstStudent的副本並將lstCopy發送到修改函數時，lstStudent也會被修改。我想保持這個列表不被修改。

List<Student> lstStudent = new List<Student>(); 
Student s = new Student(); 
s.Name = "Akash"; 
s.ID = "1"; 
lstStudent.Add(s); 
List<Student> lstCopy = new List<Student>(lstStudent); 
Logic.ModifyList(lstCopy); 
// "Want to use lstStudent(original list) for rest part of the code" 

public static void ModifyList(List<Student> lstIntegers) { 
    foreach (Student s in lstIntegers) { 
     if (s.ID.Equals("1")) { 
      s.ID = "4"; s.Name = "APS"; 
     } 
    } 
} 

Answer 1

如果您Student類型是類（引用類型），列表中只包含那些實例的引用。這意味着，當您複製清單時，複製的清單也將只有引用仍然指向相同的Student實例。通過複製你的列表，你可以簡單地複製你的引用，但不是實例。你有副本後什麼是這樣的：

List 1   List 2      instance S1 
ref to S1   ref to S1     Name: Akash 
ref to S2   ref to S2     ... 
...    ... 

所以，如果你這樣做list1[0].Name = "Jim"，你會更新實例S1，你會看到兩個列表中的改變，因爲兩個列表請參考同一組實例。

你需要做的就是在這種情況下，不僅產生了列表的克隆，但所有的對象內列表 - 你需要複製所有Student對象爲好。這被稱爲深層複製。事情是這樣的：

class StudentList : List<Student>, ICloneable 
{ 
    public object Clone() 
    { 
     StudentList oNewList = new StudentList(); 

     for (int i = 0; i < Count; i++) 
     { 
      oNewList.Add (this[i].Clone() as Student); 
     } 

     return (oNewList); 
    } 
} 

你叫這像這樣：

StudentList oClonedList = lstStudent.Clone() as StudentList; 

你也需要讓你的Student類可被複制通過實現ICloneable接口。不過請記住，在此之後，您將有2個獨立的列表和2個獨立的Student對象 - 修改一個Student實例將不會影響您的其他列表中的學生。

Answer 2

我會看看ICloneable。你所追求的是「深層複製」。良好的信息很多在這個帖子：

How do I clone a generic list in C#?

Answer 3

您還可以通過使用二進制格式實現這一點沒有可複製的接口： 注意：所有類作爲對象圖的一部分，必須標記爲Serializable。

void Main() 
{ 
    var student1=new Student{Name="Bob"}; 
    var student2=new Student{Name="Jim"}; 

    var lstStudent=new List<Student>(); 
    lstStudent.Add(student1); 
    lstStudent.Add(student2); 

    var lstCopy=new List<Student>(lstStudent); 
    var clone=Clone(lstStudent); 

    student1.Name="JOE"; 

    lstCopy.Dump(); 
    lstStudent.Dump(); 
    clone.Dump(); 

} 

public List<Student> Clone(List<Student> source) 
{ 

    BinaryFormatter bf=new BinaryFormatter(); 
    using(var ms=new MemoryStream()) 
    { 
    bf.Serialize(ms,source); 
    ms.Seek(0,0); 
    return (List<Student>)bf.Deserialize(ms); 
    } 
} 

[Serializable] 
public class Student 
{ 
    public string Name { get; set; } 
} 

OUTPUT：

5List<Student> (2 items) 4 
Name 
JOE 
Jim 

5List<Student> (2 items) 4 
Name 
JOE 
Jim 

5List<Student> (2 items) 4 
Name 
Bob 
Jim 

代碼格式化傾倒入LINQPad

編輯： 這是在這是不可能實現ICloneable情況的選項。適用時，編碼到接口。換句話說，您可以在學生對象上實現ICloneable，並使用Clone()方法中的BinaryFormatter邏輯;但是，作爲開發人員，您可以選擇自行決定要執行的操作。選項不一定是建議，建議也不總是一種選擇。有時你必須完成一項任務才能完成任務，而這正是選擇起作用的地方。

這是一個非常廣泛接受，深克隆方法： How do you do a deep copy of an object in .NET (C# specifically)?

Answer 4

又一個快速的方法使用LINQ

List<student> oldList = new List<student> { new student{ 
              id=122, 
              name="John"} }; 

IEnumerable<student> copy= oldList.Select(item => new student{ 
              id = item.id, 
              name = item.name }); 

List<student> newList= new List<student>(copy); 

複製您的列表，但最好的辦法還是可以實現ICloneable深複製你的對象

Answer 5

你想要一個列表的深層副本。現在，它是一個淺拷貝。你只有兩個引用到同一個變量。沒有簡單的方法可以像使用C++這樣的語言在C＃中獲得深層副本。獲得深層副本的一種方法是對第一個列表進行序列化和反序列化。以下是獲取對象的深層副本的模板化函數。

public static T getDeepCopy<T>(T objectToCopy) 
{ 
    T temp; 
    using (MemoryStream ms = new MemoryStream()) 
    { 
     BinaryFormatter formatter = new BinaryFormatter(); 
     formatter.Serialize(ms, objectToCopy); 
     ms.Position = 0; 
     temp = (T)formatter.Deserialize(ms); 
    } 
    return temp; 
} 

您將需要包括這些命名空間以及：

using System.IO; 
using System.Runtime.Serialization; 
using System.Runtime.Serialization.Formatters.Binary; 

然後，您可以調用該函數是這樣的：

lstCopy = getDeepCopy<List<Student>>(lstStudents);