Comment cloner une liste générique en C #?

J'ai une liste générique d'objets en C # et je souhaite cloner la liste. Les éléments de la liste sont clonables, mais il ne semble pas y avoir d'option à faire list.Clone().

Existe-t-il un moyen simple de contourner cela?

Vous pouvez utiliser une méthode d'extension.

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

Si vos éléments sont des types de valeur, vous pouvez simplement faire:

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

Cependant, s'il s'agit de types de référence et que vous souhaitez une copie complète (en supposant que vos éléments soient correctement implémentés ICloneable), vous pouvez faire quelque chose comme ceci:

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

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

De toute évidence, remplacez ICloneableles génériques ci-dessus et effectuez un cast avec le type d'élément implémenté ICloneable.

Si votre type d'élément ne prend pas en charge ICloneablemais a un constructeur de copie, vous pouvez le faire à la place:

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

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

Personnellement, j'éviterais en ICloneableraison de la nécessité de garantir une copie complète de tous les membres. Au lieu de cela, je suggère le constructeur de copie ou une méthode d'usine comme YourType.CopyFrom(YourType itemToCopy)celle-ci renvoie une nouvelle instance de YourType.

Chacune de ces options peut être encapsulée par une méthode (extension ou autre).

Pour une copie superficielle, vous pouvez utiliser à la place la méthode GetRange de la classe List générique.

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

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

Tiré de: Recettes génériques

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'est une façon de le faire avec C # et .NET 2.0. Votre objet doit l'être [Serializable()]. Le but est de perdre toutes les références et d'en construire de nouvelles.

Pour cloner une liste, il suffit d'appeler .ToList (). Cela crée une copie superficielle.

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

Après une légère modification, vous pouvez également cloner:

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

Sauf si vous avez besoin d'un clone réel de chaque objet à l'intérieur de votre List<T>, la meilleure façon de cloner une liste est de créer une nouvelle liste avec l'ancienne liste comme paramètre de collection.

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

Des modifications myListtelles que l'insertion ou la suppression n'affecteront pascloneOfMyList et vice versa.

Les objets réels que contiennent les deux listes sont cependant toujours les mêmes.

Utiliser AutoMapper (ou la bibliothèque de mappage que vous préférez) pour cloner est simple et très facile à gérer.

Définissez votre cartographie:

Mapper.CreateMap<YourType, YourType>();

Faites la magie:

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

Si vous ne vous souciez que des types de valeur ...

Et vous connaissez le type:

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

Si vous ne connaissez pas le type auparavant, vous aurez besoin d'une fonction d'assistance:

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

Le juste:

List<string> myNewList = Clone(myOldList);

Si vous avez déjà référencé Newtonsoft.Json dans votre projet et que vos objets sont sérialisables, vous pouvez toujours utiliser:

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

Ce n'est peut-être pas le moyen le plus efficace de le faire, mais à moins que vous ne le fassiez des centaines de milliers de fois, vous ne remarquerez peut-être même pas la différence de vitesse.

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

Mon ami Gregor Martinovic et moi avons trouvé cette solution simple en utilisant un sérialiseur JavaScript. Il n'est pas nécessaire de marquer les classes comme sérialisables et dans nos tests en utilisant Newtonsoft JsonSerializer encore plus rapidement qu'en utilisant BinaryFormatter. Avec des méthodes d'extension utilisables sur chaque objet.

Option standard .NET JavascriptSerializer:

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

    string json = js.Serialize(value);

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

Option plus rapide avec 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();

Je serai chanceux si quelqu'un lit jamais ceci ... mais afin de ne pas retourner une liste d'objets type dans mes méthodes Clone, j'ai créé une interface:

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

Ensuite, j'ai spécifié l'extension:

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

Et voici une implémentation de l'interface dans mon logiciel de marquage A / V. Je voulais que ma méthode Clone () retourne une liste de VidMark (tandis que l'interface ICloneable voulait que ma méthode retourne une liste d'objets):

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

Et enfin, l'utilisation de l'extension à l'intérieur d'une classe:

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

