Profonde clonage des objets

Je voulais un cloneur pour des objets très simples de la plupart des primitives et des listes. Si votre objet est en dehors de la zone de JSON serializable cette méthode fera l'affaire. Cela ne nécessite aucune modification ou la mise en œuvre des interfaces sur la cloné classe, juste un sérialiseur JSON comme JSON.NET.

public static T Clone<T>(T source)
{
    var serialized = JsonConvert.SerializeObject(source);
    return JsonConvert.DeserializeObject<T>(serialized);
}

Aussi, vous pouvez utiliser cette méthode d'extension

public static class SystemExtension
{
    public static T Clone<T>(this T source)
    {
        var serialized = JsonConvert.SerializeObject(source);
        return JsonConvert.DeserializeObject<T>(serialized);
    }
}

Après beaucoup de lecture sur la plupart des options de lien ici, et les solutions possibles pour cette question, je crois que toutes les options sont résumées assez bien le Ian P's lien (toutes les autres options sont des variantes de celles-ci) et la meilleure solution est fournie par Pedro77's lien sur la question des commentaires.

Donc je vais juste copier les parties pertinentes de ces 2 références ici. De cette façon, nous pouvons avoir:

La meilleure chose à faire pour le clonage des objets en C sharp!

D'abord et avant tout, ce sont toutes nos options:

• Manuellement avec ICloneable, qui est peu profonde et pas Type-Safe
• MemberwiseClone, qui utilise ICloneable
• La réflexion en utilisant Activateur.CreateInstance et récursive MemberwiseClone
• La sérialisation, comme indiqué par johnc préféré répondre
• Langage intermédiaire, dont je n'ai pas d'idée comment fonctionne
• Les Méthodes d'Extension, comme ce personnalisé clone cadre Havard Straden
• Des Arbres D'Expression

La article Rapide Copie en Profondeur par des Arbres d'Expression a également de comparer la performance de clonage par la Sérialisation, la Réflexion et l'Expression des Arbres.

Pourquoi j'ai choisi ICloneable (c'est à dire manuellement)

M. Venkat Subramaniam (lien redondant ici) explique en détail pourquoi.

Tous son article cercles autour d'un exemple qui essaie d'être applicable dans la plupart des cas, à l'aide de 3 objets: Personne, Cerveau et Ville. Nous voulons clone d'une personne, qui aura son propre cerveau, mais la même ville. Vous pouvez soit l'image de tous les problèmes de l'une des méthodes ci-dessus peuvent apporter ou de lire l'article.

C'est ma version légèrement modifiée de sa conclusion:

Copie d'un objet en spécifiant New suivi par le nom de la classe conduit souvent à un code qui n'est pas extensible. À l'aide de clone, l'application d'un prototype de modèle, est une meilleure façon d'atteindre cet objectif. Cependant, l'utilisation de clone car il est prévu en C# (et Java) peut être très problématiques. Il est préférable de fournir une protection (non publique) constructeur de copie et l'invoquer qu'à partir de la méthode clone. Cela nous donne la possibilité de déléguer la tâche de création d'un objet instance d'une classe elle-même, fournissant ainsi de l'extensibilité et également en toute sécurité, la création d'objets à l'aide de la copie protégée constructeur.

Nous espérons que cette mise en œuvre peut mettre les choses au clair:

public class Person : ICloneable
{
    private final Brain brain; //brain is final since I do not want 
                //any transplant on it once created!
    private int age;
    public Person(Brain aBrain, int theAge)
    {
        brain = aBrain; 
        age = theAge;
    }
    protected Person(Person another)
    {
        Brain refBrain = null;
        try
        {
            refBrain = (Brain) another.brain.clone();
            //You can set the brain in the constructor
        }
        catch(CloneNotSupportedException e) {}
        brain = refBrain;
        age = another.age;
    }
    public String toString()
    {
        return "This is person with " + brain;
        //Not meant to sound rude as it reads!
    }
    public Object clone()
    {
        return new Person(this);
    }
    …
}

Maintenant envisager d'avoir une classe de dériver de Personne.

