Wie klone ich eine generische Liste in C #?

Ich habe eine generische Liste von Objekten in C # und möchte die Liste klonen. Die Elemente in der Liste sind klonbar, aber es scheint keine Option zu geben list.Clone().

Gibt es einen einfachen Weg, dies zu umgehen?

Sie können eine Erweiterungsmethode verwenden.

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

Wenn Ihre Elemente Werttypen sind, können Sie einfach Folgendes tun:

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

Wenn es sich jedoch um Referenztypen handelt und Sie eine tiefe Kopie wünschen (vorausgesetzt, Ihre Elemente werden ordnungsgemäß implementiert ICloneable), können Sie Folgendes tun:

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

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

Ersetzen Sie natürlich ICloneabledie oben genannten Generika und setzen Sie sie mit dem Elementtyp um, der implementiert wird ICloneable.

Wenn Ihr Elementtyp nicht unterstützt ICloneable, aber über einen Kopierkonstruktor verfügt, können Sie stattdessen Folgendes tun:

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

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

Persönlich würde ich es vermeiden, ICloneableweil eine tiefe Kopie aller Mitglieder garantiert werden muss. Stattdessen würde ich vorschlagen, dass der Kopierkonstruktor oder eine solche Factory-Methode YourType.CopyFrom(YourType itemToCopy)eine neue Instanz von zurückgibt YourType.

Jede dieser Optionen kann durch eine Methode (Erweiterung oder auf andere Weise) umbrochen werden.

Für eine flache Kopie können Sie stattdessen die GetRange-Methode der generischen List-Klasse verwenden.

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

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

Zitiert aus: Generika-Rezepte

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

Dies ist eine Möglichkeit, dies mit C # und .NET 2.0 zu tun. Ihr Objekt muss sein [Serializable()]. Ziel ist es, alle Referenzen zu verlieren und neue zu erstellen.

Um eine Liste zu klonen, rufen Sie einfach .ToList () auf. Dadurch wird eine flache Kopie erstellt.

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

Nach einer geringfügigen Änderung können Sie auch klonen:

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

Wenn Sie List<T>keinen tatsächlichen Klon für jedes einzelne Objekt in Ihrem Objekt benötigen, können Sie eine Liste am besten klonen, indem Sie eine neue Liste mit der alten Liste als Auflistungsparameter erstellen.

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

Änderungen myListwie Einfügen oder Entfernen wirken sich nicht aus cloneOfMyListund umgekehrt.

Die tatsächlichen Objekte, die die beiden Listen enthalten, sind jedoch immer noch dieselben.

Die Verwendung von AutoMapper (oder einer von Ihnen bevorzugten Zuordnungsbibliothek) zum Klonen ist einfach und sehr wartbar.

Definieren Sie Ihr Mapping:

Mapper.CreateMap<YourType, YourType>();

Mach die Magie:

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

Wenn Sie sich nur für Werttypen interessieren ...

Und Sie kennen den Typ:

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

Wenn Sie den Typ vorher nicht kennen, benötigen Sie eine Hilfsfunktion:

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

Das Gerechte:

List<string> myNewList = Clone(myOldList);

Wenn Sie in Ihrem Projekt bereits auf Newtonsoft.Json verwiesen haben und Ihre Objekte serialisierbar sind, können Sie immer Folgendes verwenden:

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

Möglicherweise nicht der effizienteste Weg, dies zu tun, aber wenn Sie es nicht 100 oder 1000 Mal tun, werden Sie möglicherweise nicht einmal den Geschwindigkeitsunterschied bemerken.

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

Mein Freund Gregor Martinovic und ich haben diese einfache Lösung mit einem JavaScript Serializer entwickelt. Es ist nicht erforderlich, Klassen als serialisierbar zu kennzeichnen und in unseren Tests mit dem Newtonsoft JsonSerializer noch schneller als mit BinaryFormatter. Mit Erweiterungsmethoden, die für jedes Objekt verwendet werden können.

Standardoption für .NET JavascriptSerializer:

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

    string json = js.Serialize(value);

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

Schnellere Option mit 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();

Ich habe Glück, wenn jemand dies jemals liest ... aber um keine Liste von Typobjekten in meinen Klonmethoden zurückzugeben, habe ich eine Schnittstelle erstellt:

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

Dann habe ich die Erweiterung angegeben:

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

Und hier ist eine Implementierung der Schnittstelle in meiner A / V-Markierungssoftware. Ich wollte, dass meine Clone () -Methode eine Liste von VidMark zurückgibt (während die ICloneable-Schnittstelle wollte, dass meine Methode eine Liste von Objekten zurückgibt):

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

Und schließlich die Verwendung der Erweiterung innerhalb einer Klasse:

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

