C# Language
IClonable
Recherche…
Syntaxe
- object ICloneable.Clone () {return Clone (); } // Implémentation privée de la méthode d'interface qui utilise notre fonction publique personnalisée Clone ().
- public Foo Clone () {retourne le nouveau Foo (this); } // La méthode de clone publique doit utiliser la logique du constructeur de copie.
Remarques
Le CLR requiert un object Clone() définition de méthode object Clone() qui n'est pas sûr pour le type. Il est courant de remplacer ce comportement et de définir une méthode sécurisée de type qui renvoie une copie de la classe contenant.
Il appartient à l'auteur de décider si le clonage ne signifie qu'une copie superficielle ou une copie profonde. Pour les structures immuables contenant des références, il est recommandé de faire une copie en profondeur. Pour les classes qui sont elles-mêmes des références, il est probablement bon d'implémenter une copie superficielle.
REMARQUE: En C# une méthode d'interface peut être implémentée en privé avec la syntaxe indiquée ci-dessus.
Implémenter ICloneable dans une classe
Implémenter ICloneable dans une classe avec une torsion. Exposez un type sécurisé Clone() et implémentez l' object Clone() privé.
public class Person : ICloneable
{
// Contents of class
public string Name { get; set; }
public int Age { get; set; }
// Constructor
public Person(string name, int age)
{
this.Name=name;
this.Age=age;
}
// Copy Constructor
public Person(Person other)
{
this.Name=other.Name;
this.Age=other.Age;
}
#region ICloneable Members
// Type safe Clone
public Person Clone() { return new Person(this); }
// ICloneable implementation
object ICloneable.Clone()
{
return Clone();
}
#endregion
}
Plus tard pour être utilisé comme suit:
{
Person bob=new Person("Bob", 25);
Person bob_clone=bob.Clone();
Debug.Assert(bob_clone.Name==bob.Name);
bob.Age=56;
Debug.Assert(bob.Age!=bob.Age);
}
Notez que changer l'âge de bob ne change pas l'âge de bob_clone . En effet, la conception utilise le clonage au lieu d’attribuer des variables (de référence).
Implémenter ICloneable dans une structure
L'implémentation d'ICloneable pour une structure n'est généralement pas nécessaire car les structs font une copie membre avec l'opérateur d'affectation = . Mais la conception peut nécessiter l'implémentation d'une autre interface qui hérite d' ICloneable .
Une autre raison serait que la structure contienne un type de référence (ou un tableau) nécessitant une copie également.
// Structs are recommended to be immutable objects
[ImmutableObject(true)]
public struct Person : ICloneable
{
// Contents of class
public string Name { get; private set; }
public int Age { get; private set; }
// Constructor
public Person(string name, int age)
{
this.Name=name;
this.Age=age;
}
// Copy Constructor
public Person(Person other)
{
// The assignment operator copies all members
this=other;
}
#region ICloneable Members
// Type safe Clone
public Person Clone() { return new Person(this); }
// ICloneable implementation
object ICloneable.Clone()
{
return Clone();
}
#endregion
}
Plus tard pour être utilisé comme suit:
static void Main(string[] args)
{
Person bob=new Person("Bob", 25);
Person bob_clone=bob.Clone();
Debug.Assert(bob_clone.Name==bob.Name);
}