Réflexion ou clonage() C#

Question

Quand, en général, devrais-je utiliser des méthodes de reflet par rapport aux clones (peu profonds)?

Si toutes mes classes ont des constructeurs blanc utilise la réflexion bien, ou est-il une meilleure pratique d'écrire

Clone() 
{ 
    return new MyClass(); 
} 

méthodes pour les classes qui en ont besoin?

Je peux voir que la méthode Clone est plus sécurisée, car elle peut être vérifiée au moment de la compilation, mais laquelle est plus rapide, et quand est-il préférable d'utiliser la réflexion?

---

Mise à jour. Je ne cherche pas de solution à un problème particulier, mais plutôt d'apprendre plus de théorie pour comprendre comment aborder des problèmes de cette nature. Cependant, pour le mettre dans un contexte, je fais un jeu, et je rencontre régulièrement ce problème. Par exemple, le jeu permet à l'utilisateur de "placer" certains objets. Lorsque vous cliquez plusieurs fois, le jeu doit créer plusieurs instances (d'une sous-classe inconnue). Je suis venu avec trois solutions:

a) Avoir le menu qui sélectionne l'objet que vous allez placer un type, et utiliser Reflection pour générer ce type à plusieurs reprises.

b) Faites en sorte que le menu contienne une instance de l'objet et utilisez Reflection pour créer de nouvelles instances. (Cela peut maintenant être remplacé par MemberwiseClone)

c) Avoir le menu contenant une instance de l'objet, et utiliser une méthode Clone pour créer de nouvelles instances après que le premier est placé.

Je suppose que C est le meilleur, mais je veux comprendre pourquoi.

La réponse du modèle que je suis à la recherche est le long des lignes de ce (s'il vous plaît développer, corriger et compléter le cas échéant): Méthode

A « Clone » va généralement faire plus que simplement appeler nouvelle() que vous indiquer dans votre question; il copiera certaines ou toutes les propriétés de l'instance qu'il clone. Un clone peu profond copie un nombre limité de propriétés, et un clone profond les copie toutes.

Si vous avez simplement besoin de créer une nouvelle instance d'une classe particulière, il est préférable d'utiliser Object.MemberwiseClone(). Vous devez utiliser des méthodes de clonage chaque fois que vous avez une référence à une instance, où vous savez que cette instance aura l'attribut ICloneable.

Activator.CreateInstance() doit être réservé à l'utilisation uniquement lorsque vous n'avez pas de référence à une instance, par exemple lorsque vous avez chargé des informations de classe à partir d'un fichier texte ou XXXXXXX. La manière d'aborder le problème de la création de nouvelles instances d'une classe inconnue consiste toujours à tenter de le faire via des méthodes de type compilateur, par exemple (par exemple Cloning), et d'utiliser Reflection uniquement lorsque cela est totalement impossible.

Comme un résumé des avantages et des inconvénients:

Clone/MemberwiseClone

Plus: Vérifié comme typesafe au moment de la compilation, ne plantera pas votre programme lors de l'exécution, plus rapide lors de l'exécution Inconvénients: ne peut pas toujours être utilisé

réflexion

Avantages/inconvénients: En face ci-dessus.

Answer 1

Si vous vraiment voulez une copie superficielle alors vous pouvez très bien utiliser Object.MemberwiseClone et implémenter l'interface ICloneable.

public class Model : ICloneable 
{ 
    public object Clone() 
    { 
     return MemberwiseClone(); 
    } 
} 

Vous pouvez utiliser la réflexion pour effectuer une copie superficielle si vous le souhaitez vraiment. Je comprends qu'il est avantageux car il est automatisé et peut être étendu pour fournir une copie profonde. Cependant, la réflexion est plus lente que Object.MemberwiseClone() et n'est pas autorisée dans les environnements d'approbation partielle. C'est aussi plus de code à implémenter au départ. Read more here.

Answer 2

Pour créer une nouvelle instance d'une classe:

MyClass obj = new MyClass(); 

Pour cloner une instance:

MyClass clone = obj.Clone(); 

Si vous voulez faire de votre classe Cloneable vous devez implémenter l'interface ICloneable:

public class MyClass : ICloneable 
{ 
    public MyClass Clone() 
    { 
     MyClass clone = new MyClass(); 
     // Copy property values to clone-instance. 
     return clone; 
    } 
} 

Je n'arrive pas à comprendre pourquoi vous voulez impliquer Reflection dans la création de nouvelles instances.