public class SkilledPerson extends Person
{
    private String theSkills;
    public SkilledPerson(Brain aBrain, int theAge, String skills)
    {
        super(aBrain, theAge);
        theSkills = skills;
    }
    protected SkilledPerson(SkilledPerson another)
    {
        super(another);
        theSkills = another.theSkills;
    }

    public Object clone()
    {
        return new SkilledPerson(this);
    }
    public String toString()
    {
        return "SkilledPerson: " + super.toString();
    }
}

Vous pouvez essayer d'exécuter le code suivant:

public class User
{
    public static void play(Person p)
    {
        Person another = (Person) p.clone();
        System.out.println(p);
        System.out.println(another);
    }
    public static void main(String[] args)
    {
        Person sam = new Person(new Brain(), 1);
        play(sam);
        SkilledPerson bob = new SkilledPerson(new SmarterBrain(), 1, "Writer");
        play(bob);
    }
}

La sortie produite sera:

This is person with Brain@1fcc69
This is person with Brain@253498
SkilledPerson: This is person with SmarterBrain@1fef6f
SkilledPerson: This is person with SmarterBrain@209f4e

Observer que, si nous tenons compte du nombre d'objets, le clone mis en œuvre ici gardera un bon de compter le nombre d'objets.

Simple extension de la méthode pour copier toutes les propriétés publiques. Fonctionne pour tous les objets et les ne pas exiger de la classe [Serializable]. Peut être étendu à d'autres niveaux d'accès.

public static void CopyTo( this object S, object T )
{
    foreach( var pS in S.GetType().GetProperties() )
    {
        foreach( var pT in T.GetType().GetProperties() )
        {
            if( pT.Name != pS.Name ) continue;
            ( pT.GetSetMethod() ).Invoke( T, new object[] 
            { pS.GetGetMethod().Invoke( S, null ) } );
        }
    };
}

Je viens de créer CloneExtensions de la bibliothèque projet. Il effectue rapide, profonde clone à l'aide d'une simple affectation des opérations générées par l'Expression de l'Arbre d'exécution de la compilation du code.

Comment l'utiliser?

Au lieu d'écrire votre propre Clone ou Copy méthodes avec un ton d'attributions entre les champs et les propriétés de rendre le programme de le faire pour vous-même, à l'aide de l'Expression de l'Arbre. GetClone<T>() méthode marqué comme méthode d'extension vous permet de simplement appeler votre instance:

var newInstance = source.GetClone();

Vous pouvez choisir ce qui doit être copié à partir de source à newInstance à l'aide de CloningFlags enum:

var newInstance 
    = source.GetClone(CloningFlags.Properties | CloningFlags.CollectionItems);

Ce qui peut être cloné?

