Làm cách nào để sao chép danh sách chung trong C #?

Tôi có một danh sách chung các đối tượng trong C # và muốn sao chép danh sách đó. Các mục trong danh sách có thể được sao chép, nhưng dường như không có tùy chọn nào để thực hiện list.Clone().

Có một cách dễ dàng xung quanh này?

Bạn có thể sử dụng một phương pháp mở rộng.

static class Extensions
{
    public static IList<T> Clone<T>(this IList<T> listToClone) where T: ICloneable
    {
        return listToClone.Select(item => (T)item.Clone()).ToList();
    }
}

Nếu các yếu tố của bạn là các loại giá trị, thì bạn có thể thực hiện:

List<YourType> newList = new List<YourType>(oldList);

Tuy nhiên, nếu chúng là các loại tham chiếu và bạn muốn có một bản sao sâu (giả sử các yếu tố của bạn thực hiện đúng ICloneable), bạn có thể làm một cái gì đó như thế này:

List<ICloneable> oldList = new List<ICloneable>();
List<ICloneable> newList = new List<ICloneable>(oldList.Count);

oldList.ForEach((item) =>
    {
        newList.Add((ICloneable)item.Clone());
    });

Rõ ràng, thay thế ICloneabletrong các tổng quát ở trên và sử dụng bất kỳ loại phần tử nào của bạn ICloneable.

Nếu loại phần tử của bạn không hỗ trợ ICloneablenhưng có trình tạo bản sao, bạn có thể thực hiện việc này thay thế:

List<YourType> oldList = new List<YourType>();
List<YourType> newList = new List<YourType>(oldList.Count);

oldList.ForEach((item)=>
    {
        newList.Add(new YourType(item));
    });

Cá nhân, tôi sẽ tránh ICloneablevì cần phải đảm bảo một bản sao sâu sắc của tất cả các thành viên. Thay vào đó, tôi đề nghị xây dựng bản sao hoặc một phương thức xuất xưởng như thế YourType.CopyFrom(YourType itemToCopy)trả về một thể hiện mới của YourType.

Bất kỳ tùy chọn nào trong số này có thể được gói bằng một phương thức (phần mở rộng hoặc cách khác).

Đối với một bản sao nông, thay vào đó, bạn có thể sử dụng phương thức GetRange của lớp Danh sách chung.

List<int> oldList = new List<int>( );
// Populate oldList...

List<int> newList = oldList.GetRange(0, oldList.Count);

Trích dẫn từ: Bí quyết Generics

public static object DeepClone(object obj) 
{
  object objResult = null;
  using (MemoryStream  ms = new MemoryStream())
  {
    BinaryFormatter  bf =   new BinaryFormatter();
    bf.Serialize(ms, obj);

    ms.Position = 0;
    objResult = bf.Deserialize(ms);
  }
  return objResult;
}

Đây là một cách để làm điều đó với C # và .NET 2.0. Đối tượng của bạn yêu cầu phải được [Serializable()]. Mục tiêu là để mất tất cả các tài liệu tham khảo và xây dựng những cái mới.

Để sao chép danh sách, chỉ cần gọi .ToList (). Điều này tạo ra một bản sao nông.

Microsoft (R) Roslyn C# Compiler version 2.3.2.62116
Loading context from 'CSharpInteractive.rsp'.
Type "#help" for more information.
> var x = new List<int>() { 3, 4 };
> var y = x.ToList();
> x.Add(5)
> x
List<int>(3) { 3, 4, 5 }
> y
List<int>(2) { 3, 4 }
> 

Sau khi sửa đổi một chút, bạn cũng có thể sao chép:

public static T DeepClone<T>(T obj)
{
    T objResult;
    using (MemoryStream ms = new MemoryStream())
    {
        BinaryFormatter bf = new BinaryFormatter();
        bf.Serialize(ms, obj);
        ms.Position = 0;
        objResult = (T)bf.Deserialize(ms);
    }
    return objResult;
}

Trừ khi bạn cần một bản sao thực sự của mọi đối tượng trong bạn List<T>, cách tốt nhất để sao chép danh sách là tạo một danh sách mới với danh sách cũ làm tham số bộ sưu tập.

List<T> myList = ...;
List<T> cloneOfMyList = new List<T>(myList);

Thay đổi myListnhư chèn hoặc xóa sẽ không ảnh hưởngcloneOfMyList và ngược lại.

Tuy nhiên, các đối tượng thực tế mà hai Danh sách chứa vẫn giống nhau.

Sử dụng AutoMapper (hoặc bất kỳ lib ánh xạ nào bạn thích) để sao chép là đơn giản và có thể duy trì rất nhiều.

Xác định ánh xạ của bạn:

Mapper.CreateMap<YourType, YourType>();

Làm phép thuật:

YourTypeList.ConvertAll(Mapper.Map<YourType, YourType>);

