Как клонировать общий список на C#?

Для неглубокой копии вместо этого можно использовать метод GetRange универсального класса List.

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

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

Цитируется по: Рецепты дженериков

Если ваши элементы являются типами значений, вы можете просто сделать:

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

Однако, если это ссылочные типы, и вам нужна глубокая копия (при условии, что ваши элементы правильно реализуют ICloneable), вы можете сделать что-то вроде этого:

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

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

Очевидно, замените ICloneable в приведенных выше универсальных шаблонах и приведите их к любому типу вашего элемента, который реализует ICloneable.

Если ваш тип элемента не поддерживает ICloneable, но имеет конструктор копирования, вы можете сделать это вместо этого:

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

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

Лично я бы избегал ICloneable из-за необходимости гарантировать полную копию всех участников. Вместо этого я бы предложил конструктор копирования или фабричный метод, такой как YourType.CopyFrom(YourType itemToCopy), который возвращает новый экземпляр YourType.

Любой из этих параметров может быть обернут методом (расширением или другим способом).

Если вас интересуют только типы значений ...

И вы знаете тип:

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

Если вы раньше не знали тип, вам понадобится вспомогательная функция:

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

Справедливый:

List<string> myNewList = Clone(myOldList);

Вы можете использовать метод расширения.

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

public static object DeepClone(object obj) 
{
    object objResult = null;

    using (var ms = new MemoryStream())
    {
        var bf = new BinaryFormatter();
        bf.Serialize(ms, obj);

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

     return objResult;
}

Это один из способов сделать это с помощью C# и .NET 2.0. Ваш объект должен быть [Serializable()]. Цель состоит в том, чтобы потерять все ссылки и создать новые.

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 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;
}

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;
  }
}

Использовать AutoMapper (или любую другую библиотеку сопоставления, которую вы предпочитаете) для клонирования просто и легко обслуживается.

Определите свое отображение:

Mapper.CreateMap<YourType, YourType>();

Творите волшебство:

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

Вы можете использовать метод расширения:

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;
        }
   };

}

Вы можете клонировать все объекты, используя их члены типа значения, например, рассмотрим этот класс:

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 
    }
};

Примечание: если вы внесете какие-либо изменения в копию (или клон), это не повлияет на исходный объект.

Я сделал для себя какое-то расширение, которое преобразует ICollection элементов, которые не реализуют 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();
    }
}

Если вы уже ссылались на Newtonsoft.Json в своем проекте и ваши объекты сериализуемы, вы всегда можете использовать:

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

Возможно, это не самый эффективный способ сделать это, но если вы не делаете это 100 из 1000 раз, вы можете даже не заметить разницу в скорости.

Я использую automapper для копирования объекта. Я просто настраиваю отображение, которое сопоставляет один объект самому себе. Вы можете обернуть эту операцию как хотите.

http://automapper.codeplex.com/

Вы также можете просто преобразовать список в массив с помощью ToArray, а затем клонировать массив с помощью Array.Clone(...). В зависимости от ваших потребностей методы, включенные в класс Array, могут удовлетворить ваши потребности.

Если вам не нужен фактический клон каждого отдельного объекта внутри вашего List<T>, лучший способ клонировать список - создать новый список со старым списком в качестве параметра коллекции.

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

Изменения в myList, такие как вставка или удаление, не повлияют на cloneOfMyList и наоборот.

Однако фактические объекты, содержащиеся в двух списках, остаются прежними.

Следующий код должен быть перенесен в список с минимальными изменениями.

В основном это работает путем вставки нового случайного числа из большего диапазона с каждым последующим циклом. Если уже существуют такие же или большие числа, сдвиньте эти случайные числа на единицу вверх, чтобы они перешли в новый больший диапазон случайных индексов.

// 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;
}

Другое дело: вы можете использовать отражение. Если вы правильно кэшируете это, то он клонирует 1000000 объектов за 5,6 секунды (к сожалению, 16,4 секунды с внутренними объектами).

[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;
    }

Я измерил это простым способом, используя класс 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;

