Nasıl C # genel bir listesini klonlayabilirim?

C # nesnelerin genel bir listesi var ve listeyi klonlamak istiyorum. Listedeki öğeler klonlanabilir, ancak bir seçenek yok gibi görünüyor list.Clone().

Bunun kolay bir yolu var mı?

Bir uzantı yöntemi kullanabilirsiniz.

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

Öğeleriniz değer türüyse, şunları yapabilirsiniz:

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

Ancak, bunlar referans türleri ise ve derin bir kopya istiyorsanız (öğelerinizin düzgün bir şekilde uygulandığını varsayarak ICloneable), şöyle bir şey yapabilirsiniz:

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

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

Açıkçası, ICloneableyukarıdaki jenerikleri değiştirin ve uyguladığınız eleman türünüzle yapın ICloneable.

Öğe türünüz desteklemiyor ICloneableancak bir kopya oluşturucuya sahipse, bunun yerine bunu yapabilirsiniz:

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

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

Şahsen, ICloneabletüm üyelerin derin bir kopyasını garanti etme ihtiyacı nedeniyle kaçınırım . Bunun yerine, kopya oluşturucuyu veya bunun gibi bir fabrika yöntemini YourType.CopyFrom(YourType itemToCopy)yeni bir örneğini döndürmesini öneririm YourType.

Bu seçeneklerden herhangi biri bir yöntemle (uzantı veya başka bir şekilde) sarılabilir.

Sığ bir kopya için, bunun yerine genel List sınıfının GetRange yöntemini kullanabilirsiniz.

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

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

Alıntı sahibi: Generics Recipes

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

Bu, C # ve .NET 2.0 ile yapmanın bir yoludur. Nesneniz olması gerekiyor [Serializable()]. Amaç, tüm referansları kaybetmek ve yenilerini oluşturmaktır.

Bir listeyi klonlamak için .ToList () öğesini çağırmanız yeterlidir. Bu sığ bir kopya oluşturur.

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

Hafif bir değişiklikten sonra da klonlayabilirsiniz:

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

İçinizdeki her bir nesnenin gerçek bir klonuna ihtiyacınız olmadığı sürece List<T>, bir listeyi klonlamanın en iyi yolu eski parametre ile toplama parametresi olarak yeni bir liste oluşturmaktır.

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

Ekleme myListveya çıkarma gibi değişiklikler etkilemezcloneOfMyList veya tam tersi.

Ancak iki Listenin içerdiği gerçek nesneler hala aynıdır.

Klonlamak için AutoMapper'ı (veya tercih ettiğiniz herhangi bir haritalama lib'ini) basit ve çok bakım yapılabilir.

Eşlemenizi tanımlayın:

Mapper.CreateMap<YourType, YourType>();

Sihri yapın:

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

Yalnızca değer türlerini önemsiyorsanız ...

Ve türünü biliyorsunuz:

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

Daha önce türü bilmiyorsanız, bir yardımcı fonksiyona ihtiyacınız olacak:

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

Sadece:

List<string> myNewList = Clone(myOldList);

Projenizde zaten Newtonsoft.Json'a başvurduysanız ve nesneleriniz serileştirilebilirse, her zaman kullanabilirsiniz:

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

Muhtemelen bunu yapmanın en etkili yolu değil, ancak 1000'lerin 100'ünü yapmazsanız, hız farkını bile fark etmeyebilirsiniz.

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

Arkadaşım Gregor Martinovic ve ben bir JavaScript Serializer kullanarak bu kolay çözümü bulduk. Sınıfları Serializable olarak ve Newtonsoft JsonSerializer'ı kullanan testlerimizde BinaryFormatter kullanmaktan daha hızlı bir şekilde işaretlemeye gerek yoktur. Her nesnede kullanılabilen uzatma yöntemleri ile.

Standart .NET JavascriptSerializer seçeneği:

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

    string json = js.Serialize(value);

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

Newtonsoft JSON kullanarak daha hızlı seçenek :

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

Kimse bunu okursa şanslı olurum ... ama Clone yöntemlerimde bir tür nesne listesi döndürmemek için bir arayüz oluşturdum:

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

Sonra uzantıyı belirttim:

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

Ve işte A / V markalama yazılımımdaki arayüzün bir uygulaması. Clone () yöntemimin VidMark listesini döndürmesini istedim (ICloneable arayüzü yöntemimin nesne listesini döndürmesini istediğinde):

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

Ve son olarak, bir sınıf içinde uzantının kullanımı:

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

//Other methods instantiate and fill the lists

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

