什么是设计模式？
简单来说，设计模式是处理特定情况的标准解决方案。因此，您可以使用它来节省时间，因此不必重新发明轮子，最重要的是，您可以使用它，因为这是标准的最佳解决方案，并得到所有其他真正的程序员的认可。您需要做的是检查情况并选择最佳且相关的设计模式并对其进行调整以在您的代码中使用。但是请记住不要在任何地方使用它们，有时简单的代码可以更好地完成工作并且不需要过度使用设计模式。
基本上，设计模式主要分为三类：
- 创建型模式
- 结构型模式
- 行为型模式
创建型设计 模式主要关注对象的创建。例如，它们可以使大对象的创建变得容易且可重用。Creational 类别中存在五种不同的模式，具有不同的用法：
- 抽象工厂
- 工厂方法
- 建造者
- 原型
- 单例
抽象工厂
此模式用于创建相关对象系列，因此我们将接口或抽象类作为工厂，它们具有多个通常返回相关类型的方法。
首先，制作一些相关的类型。
public interface ITechCompany
{
void PrintDetail();
}
public interface ICarCompany
{
void PrintDetail();
}
//family #1
public class Asus : ITechCompany
{
public void PrintDetail()
{
Console.WriteLine("i am detail of asus company");
}
}
public class Dell : ITechCompany
{
public void PrintDetail()
{
Console.WriteLine("i am detail of dell company");
}
}
//family #2
public class Benz : ICarCompany
{
public void PrintDetail()
{
Console.WriteLine("i am detail of Benz company");
}
}
public class Audi : ICarCompany
{
public void PrintDetail()
{
Console.WriteLine("i am detail of Audi company");
}
}
模式的第二个实现。
public interface ICompanyFactory
{
ITechCompany CreateTechCompany();
ICarCompany CreateCarCompany();
}
public class CompanyFactoryA : ICompanyFactory
{
public ITechCompany CreateTechCompany()
{
return new Asus();
}
public ICarCompany CreateCarCompany()
{
return new Benz();
}
}
public class CompanyFactoryB : ICompanyFactory
{
public ITechCompany CreateTechCompany()
{
return new Dell();
}
public ICarCompany CreateCarCompany()
{
return new Audi();
}
}
public static class AbstractFactoryExample
{
public static void Test()
{
var factoryA = new CompanyFactoryA();
var carA = factoryA.CreateCarCompany();
var techA = factoryA.CreateTechCompany();
carA.PrintDetail();
techA.PrintDetail();
var factoryB = new CompanyFactoryB();
var carB = factoryB.CreateCarCompany();
var techB = factoryB.CreateTechCompany();
carB.PrintDetail();
techB.PrintDetail();
}
//result :
//i am detail of Benz company
//i am detail of asus company
//i am detail of Audi company
//i am detail of dell company
}
工厂方法
老实说，工厂方法模式就像抽象工厂，但只有一个区别，抽象工厂是一个具有多个工厂方法的对象，您可以使用这种方法具有很高的灵活性。
模式的实现（我们正在使用我们之前声明的系列类型）：
public interface ITechCompanyCreator
{
ITechCompany CreateTechCompany();
}
public class TechCompanyCreatorA : ITechCompanyCreator
{
public ITechCompany CreateTechCompany()
{
return new Asus();
}
}
public class TechCompanyCreatorB : ITechCompanyCreator
{
public ITechCompany CreateTechCompany()
{
return new Dell();
}
}
public static class FactoryMethodExample
{
public static void Test()
{
var creatorA = new TechCompanyCreatorA();
var techA = creatorA.CreateTechCompany();
techA.PrintDetail();
var creatorB = new TechCompanyCreatorB();
var techB = creatorB.CreateTechCompany();
techB.PrintDetail();
}
//result :
//i am detail of Asus company
//i am detail of Dell company
}
建造者模式
此模式用于创建具有许多可能配置的大对象。
public interface IBuilder
{
Contact Build();
}
public class ContactBuilder : IBuilder
{
private readonly Contact _contact = new Contact();
public ContactBuilder WithName(string name)
{
_contact.Name = name;
return this;
}
public ContactBuilder WithFamily(string family)
{
_contact.Family = family;
return this;
}
public ContactBuilder WithAge(int age)
{
_contact.Age = age;
return this;
}
public Contact Build()
{
return _contact;
}
}
public class Contact
{
public string Name { get; set; }
public string Family { get; set; }
public int Age { get; set; }
}
public static class BuilderExample
{
public static void Test()
{
var contact = new ContactBuilder()
.WithName("name")
.WithFamily("family")
.WithAge(10)
.Build();
Console.WriteLine(contact.ToJson());
}
//result :
//{"Name":"name","Family":"family","Age":10}
}
原型模式
此模式用于克隆具有任何复杂性的任何对象，并将克隆与原始对象解耦。
public class Person
{
public string Name { get; set; }
public Family Family { get; set; }
public int Age { get; set; }
//Pattern
public Person ShallowCopy()
{
return (Person) this.MemberwiseClone();
}
public Person DeepCopy()
{
var clone = (Person) this.MemberwiseClone();
clone.Name = new string(Name);
clone.Family = new Family
{
MiddleName = new string(Family.MiddleName),
LastName = new string(Family.LastName)
};
return clone;
}
}
public class Family
{
public string MiddleName { get; set; }
public string LastName { get; set; }
}
public static class PrototypeExample
{
public static void Test()
{
var person = new Person
{
Name = "David",
Family = new Family
{
MiddleName = "Junior",
LastName = "Nolan"
},
Age = 20
};
var shallowCopied = person.ShallowCopy();
var deepCopied = person.DeepCopy();
person.Age = 55;
person.Name = "rookie";
person.Family.LastName = "bishop";
Console.WriteLine(person.ToJson());
Console.WriteLine(shallowCopied.ToJson());
Console.WriteLine(deepCopied.ToJson());
}
//result:
//{"Name":"rookie","Family":{"MiddleName":"Junior","LastName":"bishop"},"Age":55} => person
//{"Name":"David","Family":{"MiddleName":"Junior","LastName":"bishop"},"Age":20} => shallowcopy
//{"Name":"David","Family":{"MiddleName":"Junior","LastName":"Nolan"},"Age":20} => deepcopy
}
单例模式
通过这种模式，我们确保在运行时有一个对象实例，具有一个通用全局访问权限。
public class Singleton
{
private Singleton()
{
}
private static Singleton _instance;
public static Singleton GetInstance()
{
if (_instance == null)
_instance = new Singleton();
return _instance;
}
}
public static class SingletonExample
{
public static void Test()
{
var instance1 = Singleton.GetInstance();
var instance2 = Singleton.GetInstance();
if (instance1.Equals(instance2))
Console.WriteLine("Yes");
else
Console.WriteLine("No");
}
//result:
//Yes
}
好的，到此为止，现在您已经了解了创建模式的基础知识，稍后我将在两篇不同的文章中解释另外两个类别。