РЕЗУЛЬТАТ: С внутренним объектом PersonInstance - 16.4, PersonInstance = null - 5.6

CopyFactory - это просто мой тестовый класс, в котором у меня есть дюжина тестов, включая использование выражения. Вы можете реализовать это в другой форме в расширении или в чем-то еще. Не забывайте о кешировании.

Я еще не тестировал сериализацию, но сомневаюсь в улучшении с помощью миллиона классов. Попробую что-нибудь быстрое protobuf / newton.

P.S .: для простоты чтения я использовал здесь только auto-property. Я мог бы обновить с помощью FieldInfo, или вы должны легко реализовать это самостоятельно.

Недавно я протестировал сериализатор Буферы протокола с функцией DeepClone из коробки. Он выигрывает с результатом 4,2 секунды на миллионе простых объектов, но когда дело доходит до внутренних объектов, он выигрывает с результатом 7,4 секунды.

Serializer.DeepClone(personList);

РЕЗЮМЕ: Если у вас нет доступа к классам, то это поможет. В противном случае это зависит от количества объектов. Я думаю, вы могли бы использовать отражение до 10000 объектов (может быть, немного меньше), но для большего, чем это, сериализатор протокольных буферов будет работать лучше.

Если вам нужен клонированный список с такой же емкостью, вы можете попробовать следующее:

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

    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;
        }
    }

Нет необходимости отмечать классы как Serializable, и в наших тестах с использованием Newtonsoft JsonSerializer даже быстрее, чем с использованием BinaryFormatter. С методами расширения, используемыми для каждого объекта.

Стандартный вариант .NET JavascriptSerializer:

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

    string json = js.Serialize(value);

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

Более быстрый вариант с использованием Newtonsoft JSON:

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

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

Существует простой способ клонировать объекты в C# с помощью сериализатора и десериализатора JSON.

Вы можете создать класс расширения:

using Newtonsoft.Json;

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

Чтобы клонировать и возражать:

obj clonedObj = originalObj.jsonCloneObject;

Чтобы клонировать список, просто вызовите .ToList (). Это создает неглубокую копию.

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 }
> 

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

Мне повезет, если кто-нибудь когда-нибудь это прочитает ... но, чтобы не возвращать список типов объектов в моих методах Clone, я создал интерфейс:

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

Затем я указал расширение:

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

А вот реализация интерфейса в моем программном обеспечении для A / V-маркировки. Я хотел, чтобы мой метод Clone () возвращал список VidMark (в то время как интерфейс ICloneable хотел, чтобы мой метод возвращал список объектов):

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();
    }
}

И, наконец, использование расширения внутри класса:

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

//Other methods instantiate and fill the lists

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

Кому-нибудь это нравится? Есть улучшения?

В этом случае для неглубокой копии может быть полезно использовать приведение:

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

применяется к общему списку:

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

Для глубокой копии ICloneable - правильное решение, но здесь аналогичный подход к ICloneable с использованием конструктора вместо интерфейса ICloneable.

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();

вам понадобится следующая библиотека, в которой вы сделаете копию

using System.Linq

вы также можете использовать цикл for вместо System.Linq, но Linq делает его кратким и понятным. Точно так же вы могли бы сделать, как предлагали другие ответы, и создать методы расширения и т.д., но ничего из этого не требуется.

Для глубокого клона я использую отражение следующим образом:

public List<T> CloneList<T>(IEnumerable<T> listToClone) {
    Type listType = listToClone.GetType();
    Type elementType = listType.GetGenericArguments()[0];
    List<T> listCopy = new List<T>();
    foreach (T item in listToClone) {
        object itemCopy = Activator.CreateInstance(elementType);
        foreach (PropertyInfo property in elementType.GetProperties()) {
            elementType.GetProperty(property.Name).SetValue(itemCopy, property.GetValue(item));
        }
        listCopy.Add((T)itemCopy);
    }
    return listCopy;
}

Вы можете использовать List или IEnumerable как взаимозаменяемые.