Nếu bạn chỉ quan tâm đến các loại giá trị ...

Và bạn biết loại:

List<int> newList = new List<int>(oldList);

Nếu bạn không biết loại trước đó, bạn sẽ cần một chức năng trợ giúp:

List<T> Clone<T>(IEnumerable<T> oldList)
{
    return newList = new List<T>(oldList);
}

Chỉ:

List<string> myNewList = Clone(myOldList);

Nếu bạn đã tham chiếu Newtonsoft.Json trong dự án của bạn và các đối tượng của bạn có thể tuần tự hóa, bạn luôn có thể sử dụng:

List<T> newList = JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(listToCopy))

Có thể không phải là cách hiệu quả nhất để làm điều đó, nhưng trừ khi bạn thực hiện nó 100 lần 1000 lần, bạn thậm chí có thể không nhận thấy sự khác biệt về tốc độ.

public static Object CloneType(Object objtype)
{
    Object lstfinal = new Object();

    using (MemoryStream memStream = new MemoryStream())
    {
        BinaryFormatter binaryFormatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.Clone));
        binaryFormatter.Serialize(memStream, objtype); memStream.Seek(0, SeekOrigin.Begin);
        lstfinal = binaryFormatter.Deserialize(memStream);
    }

    return lstfinal;
}

public class CloneableList<T> : List<T>, ICloneable where T : ICloneable
{
  public object Clone()
  {
    var clone = new List<T>();
    ForEach(item => clone.Add((T)item.Clone()));
    return clone;
  }
}

    public List<TEntity> Clone<TEntity>(List<TEntity> o1List) where TEntity : class , new()
    {
        List<TEntity> retList = new List<TEntity>();
        try
        {
            Type sourceType = typeof(TEntity);
            foreach(var o1 in o1List)
            {
                TEntity o2 = new TEntity();
                foreach (PropertyInfo propInfo in (sourceType.GetProperties()))
                {
                    var val = propInfo.GetValue(o1, null);
                    propInfo.SetValue(o2, val);
                }
                retList.Add(o2);
            }
            return retList;
        }
        catch
        {
            return retList;
        }
    }

Bạn tôi Gregor Martinovic và tôi đã đưa ra giải pháp dễ dàng này bằng cách sử dụng Trình tuần tự hóa JavaScript. Không cần gắn cờ các lớp là Nối tiếp và trong các thử nghiệm của chúng tôi bằng cách sử dụng Newtonsoft JsonSerializer thậm chí còn nhanh hơn so với sử dụng BinaryFormatter. Với các phương thức mở rộng có thể sử dụng trên mọi đối tượng.

Tùy chọn .NET JavascriptSerializer tiêu chuẩn:

public static T DeepCopy<T>(this T value)
{
    JavaScriptSerializer js = new JavaScriptSerializer();

    string json = js.Serialize(value);

    return js.Deserialize<T>(json);
}

Tùy chọn nhanh hơn bằng Newtonsoft JSON :

public static T DeepCopy<T>(this T value)
{
    string json = JsonConvert.SerializeObject(value);

    return JsonConvert.DeserializeObject<T>(json);
}

 //try this
 List<string> ListCopy= new List<string>(OldList);
 //or try
 List<T> ListCopy=OldList.ToList();

Tôi sẽ may mắn nếu có ai từng đọc điều này ... nhưng để không trả về danh sách các đối tượng loại trong các phương thức Clone của tôi, tôi đã tạo một giao diện:

public interface IMyCloneable<T>
{
    T Clone();
}

Sau đó, tôi chỉ định phần mở rộng:

public static List<T> Clone<T>(this List<T> listToClone) where T : IMyCloneable<T>
{
    return listToClone.Select(item => (T)item.Clone()).ToList();
}

Và đây là cách triển khai giao diện trong phần mềm đánh dấu A / V của tôi. Tôi muốn phương thức Clone () của mình trả về danh sách VidMark (trong khi giao diện IClonizable muốn phương thức của tôi trả về danh sách đối tượng):

public class VidMark : IMyCloneable<VidMark>
{
    public long Beg { get; set; }
    public long End { get; set; }
    public string Desc { get; set; }
    public int Rank { get; set; } = 0;

    public VidMark Clone()
    {
        return (VidMark)this.MemberwiseClone();
    }
}

Và cuối cùng, việc sử dụng phần mở rộng bên trong một lớp:

private List<VidMark> _VidMarks;
private List<VidMark> _UndoVidMarks;

//Other methods instantiate and fill the lists

private void SetUndoVidMarks()
{
    _UndoVidMarks = _VidMarks.Clone();
}

Có ai thích không? Có cải tiến gì không?