Bunu beğenen var mı? Herhangi bir gelişme var mı?

Ayrıca listeyi kullanarak bir diziye dönüştürebilir ToArrayve ardından diziyi klonlayabilirsiniz Array.Clone(...). Gereksinimlerinize bağlı olarak, Array sınıfında yer alan yöntemler ihtiyaçlarınızı karşılayabilir.

Uzantı yöntemini kullanabilirsiniz:

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

}

Örneğin, değer türü üyelerini kullanarak tüm nesneleri klonlayabilirsiniz, bu sınıfı göz önünde bulundurun:

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

Not: kopyada (veya klonda) herhangi bir değişiklik yaparsanız, orijinal nesne etkilenmez.

Aynı kapasiteye sahip klonlanmış bir listeye ihtiyacınız varsa, bunu deneyebilirsiniz:

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

IClonable'ı uygulamayan öğelerin ICollection'ını dönüştüren kendi uzantısı için yaptım

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

Bir nesneyi kopyalamak için automapper kullanıyorum. Sadece bir nesneyi kendine eşleyen bir eşleme ayarladım. Bu işlemi istediğiniz gibi sarabilirsiniz.

http://automapper.codeplex.com/

Bu durumda, sığ bir kopya için alçı kullanmak yardımcı olabilir:

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

genel listeye uygulandı:

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

Derin bir kopya için, ICloneable doğru çözümdür, ancak burada ICloneable arabirimi yerine yapıcı kullanılarak ICloneable için benzer bir yaklaşım vardır.

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

kopyayı yaptığınız aşağıdaki kütüphaneye ihtiyacınız olacak

using System.Linq

System.Linq yerine bir for döngüsü de kullanabilirsiniz, ancak Linq bunu özlü ve temiz yapar. Benzer şekilde, diğer cevapların önerdiği gibi yapabilir ve uzatma yöntemleri vb. Yapabilirsiniz, ancak bunların hiçbiri gerekli değildir.

Aşağıdaki kod, minimum değişiklik içeren bir listeye aktarılmalıdır.

Temelde, her ardışık döngü ile daha geniş bir aralıktan yeni bir rastgele sayı ekleyerek çalışır. Zaten aynı veya ondan daha yüksek olan sayılar varsa, bu rastgele sayıları bir yukarı kaydırın, böylece yeni daha büyük rastgele dizin aralığına aktarın.

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

Başka bir şey: yansıma kullanabilirsiniz. Bunu düzgün bir şekilde önbelleğe alırsanız, 5.000 saniyede 1.000.000 nesneyi (ne yazık ki iç nesnelerle 16.4 saniye) klonlar.

[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 sınıfını kullanarak basit bir şekilde ölçtüm.

 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;

SONUÇ: PersonInstance - 16.4 iç nesnesi ile PersonInstance = null - 5.6

CopyFactory, ifade kullanımı da dahil olmak üzere onlarca testimin olduğu test sınıfım. Bunu başka bir biçimde bir uzantıda ya da her neyse uygulayabilirsiniz. Önbelleğe almayı unutmayın.

Serileştirmeyi henüz test etmedim, ancak bir milyon sınıfla yapılan bir iyileşmeden şüphe ediyorum. Hızlı bir şekilde protobuf / newton deneyeceğim.

PS: basitlik okumak amacıyla, ben sadece burada otomatik mülkiyet kullandım. FieldInfo ile güncelleyebilirim, ya da bunu kendi başınıza kolayca uygulamanız gerekir.

Son zamanlarda DeepClone fonksiyonu ile Protokol Tamponları serileştiricisini test ettim . Bir milyon basit nesnede 4.2 saniye kazanır, ancak iç nesneler söz konusu olduğunda, 7.4 saniye ile kazanır.

Serializer.DeepClone(personList);

Hepsini kapa Özet: Sınıflara erişiminiz yoksa, bu yardımcı olacaktır. Aksi takdirde, nesnelerin sayısına bağlıdır. Sanırım 10.000 nesneye kadar yansımayı kullanabilirsiniz (belki biraz daha az), ancak bundan daha fazlası için Protokol Tamponları serileştirici daha iyi performans gösterecektir.

Bir JSON serileştirici ve serisini kaldırıcı kullanarak C # içindeki nesneleri klonlamanın basit bir yolu vardır.

Bir uzantı sınıfı oluşturabilirsiniz:

using Newtonsoft.Json;

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

Klonlamak ve itiraz etmek için:

obj clonedObj = originalObj.jsonCloneObject;