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

У меня есть общий список объектов в С# и хочу клонировать список. Элементы в списке являются клонированными, но, похоже, не существует опции list.Clone().

Есть ли простой способ обойти это?

509
21 окт. '08 в 19:47
источник поделиться
27 ответов

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

static class Extensions
{
    public static IList<T> Clone<T>(this IList<T> listToClone) where T: ICloneable
    {
        return listToClone.Select(item => (T)item.Clone()).ToList();
    }
}
339
21 окт. '08 в 19:58
источник

Связанные вопросы


Похожие вопросы

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

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 из-за необходимости гарантировать глубокую копию всех участников. Вместо этого я бы предложил конструктор-копию или метод factory, например YourType.CopyFrom(YourType itemToCopy), который возвращает новый экземпляр YourType.

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

452
21 окт. '08 в 19:54
источник
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;
}

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

76
21 окт. '08 в 20:43
источник

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

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

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

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

75
21 окт. '08 в 19:52
источник

После небольшой модификации вы также можете клонировать:

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;
}
20
20 июля '11 в 12:26
источник

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

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

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

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

15
10 июля '15 в 17:09
источник

Чтобы клонировать список, просто вызовите .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 }
> 
15
25 сент. '17 в 3:35
источник

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

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

Mapper.CreateMap<YourType, YourType>();

Сделайте магию:

YourTypeList.ConvertAll(Mapper.Map<YourType, YourType>);
13
14 февр. '13 в 2:20
источник

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

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

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);
13
21 окт. '08 в 19:54
источник

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

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

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

9
01 нояб. '13 в 17:43
источник
    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;
        }
    }
3
10 апр. '16 в 10:40
источник
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;
}
3
25 апр. '11 в 15:18
источник
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;
  }
}
3
07 окт. '11 в 10:04
источник

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

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

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

2
07 июня '13 в 14:37
источник

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

2
15 янв. '15 в 18:08
источник

Мой друг Грегор Мартинович и я придумали это простое решение с помощью сериализатора JavaScript. Нет необходимости отмечать классы как 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);
}
2
09 нояб. '16 в 16:55
источник

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

public static List<T> Clone<T>(this List<T> oldList)
{
    var newList = new List<T>(oldList.Capacity);
    newList.AddRange(oldList);
    return newList;
}
2
22 дек. '15 в 5:19
источник

Я сделал для своего собственного расширения, которое преобразует 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();
    }
}
1
03 июля '13 в 15:41
источник

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

http://automapper.codeplex.com/

1
13 окт. '14 в 17:28
источник

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

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);
1
27 февр. '19 в 12:51
источник

Существует простой способ клонирования объектов в С# с использованием сериализатора 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;
0
20 янв. '17 в 11:43
источник
 //try this
 List<string> ListCopy= new List<string>(OldList);
 //or try
 List<T> ListCopy=OldList.ToList();
0
18 февр. '18 в 7:52
источник
 public class DemoListClone
 {
    private class YearsDto : ICloneable
    {
        public object Clone()
        {
            return new YearsDto { Year = this.Year };
        }

        public int Year { get; set; }
    }

    private List<YearsDto> Org_Years = new List<YearsDto> { new YearsDto { Year = 1966 }, new YearsDto { Year = 1969 } , new YearsDto { Year = 1973 } , new YearsDto { Year = 1985 } , new YearsDto { Year = 2000 } };
    private List<YearsDto> Work_Years;

    public void CloneList()
    {
        this.Work_Years = this.Org_Years.Select(x => (YearsDto)x.Clone()).Where(x => x.Year > 1970).ToList();
    }
  }

первоначальный список = 1966, 1969, 1973, 1985, 2000

рабочий список = 1973, 1985, 2000

0
10 дек. '18 в 19:11
источник

Мне повезет, если кто-нибудь когда-нибудь прочтет это... но чтобы не возвращать список типов объектов в моих методах 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();
}

Кто-нибудь любит это? Какие-нибудь улучшения?

0
21 янв. '19 в 20:15
источник

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

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

// 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;
}
0
03 сент. '15 в 14:23
источник

Другое дело: вы можете использовать отражение. Если вы будете кэшировать это правильно, то он будет клонировать 1 000 000 объектов за 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 - это всего лишь мой тестовый класс, где у меня есть дюжина тестов, включая использование выражения. Вы можете реализовать это в другой форме в расширении или что-то еще. Не забывайте о кешировании.

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

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

Недавно я протестировал сериализатор Protocol Buffers с функцией DeepClone из коробки. Он выигрывает с 4.2 секундами на миллион простых объектов, но когда дело доходит до внутренних объектов, он выигрывает с результатом 7.4 секунды.

Serializer.DeepClone(personList);

АННОТАЦИЯ: Если у вас нет доступа к классам, это поможет. В противном случае это зависит от количества объектов. Я думаю, вы могли бы использовать отражение до 10 000 объектов (может быть, немного меньше), но более того, сериализатор протоколов буферов будет работать лучше.

0
19 дек. '15 в 2:56
источник

Для глубокой копии 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 делает его лаконичным и понятным. Точно так же вы могли бы делать, как предлагали другие ответы, и делать методы расширения и т.д., Но ничего из этого не требуется.

0
14 мая '19 в 0:04
источник

Посмотрите другие вопросы по меткам или Задайте вопрос