Bạn cũng có thể chỉ cần chuyển đổi danh sách thành một mảng bằng cách sử dụng ToArray, sau đó sao chép mảng bằng cách sử dụng Array.Clone(...). Tùy thuộc vào nhu cầu của bạn, các phương thức có trong lớp Array có thể đáp ứng nhu cầu của bạn.

Bạn có thể sử dụng phương pháp mở rộng:

namespace extension
{
    public class ext
    {
        public static List<double> clone(this List<double> t)
        {
            List<double> kop = new List<double>();
            int x;
            for (x = 0; x < t.Count; x++)
            {
                kop.Add(t[x]);
            }
            return kop;
        }
   };

}

Bạn có thể sao chép tất cả các đối tượng bằng cách sử dụng các thành viên loại giá trị của chúng, ví dụ, xem xét lớp này:

public class matrix
{
    public List<List<double>> mat;
    public int rows,cols;
    public matrix clone()
    { 
        // create new object
        matrix copy = new matrix();
        // firstly I can directly copy rows and cols because they are value types
        copy.rows = this.rows;  
        copy.cols = this.cols;
        // but now I can no t directly copy mat because it is not value type so
        int x;
        // I assume I have clone method for List<double>
        for(x=0;x<this.mat.count;x++)
        {
            copy.mat.Add(this.mat[x].clone());
        }
        // then mat is cloned
        return copy; // and copy of original is returned 
    }
};

Lưu ý: nếu bạn thực hiện bất kỳ thay đổi nào trên bản sao (hoặc bản sao), nó sẽ không ảnh hưởng đến đối tượng ban đầu.

Nếu bạn cần một danh sách nhân bản có cùng dung lượng, bạn có thể thử điều này:

public static List<T> Clone<T>(this List<T> oldList)
{
    var newList = new List<T>(oldList.Capacity);
    newList.AddRange(oldList);
    return newList;
}

Tôi đã tạo cho riêng mình một số tiện ích mở rộng chuyển đổi ICollection của các mặt hàng không triển khai IClonable

static class CollectionExtensions
{
    public static ICollection<T> Clone<T>(this ICollection<T> listToClone)
    {
        var array = new T[listToClone.Count];
        listToClone.CopyTo(array,0);
        return array.ToList();
    }
}

Tôi sử dụng automapper để sao chép một đối tượng. Tôi chỉ thiết lập một ánh xạ ánh xạ một đối tượng đến chính nó. Bạn có thể bọc thao tác này bất kỳ cách nào bạn muốn.

http://automapper.codeplex.com/

Sử dụng diễn viên có thể hữu ích, trong trường hợp này, cho một bản sao nông:

IList CloneList(IList list)
{
    IList result;
    result = (IList)Activator.CreateInstance(list.GetType());
    foreach (object item in list) result.Add(item);
    return result;
}

áp dụng cho danh sách chung:

List<T> Clone<T>(List<T> argument) => (List<T>)CloneList(argument);

Đối với một bản sao sâu, IClonizable là giải pháp chính xác, nhưng đây là một cách tiếp cận tương tự với IClonizable bằng cách sử dụng hàm tạo thay vì giao diện IClonizable.

public class Student
{
  public Student(Student student)
  {
    FirstName = student.FirstName;
    LastName = student.LastName;
  }

  public string FirstName { get; set; }
  public string LastName { get; set; }
}

// wherever you have the list
List<Student> students;

// and then where you want to make a copy
List<Student> copy = students.Select(s => new Student(s)).ToList();

bạn sẽ cần thư viện sau nơi bạn tạo bản sao

using System.Linq

bạn cũng có thể sử dụng vòng lặp for thay vì System.Linq, nhưng Linq làm cho nó ngắn gọn và rõ ràng. Tương tự như vậy, bạn có thể làm như các câu trả lời khác đã đề xuất và thực hiện các phương pháp mở rộng, v.v., nhưng không có câu trả lời nào là cần thiết.

Các mã sau đây nên chuyển vào một danh sách với những thay đổi tối thiểu.

Về cơ bản, nó hoạt động bằng cách chèn một số ngẫu nhiên mới từ một phạm vi lớn hơn với mỗi vòng lặp liên tiếp. Nếu đã tồn tại các số giống hoặc cao hơn số đó, hãy dịch các số ngẫu nhiên đó lên một số để chúng chuyển sang phạm vi chỉ mục ngẫu nhiên lớn hơn mới.

// Example Usage
int[] indexes = getRandomUniqueIndexArray(selectFrom.Length, toSet.Length);

for(int i = 0; i < toSet.Length; i++)
    toSet[i] = selectFrom[indexes[i]];