//Other methods instantiate and fill the lists

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

Gefällt es jemandem? Irgendwelche Verbesserungen?

Sie können die Liste auch einfach mit in ein Array konvertieren ToArrayund das Array dann mit klonen Array.Clone(...). Abhängig von Ihren Anforderungen können die in der Array-Klasse enthaltenen Methoden Ihren Anforderungen entsprechen.

Sie können die Erweiterungsmethode verwenden:

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

}

Sie können alle Objekte klonen, indem Sie beispielsweise ihre Werttypelemente verwenden. Betrachten Sie diese Klasse:

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

Hinweis: Wenn Sie beim Kopieren (oder Klonen) Änderungen vornehmen, wirkt sich dies nicht auf das ursprüngliche Objekt aus.

Wenn Sie eine geklonte Liste mit derselben Kapazität benötigen, können Sie Folgendes versuchen:

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

Ich habe selbst eine Erweiterung erstellt, die die ICollection von Elementen konvertiert, die IClonable nicht implementieren

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

Ich benutze Automapper, um ein Objekt zu kopieren. Ich habe gerade eine Zuordnung eingerichtet, die ein Objekt auf sich selbst abbildet. Sie können diesen Vorgang beliebig umbrechen.

http://automapper.codeplex.com/

Die Verwendung einer Besetzung kann in diesem Fall für eine flache Kopie hilfreich sein:

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

angewendet auf generische Liste:

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

Für eine tiefe Kopie ist ICloneable die richtige Lösung, aber hier ist ein ähnlicher Ansatz wie bei ICloneable, bei dem der Konstruktor anstelle der ICloneable-Schnittstelle verwendet wird.

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

Sie benötigen die folgende Bibliothek, in der Sie die Kopie erstellen

using System.Linq

Sie können auch eine for-Schleife anstelle von System.Linq verwenden, aber Linq macht sie präzise und sauber. Ebenso könnten Sie tun, was andere Antworten vorgeschlagen haben, und Erweiterungsmethoden usw. erstellen, aber nichts davon ist notwendig.

Der folgende Code sollte mit minimalen Änderungen in eine Liste übertragen werden.

Grundsätzlich funktioniert es, indem mit jeder aufeinanderfolgenden Schleife eine neue Zufallszahl aus einem größeren Bereich eingefügt wird. Wenn es bereits Zahlen gibt, die gleich oder höher sind, verschieben Sie diese Zufallszahlen um eins nach oben, damit sie in den neuen größeren Bereich von Zufallsindizes übertragen werden.

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

Eine andere Sache: Sie könnten Reflexion gebrauchen. Wenn Sie dies richtig zwischenspeichern, werden 1.000.000 Objekte in 5,6 Sekunden geklont (leider 16,4 Sekunden bei inneren Objekten).

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

Ich habe es auf einfache Weise mit der Watcher-Klasse gemessen.

 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;

ERGEBNIS: Mit dem inneren Objekt PersonInstance - 16.4 ist PersonInstance = null - 5.6

CopyFactory ist nur meine Testklasse, in der ich Dutzende von Tests einschließlich der Verwendung von Ausdruck habe. Sie können dies in einer anderen Form in einer Erweiterung oder was auch immer implementieren. Vergessen Sie nicht das Caching.

Ich habe die Serialisierung noch nicht getestet, bezweifle aber eine Verbesserung mit einer Million Klassen. Ich werde etwas schnelles Protobuf / Newton versuchen.

PS: Der Einfachheit halber habe ich hier nur Auto-Property verwendet. Ich könnte mit FieldInfo aktualisieren, oder Sie sollten dies einfach selbst implementieren.

Ich habe kürzlich den Serializer für Protokollpuffer mit der sofort einsatzbereiten DeepClone-Funktion getestet . Es gewinnt mit 4,2 Sekunden auf einer Million einfacher Objekte, aber wenn es um innere Objekte geht, gewinnt es mit dem Ergebnis 7,4 Sekunden.

Serializer.DeepClone(personList);

ZUSAMMENFASSUNG: Wenn Sie keinen Zugriff auf die Klassen haben, hilft dies. Ansonsten kommt es auf die Anzahl der Objekte an. Ich denke, Sie könnten Reflexion von bis zu 10.000 Objekten verwenden (vielleicht etwas weniger), aber für mehr als dies wird der Serializer für Protokollpuffer eine bessere Leistung erzielen.

Es gibt eine einfache Möglichkeit, Objekte in C # mit einem JSON-Serializer und -Deserializer zu klonen.

Sie können eine Erweiterungsklasse erstellen:

using Newtonsoft.Json;

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

Klonen und Einwenden:

obj clonedObj = originalObj.jsonCloneObject;