• Primitifs (int, uint, byte, double, char, etc.), connu immuable
  types (DateTime, laps de Temps (la Chaîne) et les délégués (y compris
  Action, Func, etc)
• Nullable
• T[] tableaux
• Classes personnalisées et les structures, y compris les classes génériques et des structures.

Suivants de la classe/les membres de la structure sont clonés à l'interne:

• Valeurs de public, pas en lecture seule champs
• Des valeurs de propriétés publiques avec les deux accesseurs get et set
• Les articles de la Collection pour les types de mise en œuvre de ICollection

Comment il est rapide?

La solution est plus rapide que la réflexion, parce que les membres de l'information doit être recueillie une seule fois, avant de GetClone<T> est utilisé pour la première fois pour le type donné T.

Il est également plus rapide que la sérialisation à base de solution lorsque vous clonez plus de couple instances d'un même type T.

et plus...

Lire plus sur générés expressions sur la documentation.

Exemple d'expression de débogage de liste pour List<int>:

.Lambda #Lambda1<System.Func`4[System.Collections.Generic.List`1[System.Int32],CloneExtensions.CloningFlags,System.Collections.Generic.IDictionary`2[System.Type,System.Func`2[System.Object,System.Object]],System.Collections.Generic.List`1[System.Int32]]>(
System.Collections.Generic.List`1[System.Int32] $source,
CloneExtensions.CloningFlags $flags,
System.Collections.Generic.IDictionary`2[System.Type,System.Func`2[System.Object,System.Object]] $initializers) {
.Block(System.Collections.Generic.List`1[System.Int32] $target) {
.If ($source == null) {
.Return #Label1 { null }
} .Else {
.Default(System.Void)
};
.If (
.Call $initializers.ContainsKey(.Constant<System.Type>(System.Collections.Generic.List`1[System.Int32]))
) {
$target = (System.Collections.Generic.List`1[System.Int32]).Call ($initializers.Item[.Constant<System.Type>(System.Collections.Generic.List`1[System.Int32])]
).Invoke((System.Object)$source)
} .Else {
$target = .New System.Collections.Generic.List`1[System.Int32]()
};
.If (
((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(Fields)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(Fields)
) {
.Default(System.Void)
} .Else {
.Default(System.Void)
};
.If (
((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(Properties)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(Properties)
) {
.Block() {
$target.Capacity = .Call CloneExtensions.CloneFactory.GetClone(
$source.Capacity,
$flags,
$initializers)
}
} .Else {
.Default(System.Void)
};
.If (
((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(CollectionItems)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(CollectionItems)
) {
.Block(
System.Collections.Generic.IEnumerator`1[System.Int32] $var1,
System.Collections.Generic.ICollection`1[System.Int32] $var2) {
$var1 = (System.Collections.Generic.IEnumerator`1[System.Int32]).Call $source.GetEnumerator();
$var2 = (System.Collections.Generic.ICollection`1[System.Int32])$target;
.Loop  {
.If (.Call $var1.MoveNext() != False) {
.Call $var2.Add(.Call CloneExtensions.CloneFactory.GetClone(
$var1.Current,
$flags,
$initializers))
} .Else {
.Break #Label2 { }
}
}
.LabelTarget #Label2:
}
} .Else {
.Default(System.Void)
};
.Label
$target
.LabelTarget #Label1:
}

}

ce qui a le même sens comme code c# suivant:

(source, flags, initializers) =>
{
if(source == null)
return null;
if(initializers.ContainsKey(typeof(List<int>))
target = (List<int>)initializers[typeof(List<int>)].Invoke((object)source);
else
target = new List<int>();
if((flags & CloningFlags.Properties) == CloningFlags.Properties)
{
target.Capacity = target.Capacity.GetClone(flags, initializers);
}
if((flags & CloningFlags.CollectionItems) == CloningFlags.CollectionItems)
{
var targetCollection = (ICollection<int>)target;
foreach(var item in (ICollection<int>)source)
{
targetCollection.Add(item.Clone(flags, initializers));
}
}
return target;
}

N'est-il pas tout à fait comme la façon dont vous voulez écrire votre propre Clone méthode pour List<int>?

Le mieux est de mettre en œuvre un méthode d'extension comme

public static T DeepClone<T>(this T originalObject)
{ /* the cloning code */ }

et ensuite l'utiliser n'importe où dans la solution par

var copy = anyObject.DeepClone();

Nous pouvons avoir trois implémentations:

1. Par la Sérialisation (la plus courte de code)
2. Par la Réflexion - 5x plus rapide
3. Par des Arbres d'Expression - 20x plus vite

Tous liés les méthodes de travail bien et ont été profondément testé.

1. Fondamentalement, vous avez besoin pour mettre en œuvre ICloneable interface et ensuite réaliser la structure de l'objet de la copie.
2. Si c'est de la copie en profondeur de tous les membres, vous devez vous assurer (ne concernant pas la solution que vous choisissez) que tous les enfants sont clonable ainsi.
3. Parfois, vous devez être conscient de certaines restrictions au cours de ce processus, par exemple, si vous avez la copie de l'ORM objets de la plupart des cadres de permettre à un seul objet connecté à la session et vous ne DEVEZ PAS faire des clones de cet objet, ou si c'est possible, vous devez vous préoccuper de la session de fixation de ces objets.

Acclamations.

Garder les choses simples et AutoMapper comme d'autres l'ont mentionné, c'est une simple petite bibliothèque à la carte un objet à l'autre... Pour copier un objet à un autre de même type, vous n'avez besoin que de trois lignes de code:

MyType source = new MyType();
Mapper.CreateMap<MyType, MyType>();
MyType target = Mapper.Map<MyType, MyType>(source);

L'objet cible est maintenant une copie de l'objet source.
Pas assez simple? Créer une extension de la méthode à utiliser partout dans votre solution:

public static T Copy<T>(this T source)
{
T copy = default(T);
Mapper.CreateMap<T, T>();
copy = Mapper.Map<T, T>(source);
return copy;
}

À l'aide de la méthode d'extension, les trois lignes deviennent une seule ligne:

MyType copy = source.Copy();

Q. Pourquoi ai-je choisi cette réponse?

• Choisi cette réponse, si vous voulez la vitesse la plus rapide .NET est capable de.
• Ignorer cette réponse si vous le voulez vraiment, vraiment facile méthode de clonage.

En d'autres termes, aller avec une autre réponse, sauf si vous avez un goulot d'étranglement des performances qui doit être réparé, et vous pouvez le prouver avec un profiler.

10x plus rapide que les autres méthodes

La méthode suivante de l'exécution d'une profonde clone est:

• 10x plus rapide que tout ce qui implique la sérialisation/désérialisation;
• Sacrément proche de la vitesse théorique maximale .NET est capable de.

Et la méthode ...

Pour la vitesse ultime, vous pouvez utiliser Imbriquée MemberwiseClone faire une copie en profondeur. Ses presque la même vitesse que la copie d'une valeur de struct, et est beaucoup plus rapide que (un) ou de réflexion (b) la sérialisation (comme décrit dans d'autres réponses sur cette page).

Noter que si vous utilisez Imbriquée MemberwiseClone pour une copie en profondeur, vous devez manuellement mettre en œuvre un ShallowCopy pour chaque niveau imbriqué dans la classe, et un Propriétédeepcopy qui appelle tous dit ShallowCopy méthodes pour créer un clone complet. C'est simple: seulement quelques lignes, au total, voir la démo de code ci-dessous.

Ici est la sortie du code montrant la performance relative de différence pour 100 000 clones:

• 1.08 secondes pour Imbriquée MemberwiseClone sur imbriqués les structures
• De 4,77 secondes pour Imbriquée MemberwiseClone sur les classes imbriquées
• 39.93 secondes pour la Sérialisation/Désérialisation

Utilisant des MemberwiseClone sur une classe presque aussi rapide que la copie d'une struct, et la copie d'un struct est vachement proche de la vitesse théorique maximale .NET est capable de.

Demo 1 of shallow and deep copy, using classes and MemberwiseClone:
Create Bob
Bob.Age=30, Bob.Purchase.Description=Lamborghini
Clone Bob >> BobsSon
Adjust BobsSon details
BobsSon.Age=2, BobsSon.Purchase.Description=Toy car
Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:
Bob.Age=30, Bob.Purchase.Description=Lamborghini
Elapsed time: 00:00:04.7795670,30000000
Demo 2 of shallow and deep copy, using structs and value copying:
Create Bob
Bob.Age=30, Bob.Purchase.Description=Lamborghini
Clone Bob >> BobsSon
Adjust BobsSon details:
BobsSon.Age=2, BobsSon.Purchase.Description=Toy car
Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:
Bob.Age=30, Bob.Purchase.Description=Lamborghini
Elapsed time: 00:00:01.0875454,30000000
Demo 3 of deep copy, using class and serialize/deserialize:
Elapsed time: 00:00:39.9339425,30000000

À comprendre comment faire une copie en profondeur à l'aide de MemberwiseCopy, ici, c'est le projet de démonstration qui a été utilisé pour générer la fois ci-dessus:

//Nested MemberwiseClone example. 
//Added to demo how to deep copy a reference class.
[Serializable] //Not required if using MemberwiseClone, only used for speed comparison using serialization.
public class Person
{
public Person(int age, string description)
{
this.Age = age;
this.Purchase.Description = description;
}
[Serializable] //Not required if using MemberwiseClone
public class PurchaseType
{
public string Description;
public PurchaseType ShallowCopy()
{
return (PurchaseType)this.MemberwiseClone();
}
}
public PurchaseType Purchase = new PurchaseType();
public int Age;
//Add this if using nested MemberwiseClone.
//This is a class, which is a reference type, so cloning is more difficult.
public Person ShallowCopy()
{
return (Person)this.MemberwiseClone();
}
//Add this if using nested MemberwiseClone.
//This is a class, which is a reference type, so cloning is more difficult.
public Person DeepCopy()
{
//Clone the root ...
Person other = (Person) this.MemberwiseClone();
//... then clone the nested class.
other.Purchase = this.Purchase.ShallowCopy();
return other;
}
}
//Added to demo how to copy a value struct (this is easy - a deep copy happens by default)
public struct PersonStruct
{
public PersonStruct(int age, string description)
{
this.Age = age;
this.Purchase.Description = description;
}
public struct PurchaseType
{
public string Description;
}
public PurchaseType Purchase;
public int Age;
//This is a struct, which is a value type, so everything is a clone by default.
public PersonStruct ShallowCopy()
{
return (PersonStruct)this;
}
//This is a struct, which is a value type, so everything is a clone by default.
public PersonStruct DeepCopy()
{
return (PersonStruct)this;
}
}
//Added only for a speed comparison.
public class MyDeepCopy
{
public static T DeepCopy<T>(T obj)
{
object result = null;
using (var ms = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(ms, obj);
ms.Position = 0;
result = (T)formatter.Deserialize(ms);
ms.Close();
}
return (T)result;
}
}

Ensuite, appelez la démo principal:

void MyMain(string[] args)
{
{
Console.Write("Demo 1 of shallow and deep copy, using classes and MemberwiseCopy:\n");
var Bob = new Person(30, "Lamborghini");
Console.Write("  Create Bob\n");
Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
Console.Write("  Clone Bob >> BobsSon\n");
var BobsSon = Bob.DeepCopy();
Console.Write("  Adjust BobsSon details\n");
BobsSon.Age = 2;
BobsSon.Purchase.Description = "Toy car";
Console.Write("    BobsSon.Age={0}, BobsSon.Purchase.Description={1}\n", BobsSon.Age, BobsSon.Purchase.Description);
Console.Write("  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:\n");
Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
Debug.Assert(Bob.Age == 30);
Debug.Assert(Bob.Purchase.Description == "Lamborghini");
var sw = new Stopwatch();
sw.Start();
int total = 0;
for (int i = 0; i < 100000; i++)
{
var n = Bob.DeepCopy();
total += n.Age;
}
Console.Write("  Elapsed time: {0},{1}\n\n", sw.Elapsed, total);
}
{               
Console.Write("Demo 2 of shallow and deep copy, using structs:\n");
var Bob = new PersonStruct(30, "Lamborghini");
Console.Write("  Create Bob\n");
Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
Console.Write("  Clone Bob >> BobsSon\n");
var BobsSon = Bob.DeepCopy();
Console.Write("  Adjust BobsSon details:\n");
BobsSon.Age = 2;
BobsSon.Purchase.Description = "Toy car";
Console.Write("    BobsSon.Age={0}, BobsSon.Purchase.Description={1}\n", BobsSon.Age, BobsSon.Purchase.Description);
Console.Write("  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:\n");
Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);                
Debug.Assert(Bob.Age == 30);
Debug.Assert(Bob.Purchase.Description == "Lamborghini");
var sw = new Stopwatch();
sw.Start();
int total = 0;
for (int i = 0; i < 100000; i++)
{
var n = Bob.DeepCopy();
total += n.Age;
}
Console.Write("  Elapsed time: {0},{1}\n\n", sw.Elapsed, total);
}
{
Console.Write("Demo 3 of deep copy, using class and serialize/deserialize:\n");
int total = 0;
var sw = new Stopwatch();
sw.Start();
var Bob = new Person(30, "Lamborghini");
for (int i = 0; i < 100000; i++)
{
var BobsSon = MyDeepCopy.DeepCopy<Person>(Bob);
total += BobsSon.Age;
}
Console.Write("  Elapsed time: {0},{1}\n", sw.Elapsed, total);
}
Console.ReadKey();
}

À nouveau, notez que si vous utilisez Imbriquée MemberwiseClone pour une copie en profondeur, vous devez manuellement mettre en œuvre un ShallowCopy pour chaque niveau imbriqué dans la classe, et un Propriétédeepcopy qui appelle tous dit ShallowCopy méthodes pour créer un clone complet. C'est simple: seulement quelques lignes, au total, voir la démo de code ci-dessus.

Types de valeur vs Références Types

Remarque que quand il s'agit de clonage d'un objet, il y a une grande différence entre un "struct" et un "classe":

• Si vous avez un "struct", c'est un type de valeur de sorte que vous pouvez le copier, et le contenu sera cloné (mais on aura qu'à faire un clone simple, sauf si vous utilisez les techniques dans ce post).
• Si vous avez un "classe", c'est un type de référence, donc si vous le copiez, tout ce que vous faire est de copier le pointeur. Afin de créer un véritable clone, vous avez à être plus créatifs, et l'utilisation les différences entre les types valeur et les types de références qui crée une autre copie de l'original de l'objet en mémoire.

Voir les différences entre les types valeur et les types de références.

Les sommes de contrôle pour faciliter le débogage

• Clonage des objets de manière incorrecte peut conduire à de très difficile à pin-bas bugs. Dans le code de production, j'ai tendance à mettre en œuvre une somme de contrôle pour vérifier que l'objet a été cloné correctement, et n'a pas été endommagé par une autre référence. Cette somme de contrôle peut être désactivé en mode Release.
• Je trouve cette méthode très utile: souvent, vous ne voulez cloner une partie de l'objet, pas l'ensemble de la chose.

Vraiment utile pour le découplage nombre de threads que de nombreux autres threads

Un excellent cas d'utilisation de ce code est l'alimentation des clones d'une classe imbriquée ou struct dans une file d'attente, pour mettre en œuvre le producteur /consommateur motif.

• Nous pouvons avoir un (ou plus) de threads de la modification d'une catégorie qu'ils détiennent, puis en poussant une copie complète de cette classe dans une ConcurrentQueue.
• Nous avons alors un (ou plus) de threads tirer des copies de ces classes et de traiter avec eux.

Cela fonctionne extrêmement bien dans la pratique, et nous permet de découpler le nombre de threads (les producteurs) à partir d'un ou plusieurs threads (les consommateurs).

Et cette méthode est absolument trop rapide: si nous utilisons des structures imbriquées, c'est 35x plus vite que la sérialisation/désérialisation des classes imbriquées, et nous permet de profiter de tous les threads disponibles sur la machine.

Mise à jour

Apparemment, ExpressMapper est aussi rapide, sinon plus, que le codage à la main comme ci-dessus. Je pourrais l'avoir pour voir comment ils se comparent avec un profiler.

Je l'ai vu mis en œuvre par le biais de la réflexion en tant que bien. Fondamentalement, il y avait une méthode qui permettrait d'itérer sur les membres d'un objet et la manière appropriée de les copier sur le nouvel objet. Quand il atteint les types de référence ou des collections, je pense qu'il a fait un appel récursif sur lui-même. La réflexion est cher, mais il a fonctionné assez bien.

Que je ne pouvais pas trouver un cloneur qui répond à toutes mes exigences dans les différents projets, j'ai créé une profonde cloner qui peuvent être configurés et adaptés aux différentes structures de code au lieu d'adapter mon code pour répondre aux cloneurs exigences. Son obtenu par ajout d'annotations dans le code qui doit être cloné ou que vous venez de laisser le code comme il est d'avoir le comportement par défaut. Il utilise la réflexion, type de caches et est basé sur fasterflect. Le processus de clonage est très rapide pour une énorme quantité de données et d'une haute hiérarchie de l'objet (par rapport à d'autres de réflexion/de sérialisation de base des algorithmes).

https://github.com/kalisohn/CloneBehave

Également disponible comme un package nuget:
https://www.nuget.org/packages/Clone.Behave/1.0.0

Par exemple: Le code suivant deepClone Adresse, mais seulement d'effectuer une copie de la _currentJob champ.

public class Person 
{
[DeepClone(DeepCloneBehavior.Shallow)]
private Job _currentJob;      
public string Name { get; set; }
public Job CurrentJob 
{ 
get{ return _currentJob; }
set{ _currentJob = value; }
}
public Person Manager { get; set; }
}
public class Address 
{      
public Person PersonLivingHere { get; set; }
}
Address adr = new Address();
adr.PersonLivingHere = new Person("John");
adr.PersonLivingHere.BestFriend = new Person("James");
adr.PersonLivingHere.CurrentJob = new Job("Programmer");
Address adrClone = adr.Clone();
//RESULT
adr.PersonLivingHere == adrClone.PersonLivingHere //false
adr.PersonLivingHere.Manager == adrClone.PersonLivingHere.Manager //false
adr.PersonLivingHere.CurrentJob == adrClone.PersonLivingHere.CurrentJob //true
adr.PersonLivingHere.CurrentJob.AnyProperty == adrClone.PersonLivingHere.CurrentJob.AnyProperty //true

J'aime Copyconstructors comme ça:

    public AnyObject(AnyObject anyObject)
{
foreach (var property in typeof(AnyObject).GetProperties())
{
property.SetValue(this, property.GetValue(anyObject));
}
foreach (var field in typeof(AnyObject).GetFields())
{
field.SetValue(this, field.GetValue(anyObject));
}
}

Si vous avez plus de choses à copier les ajouter

Ici une solution rapide et facile qui a fonctionné pour moi sans relais sur la Sérialisation/Désérialisation.

public class MyClass
{
public virtual MyClass DeepClone()
{
var returnObj = (MyClass)MemberwiseClone();
var type = returnObj.GetType();
var fieldInfoArray = type.GetRuntimeFields().ToArray();
foreach (var fieldInfo in fieldInfoArray)
{
object sourceFieldValue = fieldInfo.GetValue(this);
if (!(sourceFieldValue is MyClass))
{
continue;
}
var sourceObj = (MyClass)sourceFieldValue;
var clonedObj = sourceObj.DeepClone();
fieldInfo.SetValue(returnObj, clonedObj);
}
return returnObj;
}
}

MODIFIER:
nécessite

    using System.Linq;
using System.Reflection;

C'est la Façon dont je l'ai utilisé

public MyClass Clone(MyClass theObjectIneededToClone)
{
MyClass clonedObj = theObjectIneededToClone.DeepClone();
}

Suivez ces étapes:

• Définir un ISelf<T> avec un accès en lecture seule Self propriété qui renvoie T, et ICloneable<out T>, qui dérive de ISelf<T> et inclut une méthode T Clone().
• Puis de définir une CloneBase type qui implémente un protected virtual generic VirtualClone casting MemberwiseClone pour le type transmis.
• Chaque type dérivé doit mettre en œuvre VirtualClone par l'appel de la base de méthode clone et ensuite de faire ce qui doit être fait correctement cloner ces aspects du type dérivé dont le parent VirtualClone méthode n'a pas encore traitées.

Pour un maximum de l'héritage de la polyvalence, des classes d'exposer public clonage fonctionnalité doit être sealed, mais dérivent d'une classe de base qui est d'ailleurs identique à l'exception de l'absence de clonage. Plutôt que de passer des variables de l'explicite clonable type, prend un paramètre de type ICloneable<theNonCloneableType>. Cela permettra à une routine qui s'attend à un clonable dérivés de Foo de travailler avec un clonable dérivés de DerivedFoo, mais également permettre la création de non-clonable dérivés de Foo.

Pour cloner votre objet de classe, vous pouvez utiliser l'Objet.MemberwiseClone méthode,

il suffit d'ajouter cette fonction à votre classe :

public class yourClass
{
//...
//...
public yourClass DeepCopy()
{
yourClass othercopy = (yourClass)this.MemberwiseClone();
return othercopy;
}
}

ensuite d'effectuer une profonde indépendant de la copie, il suffit d'appeler le Propriétédeepcopy méthode :

yourClass newLine = oldLine.DeepCopy();

espère que cette aide.

Si votre Objet est un Arbre Serializeable vous pouvez également utiliser quelque chose comme ceci

static public MyClass Clone(MyClass myClass)
{
MyClass clone;
XmlSerializer ser = new XmlSerializer(typeof(MyClass), _xmlAttributeOverrides);
using (var ms = new MemoryStream())
{
ser.Serialize(ms, myClass);
ms.Position = 0;
clone = (MyClass)ser.Deserialize(ms);
}
return clone;
}

être informé que cette Solution est assez facile, mais il n'est pas aussi performante que d'autres solutions peuvent être.

Et assurez-vous que si la Classe se développe, il y aura toujours uniquement les champs cloné, qui par ailleurs sont sérialisés.

Disclaimer: je suis l'auteur de ce forfait.

J'ai été surpris de voir comment les principales réponses à cette question en 2019 toujours utiliser la sérialisation ou de la réflexion.

La sérialisation est limitant (nécessite attributs spécifiques des constructeurs, etc.) et il est très lent

BinaryFormatter nécessite la Serializable attribut, JsonConverter nécessite un constructeur sans paramètre ou d'attributs, ni la poignée de lire que des champs ou des interfaces très bien et les deux sont de 10-30x plus lentement que nécessaire.

Des Arbres D'Expression

Place, vous pouvez utiliser des Arbres d'Expression ou Réflexion.Émettent pour générer le clonage code qu'une seule fois, puis utiliser le code compilé à la place de la lenteur de la réflexion ou de la sérialisation.

Avoir trouver le problème moi-même et ne voyant pas de solution satisfaisante, j'ai décidé de créer un package qui n'est juste que et fonctionne avec tous les types et est presque aussi rapide que la coutume le code écrit.

Vous pouvez trouver le projet sur GitHub: https://github.com/marcelltoth/ObjectCloner

Utilisation

Vous pouvez l'installer à partir de NuGet. Obtenir soit l' ObjectCloner paquet et l'utiliser comme:

var clone = ObjectCloner.DeepClone(original);

ou si vous n'avez pas l'esprit de polluer votre type d'objet avec les extensions ObjectCloner.Extensions ainsi et à écrire:

var clone = original.DeepClone();

Performance

Un simple indice de référence du clonage d'une hiérarchie de classe a montré des performances ~3x plus rapide que l'utilisation de la Réflexion, ~12x plus rapide que Newtonsoft.La sérialisation Json et ~36 fois plus rapides que la très suggéré BinaryFormatter.

Lors de l'utilisation de Marc Gravells protobuf-réseau que votre sérialiseur de la accepté de répondre à des besoins, de légères modifications, comme l'objet à copier ne sera pas attribué à [Serializable] et, par conséquent, n'est pas sérialisable et le Clone-méthode lève une exception.

Je l'ai modifié pour qu'il fonctionne avec protobuf-net:

public static T Clone<T>(this T source)
{
if(Attribute.GetCustomAttribute(typeof(T), typeof(ProtoBuf.ProtoContractAttribute))
== null)
{
throw new ArgumentException("Type has no ProtoContract!", "source");
}
if(Object.ReferenceEquals(source, null))
{
return default(T);
}
IFormatter formatter = ProtoBuf.Serializer.CreateFormatter<T>();
using (Stream stream = new MemoryStream())
{
formatter.Serialize(stream, source);
stream.Seek(0, SeekOrigin.Begin);
return (T)formatter.Deserialize(stream);
}
}

Ce vérifie la présence d'un [ProtoContract] attribut et utilise protobufs propre formateur pour sérialiser l'objet.

C# Extension qui va de soutien pour la "pas ISerializable" types trop.

 public static class AppExtensions
{                                                                      
public static T DeepClone<T>(this T a)
{
using (var stream = new MemoryStream())
{
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
serializer.Serialize(stream, a);
stream.Position = 0;
return (T)serializer.Deserialize(stream);
}
}                                                                    
}

Utilisation

       var obj2 = obj1.DeepClone()