概述
student s=new student();
student s1=new student();
student s2=new student();
C#通过this.MemberwiseClone()实现原型模式
/// <summary>
/// //原型抽象类
/// </summary>
public abstract class StudentPrototype
{
public string Name { get; }
public StudentPrototype(string name)
{
Name=name;
}
public abstract StudentPrototype Clone();
}
/// <summary>
/// 学生类继承原型抽象类 并重写Clone();
/// </summary>
public class Student : StudentPrototype
{
public Student(string name) : base(name)
{
}
public override StudentPrototype Clone()
{
//浅拷贝
//值类型成员:全都复制一份,并且搞一份新的。
//引用类型:只是复制其引用,并不复制其对象。
return (StudentPrototype)this.MemberwiseClone();
}
}
Console.WriteLine("原型设计模式");
Student student=new Student("mhg");
Student student1=(Student)student.Clone();
Console.WriteLine(student.GetHashCode());
Console.WriteLine(student1.GetHashCode());
Console.WriteLine(student1.Name);
C#自己继承ICloneable实现原型模式
public class Teacher:ICloneable
{
public Teacher(string name)
{
Name=name;
}
public string Name { get; }
public object Clone()
{
return this.MemberwiseClone();
}
}
Console.WriteLine("C#自己继承ICloneable");
Teacher teacher=new Teacher("mhg2");
Teacher teacher2=(Teacher)teacher.Clone();
Console.WriteLine(teacher.GetHashCode()); Console.WriteLine(teacher2.GetHashCode()); Console.WriteLine(teacher2.Name);
public class Teacher : ICloneable
{
public string? Name { get; set; }
public MyStudent? MyStudent { get; set; }
public object Clone()
{
return this.MemberwiseClone();
}
public void Show()
{
Console.WriteLine($"Teacher:{Name}");
Console.WriteLine($"MyStudent name:{MyStudent.Name}");
Console.WriteLine($"MyStudent Age:{MyStudent.Age}");
}
}
public class MyStudent
{
public string Name { get; set; }
public string Age { get; set; }
}
看下执行结果
通过原型伪深拷贝实现
public class Teacher : ICloneable
{
public string? Name { get; set; }
public MyStudent? MyStudent { get; set; }
public Teacher()
{
MyStudent=new MyStudent();
}
private Teacher(MyStudent myStudent)
{
MyStudent=(MyStudent)myStudent.Clone();
}
public object Clone()
{
//在创建新对象的时候把工作经验这个引用类型也复制一份
Teacher teacher1 = new Teacher(MyStudent)
{
Name = Name
};
return teacher1;
//如果依然调用this.MemberwiseClone();引用类型,就永远不可能被复制一份新的
//return this.MemberwiseClone(); //这种写法只能拷贝值类型
}
public void Show(string objectName)
{
Console.WriteLine($"-------------{objectName}-start----------------");
Console.WriteLine($"{objectName}:{Name}");
Console.WriteLine($"MyStudent-name:{MyStudent.Name}");
Console.WriteLine($"MyStudent-Age:{MyStudent.Age}");
Console.WriteLine($"-------------{objectName}-end----------------\r\n");
}
}
public class MyStudent:ICloneable
{
public string Name { get; set; }
public string Age { get; set; }
public object Clone()
{
return this.MemberwiseClone();
}
}
来看看执行结果
通过上述代码运行可以看出,teacher1、teacher2、teacher3几个对象的创建...最后不仅把值类型全部复制了一份新的,引用类型也复制了一份对象,不再是复制其引用了。
目前这种原型创建还只是伪深拷贝,如果在MyStudent类中在出现一个引用类型,那么就需要使用递归。这种方式显而易见是有问题的,如果要真正的实现深拷贝,需要通过反射和序列化来实现.