factory pattern design c#

¿Cuál es el método que hace MemberwiseClone()?

Question

Estoy confundido con este código a continuación,

Developer devCopy = (Developer)dev.Clone();

Clone el método de Developer Class solo creando un clon de Employee, y luego cómo el desarrollador obtiene otro clon de desarrollador.

public abstract class Employee
{
public abstract Employee Clone();
public string Name { get; set; }
public string Role { get; set; }
}
public class Typist : Employee
{
public int WordsPerMinute { get; set; }
public override Employee Clone()
{
return (Employee)MemberwiseClone();
}
public override string ToString()
{
return string.Format("{0} - {1} - {2}wpm", Name, Role, WordsPerMinute);
}
}
public class Developer : Employee
{
public string PreferredLanguage { get; set; }
public override Employee Clone()
{
return (Employee)MemberwiseClone();
}
public override string ToString()
{
return string.Format("{0} - {1} - {2}", Name, Role, PreferredLanguage);
}
}
Developer dev = new Developer();
dev.Name = "Bob";
dev.Role = "Team Leader";
dev.PreferredLanguage = "C#";
Developer devCopy = (Developer)dev.Clone();
devCopy.Name = "Sue";
Console.WriteLine(dev);
Console.WriteLine(devCopy);
/* OUTPUT
Bob - Team Leader - C#
Sue - Team Leader - C#
*/
Typist typist = new Typist();
typist.Name = "Kay";
typist.Role = "Typist";
typist.WordsPerMinute = 120;
Typist typistCopy = (Typist)typist.Clone();
typistCopy.Name = "Tim";
typistCopy.WordsPerMinute = 115;
Console.WriteLine(typist);
Console.WriteLine(typistCopy);
/* OUTPUT
Kay - Typist - 120wpm
Tim - Typist - 115wpm
*/

Answer 1

La función MemberwiseClone crea un nuevo objeto cuyos campos son copias bit a bit de aquellos en la estructura original. Es una parte necesaria de cualquier clase heredable que permite la clonación sin el uso de Reflection o serialización, pero es solo una pequeña parte del rompecabezas general.

Si desea permitir la clonación dentro de una clase heredable, debe definir un método de clonación de protected virtual T BaseClone<T>() ; la clase de nivel base que desciende de Object debe llamar a base.MemberwiseClone ; todas las otras clases deben usar base.BaseClone<T> para obtener la nueva instancia y luego reemplazar cualquier campo clonable mutable con clones de los que están en el objeto original.

También recomendaría definir las siguientes interfaces:

interface ISelf<out T> {T Self();}
interface ICloneable<out T> : ISelf<T> {T Clone();}

Eso permitirá situaciones en las que una clase puede tener algunos descendientes que pueden clonarse y otros que no. Aquellos que pueden ser clonados pueden exponer los métodos públicos de clonación (que deben encadenarse a BaseClone<theirOwnType> ). Los métodos que necesitan derivados clonables del tipo base pueden usar parámetros del tipo ICloneable<theBaseType> ; esto les permitirá aceptar cualquier derivado clonable del tipo base, incluso si no todos los derivados comparten una clase base común.

Answer 2

Porque el método MemberwiseClone() hace esto por usted. Ver la documentación

El método MemberwiseClone crea una copia superficial creando un nuevo objeto y luego copiando los campos no estáticos del objeto actual al nuevo objeto. Si un campo es un tipo de valor, se realiza una copia bit por bit del campo. Si un campo es un tipo de referencia, la referencia se copia pero el objeto referido no; por lo tanto, el objeto original y su clon se refieren al mismo objeto.

Cada vez que veas un método que no entiendes, puedes rastrear quién lo ha declarado (en Visual Studio, supongo) y, a su vez, ver su documentación. Eso hace las cosas bastante obvias la mayor parte del tiempo.