Як клонувати загальний список у C #?

У мене є загальний список об'єктів у C # і я хочу його клонувати. Елементи зі списку можуть бути клонованими, але, здається, немає можливості зробити це list.Clone().

Чи існує простий спосіб цього?

Можна використовувати метод розширення.

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

Якщо ваші елементи - це типові значення, то ви можете просто зробити:

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.

Будь-який із цих варіантів може бути перетворений методом (розширенням чи іншим способом).

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

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

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

Цитується з: Рецепти генерики

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

Це один із способів зробити це за допомогою C # і .NET 2.0. Ваш об’єкт вимагає бути [Serializable()]. Мета - втратити всі посилання та побудувати нові.

Для клонування списку просто зателефонуйте .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 }
> 

Після невеликої модифікації ви також можете клонувати:

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

Якщо вам не потрібен фактичний клон кожного об'єкту всередині вашого List<T>, найкращий спосіб клонувати список - це створити новий список зі старим списком як параметр колекції.

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

Зміни, myListтакі як вставка або видалення, не вплинуть cloneOfMyListі навпаки.

Однак фактичні об'єкти, які містяться у двох Списках, все ще однакові.

Використовувати AutoMapper (або будь-яку іншу карту), яку ви віддаєте перевагу, для клонування просто та багато ремонту.

Визначте своє відображення:

Mapper.CreateMap<YourType, YourType>();

Робіть магію:

YourTypeList.ConvertAll(Mapper.Map<YourType, 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);

Якщо ви вже посилалися на Newtonsoft.Json у своєму проекті, а ваші об'єкти можна серіалізувати, ви завжди можете використовувати:

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

Можливо, це не найефективніший спосіб зробити це, але якщо ви це не зробите в 100 тисяч разів, ви навіть не помітите різницю швидкості.

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

Ми з моїм другом Грегором Мартиновичем придумали це просте рішення за допомогою серіалізатора JavaScript. Немає необхідності позначати класи як серіалізаційні, і в наших тестах, використовуючи 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);
}

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

Комусь подобається? Будь-які поліпшення?

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

Ви можете використовувати метод розширення:

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

Примітка: якщо ви внесете будь-які зміни на копію (або клонування), це не вплине на оригінальний об'єкт.

Якщо вам потрібен список клонованих з однаковою ємністю, ви можете спробувати це:

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

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

Я використовую автоматизатор для копіювання об'єкта. Я просто налаштовую карту, яка відображає один об’єкт до себе. Ви можете завершити цю операцію будь-яким способом.

http://automapper.codeplex.com/

Використання акторів може бути корисним у цьому випадку для дрібної копії:

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 робить це лаконічним та чистим. Так само ви можете зробити так, як пропонують інші відповіді, і зробити методи розширення тощо, але нічого з цього не потрібно.

Наступний код повинен перенестись у список із мінімальними змінами.

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

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

Інша річ: ви могли б використати роздуми. Якщо ви кешуєте це належним чином, то він клонуватиме 1000 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 - це лише мій тестовий клас, де я провів десяток тестів, включаючи використання вираження. Ви можете реалізувати це в іншій формі в розширенні чи будь-якому іншому. Не забувайте про кешування.

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

PS: для простоти читання я тут використовував лише автоматичну властивість. Я міг би оновити програму FieldInfo, або вам слід легко її реалізувати самостійно.

Нещодавно я перевірив серіалізатор протокольних буферів із функцією DeepClone поза коробкою. Він виграє за 4,2 секунди на мільйоні простих предметів, але коли мова йде про внутрішні об’єкти, він виграє з результатом 7,4 секунди.

Serializer.DeepClone(personList);

РЕЗЮМЕ: Якщо у вас немає доступу до класів, це допоможе. Інакше це залежить від кількості об’єктів. Я думаю, ви могли б використовувати відображення до 10 000 об'єктів (можливо трохи менше), але для цього серіалізатор протокольних буферів працюватиме краще.

Існує простий спосіб клонування об’єктів у 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;