private int[] getRandomUniqueIndexArray(int length, int count)
{
    if(count > length || count < 1 || length < 1)
        return new int[0];

    int[] toReturn = new int[count];
    if(count == length)
    {
        for(int i = 0; i < toReturn.Length; i++) toReturn[i] = i;
        return toReturn;
    }

    Random r = new Random();
    int startPos = count - 1;
    for(int i = startPos; i >= 0; i--)
    {
        int index = r.Next(length - i);
        for(int j = startPos; j > i; j--)
            if(toReturn[j] >= index)
                toReturn[j]++;
        toReturn[i] = index;
    }

    return toReturn;
}

Một điều nữa: bạn có thể sử dụng sự phản chiếu. Nếu bạn sẽ lưu trữ bộ đệm này đúng cách, thì nó sẽ sao chép 1.000.000 đối tượng trong 5,6 giây (đáng buồn là 16,4 giây với các đối tượng bên trong).

[ProtoContract(ImplicitFields = ImplicitFields.AllPublic)]
public class Person
{
       ...
      Job JobDescription
       ...
}

[ProtoContract(ImplicitFields = ImplicitFields.AllPublic)]
public class Job
{...
}

private static readonly Type stringType = typeof (string);

public static class CopyFactory
{
    static readonly Dictionary<Type, PropertyInfo[]> ProperyList = new Dictionary<Type, PropertyInfo[]>();

    private static readonly MethodInfo CreateCopyReflectionMethod;

    static CopyFactory()
    {
        CreateCopyReflectionMethod = typeof(CopyFactory).GetMethod("CreateCopyReflection", BindingFlags.Static | BindingFlags.Public);
    }

    public static T CreateCopyReflection<T>(T source) where T : new()
    {
        var copyInstance = new T();
        var sourceType = typeof(T);

        PropertyInfo[] propList;
        if (ProperyList.ContainsKey(sourceType))
            propList = ProperyList[sourceType];
        else
        {
            propList = sourceType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            ProperyList.Add(sourceType, propList);
        }

        foreach (var prop in propList)
        {
            var value = prop.GetValue(source, null);
            prop.SetValue(copyInstance,
                value != null && prop.PropertyType.IsClass && prop.PropertyType != stringType ? CreateCopyReflectionMethod.MakeGenericMethod(prop.PropertyType).Invoke(null, new object[] { value }) : value, null);
        }

        return copyInstance;
    }

Tôi đã đo nó một cách đơn giản, bằng cách sử dụng lớp Watcher.

 var person = new Person
 {
     ...
 };

 for (var i = 0; i < 1000000; i++)
 {
    personList.Add(person);
 }
 var watcher = new Stopwatch();
 watcher.Start();
 var copylist = personList.Select(CopyFactory.CreateCopyReflection).ToList();
 watcher.Stop();
 var elapsed = watcher.Elapsed;

KẾT QUẢ: Với đối tượng bên trong PersonInstance - 16.4, PersonInstance = null - 5.6

CopyFactory chỉ là lớp kiểm tra của tôi, nơi tôi có hàng tá bài kiểm tra bao gồm cả việc sử dụng biểu thức. Bạn có thể thực hiện điều này trong một hình thức khác trong một phần mở rộng hoặc bất cứ điều gì. Đừng quên bộ nhớ đệm.

Tôi chưa thử nghiệm tuần tự hóa, nhưng tôi nghi ngờ về sự cải tiến với một triệu lớp. Tôi sẽ thử một cái gì đó nhanh protobuf / newton.

PS: vì mục đích đọc đơn giản, tôi chỉ sử dụng tính năng tự động ở đây. Tôi có thể cập nhật với FieldInfo hoặc bạn có thể dễ dàng thực hiện việc này bằng cách riêng của mình.

Gần đây tôi đã thử nghiệm trình tuần tự hóa Bộ đệm giao thức với chức năng DeepClone. Nó chiến thắng với 4.2 giây trên một triệu vật thể đơn giản, nhưng khi nói đến vật thể bên trong, nó chiến thắng với kết quả là 7,4 giây.

Serializer.DeepClone(personList);

TÓM TẮT: Nếu bạn không có quyền truy cập vào các lớp, thì điều này sẽ giúp ích. Nếu không, nó phụ thuộc vào số lượng của các đối tượng. Tôi nghĩ rằng bạn có thể sử dụng sự phản chiếu lên tới 10.000 đối tượng (có thể ít hơn một chút), nhưng với nhiều hơn thế, bộ nối tiếp Bộ đệm Giao thức sẽ hoạt động tốt hơn.

Có một cách đơn giản để sao chép các đối tượng trong C # bằng cách sử dụng trình tuần tự hóa và trình giải tuần tự JSON.

Bạn có thể tạo một lớp mở rộng:

using Newtonsoft.Json;

static class typeExtensions
{
    [Extension()]
    public static T jsonCloneObject<T>(T source)
    {
    string json = JsonConvert.SerializeObject(source);
    return JsonConvert.DeserializeObject<T>(json);
    }
}

Để nhân bản và đối tượng:

obj clonedObj = originalObj.jsonCloneObject;