//Other methods instantiate and fill the lists

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

Quelqu'un l'aime? Des améliorations?

Vous pouvez également simplement convertir la liste en un tableau à l'aide ToArray, puis cloner le tableau à l'aide Array.Clone(...). Selon vos besoins, les méthodes incluses dans la classe Array peuvent répondre à vos besoins.

Vous pouvez utiliser la méthode d'extension:

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

}

Vous pouvez cloner tous les objets en utilisant leurs membres de type valeur par exemple, considérez cette classe:

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

Remarque: si vous effectuez des modifications sur la copie (ou le clonage), cela n'affectera pas l'objet d'origine.

Si vous avez besoin d'une liste clonée avec la même capacité, vous pouvez essayer ceci:

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

J'ai créé moi-même une extension qui convertit ICollection d'éléments qui n'implémentent pas 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();
    }
}

J'utilise automapper pour copier un objet. Je viens de configurer un mappage qui mappe un objet sur lui-même. Vous pouvez terminer cette opération comme vous le souhaitez.

http://automapper.codeplex.com/

L'utilisation d'un casting peut être utile, dans ce cas, pour une copie superficielle:

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

appliqué à la liste générique:

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

Pour une copie complète, ICloneable est la bonne solution, mais voici une approche similaire à ICloneable utilisant le constructeur au lieu de l'interface 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();

vous aurez besoin de la bibliothèque suivante où vous faites la copie

using System.Linq

vous pouvez également utiliser une boucle for au lieu de System.Linq, mais Linq la rend concise et propre. De même, vous pouvez faire comme d'autres réponses l'ont suggéré et créer des méthodes d'extension, etc., mais rien de tout cela n'est nécessaire.

Le code suivant doit être transféré sur une liste avec un minimum de modifications.

Fondamentalement, cela fonctionne en insérant un nouveau nombre aléatoire à partir d'une plus grande plage avec chaque boucle successive. S'il existe déjà des nombres qui sont identiques ou supérieurs à lui, déplacez ces nombres aléatoires d'un pour qu'ils soient transférés dans la nouvelle gamme plus large d'index aléatoires.

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

Autre chose: vous pouvez utiliser la réflexion. Si vous le cachez correctement, il clonera 1 000 000 d'objets en 5,6 secondes (malheureusement, 16,4 secondes avec des objets internes).

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

Je l'ai mesuré d'une manière simple, en utilisant la classe 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;

RÉSULTAT: avec l'objet interne PersonInstance - 16.4, PersonInstance = null - 5.6

CopyFactory est juste ma classe de test où j'ai une douzaine de tests, y compris l'utilisation de l'expression. Vous pouvez l'implémenter sous une autre forme dans une extension ou autre. N'oubliez pas la mise en cache.

Je n'ai pas encore testé la sérialisation, mais je doute d'une amélioration avec un million de classes. Je vais essayer quelque chose de rapide protobuf / newton.

PS: par souci de simplicité de lecture, je n'ai utilisé ici que la propriété automatique. Je pourrais mettre à jour avec FieldInfo, ou vous devriez facilement l'implémenter par vous-même.

J'ai récemment testé le sérialiseur Protocol Buffers avec la fonction DeepClone prête à l'emploi. Il gagne avec 4,2 secondes sur un million d'objets simples, mais en ce qui concerne les objets intérieurs, il gagne avec le résultat 7,4 secondes.

Serializer.DeepClone(personList);

RÉSUMÉ: Si vous n'avez pas accès aux cours, cela vous aidera. Sinon, cela dépend du nombre d'objets. Je pense que vous pouvez utiliser la réflexion jusqu'à 10 000 objets (peut-être un peu moins), mais pour plus que cela, le sérialiseur Protocol Buffers fonctionnera mieux.

Il existe un moyen simple de cloner des objets en C # à l'aide d'un sérialiseur et désérialiseur JSON.

Vous pouvez créer une classe d'extension:

using Newtonsoft.Json;

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

Pour cloner et objecter:

obj clonedObj = originalObj.jsonCloneObject;