浅谈C#在unity应用中的工厂模式

文章目录

    • 前言
    • 简单工厂模式
    • 工厂方法模式
    • 抽象工厂模式
    • Unity实战

前言

工厂模式是一种创建型设计模式,它提供了一种将对象的实例化过程封装起来的方法,使得客户端代码不必直接依赖于具体类。这有助于降低代码的耦合度,提高代码的可维护性和可扩展性。在C#中,有三种常见的工厂模式:简单工厂模式工厂方法模式抽象工厂模式。下面详细解释这三种工厂模式。


简单工厂模式

简单工厂模式是最基本的工厂模式,它通过一个工厂类来创建对象。客户端只需要知道要创建的产品的类型,而不需要知道具体的实现类。

  • 首先定义一个抽象产品类。该类主要定义了产品的共有属性和方法,用于子类继承和实现。
public abstract class Car
{
    public abstract void GetName();

    public void Refuel()
    {
        Console.WriteLine("汽车加油");
    }
}
  • 其次定义每个产品的具体实现子类。该类实现并继承自抽象类,如需增加产品可直接创建新的子类并继承自抽象类即可。
public class FordCar: Car
{
    public override void GetName()
    {
        Console.WriteLine("我是福特汽车");
    }
}

public class HondaCar: Car
{
    public override void GetName()
    {
        Console.WriteLine("我是本田汽车");
    }
}
  • 然后定义核心类,即工厂类。该类通过创建了一个枚举类型参数来选择需要创建的产品实例。
public class CarFactory
{
    public static Car CreateCar(CarType carType)
    {
        switch (carType)
        {
            case CarType.FordCar:
                return new FordCar();
                break;
            case CarType.HondaCar:
                return new HondaCar();
                break;
            default:
                break;
        }
        return null;
    }

    public enum CarType
    {
        FordCar,
        HondaCar
    }
}
  • 最后客户端调用。
class Program
{
    static void Main(string[] args)
    {
        //通过CarFactory产品工厂创建了FordCar产品实例
        Car car = CarFactory.CreateCar(CarFactory.CarType.FordCar);
        car.GetName();

        //通过CarFactory产品工厂创建了HondaCar产品实例
        car = CarFactory.CreateCar(CarFactory.CarType.HondaCar);
        car.GetName();
        car.Refuel();
    }
}

对于客户端来说,其去除了与具体产品之间的依赖。

简单工厂模式的缺点主要就是违背开闭原则


工厂方法模式

这是一种更高级的工厂模式,它通过抽象接口或基类中的工厂方法来创建对象。

具体实现由子类负责,因此更加灵活。这种设计方式有利于实现开闭原则,即对扩展开放,对修改封闭

  • 抽象产品类:
public abstract class Car
{
    public abstract void GetName();

    public void Refuel()
    {
        Console.WriteLine("汽车加油");
    }
}
  • 具体产品类:
public class FordCar: Car
{
    public override void GetName()
    {
        Console.WriteLine("我是福特汽车");
    }
}

public class HondaCar: Car
{
    public override void GetName()
    {
        Console.WriteLine("我是本田汽车");
    }
}
  • 抽象工厂:
public abstract class CarFactory
{
    public abstract Car CreateCar();
}
  • 具体产品工厂:
public class FordCarFactory: CarFactory
{
    public override Car CreateCar()
    {
        return new FordCar();
    }
}

public class HondaCarFactory: CarFactory
{
    public override Car CreateCar()
    {
        return new HondaCar();
    }
}
  • 客户端调用:
class Program
{
    static void Main(string[] args)
    {
        //创建一个汽车工厂,只负责生产福特汽车产品
        CarFactory carFactory = new FordCarFactory();
        //在福特汽车工厂中生产一个福特汽车产品
        Car car = carFactory.CreateCar();
        car.GetName();

        //创建一个汽车工厂,只负责生产本田汽车产品
        carFactory = new HondaCarFactory();
        //在本田汽车工厂中生产一个本田汽车产品
        car = carFactory.CreateCar();
        car.GetName();
        //汽车加油
        car.Refuel();
    }
}

抽象工厂模式

抽象工厂模式提供一个接口,用于创建相关或依赖对象的家族,而不需要指定具体类。它是工厂方法模式的推广,不仅仅创建一个对象,而是创建一系列相关的对象。

  • 抽象产品类,有多少个不同产品就创建多少个抽象产品类。实例中创建了两种产品,即汽车和轮胎。
public abstract class Car
{
    public abstract void GetName();

    public void Refuel()
    {
        Console.WriteLine("汽车加油");
    }
}
public abstract class Tire
{
    public abstract void GetName();
}
  • 具体产品类,不同产品继承不同抽象类。实例中定义了两种汽车和两种轮胎,汽车为一个产品等级,轮胎是另外一个产品等级。
public class FordCar: Car
{
    public override void GetName()
    {
        Console.WriteLine("我是福特汽车");
    }
}

public class HondaCar: Car
{
    public override void GetName()
    {
        Console.WriteLine("我是本田汽车");
    }
} 

public class FordTire: Tire
{
    public override void GetName()
    {
        Console.WriteLine("我是福特轮胎。");
    }
}

public class HondaTire: Tire
{
    public override void GetName()
    {
        Console.WriteLine("我是本田轮胎。");
    }
}
  • 抽象工厂类,有多少个系列就可以创建多少个抽象工厂类。
public abstract class CarFactory
{
    //生产汽车
    public abstract Car CreateCar();
    //生产轮胎
    public abstract Tire CreateTire();
}
  • 具体工厂类,同一系列可以创建多个具体的工厂,负责同一系列下的不同产品出的创建。
public class FordCarFactory: CarFactory
{
    public override Car CreateCar()
    {
        return new FordCar();
    }

    public override Tire CreateTire()
    {
        return new FordTire();
    }
}

public class HondaCarFactory: CarFactory
{
    public override Car CreateCar()
    {
        return new HondaCar();
    }

    public override Tire CreateTire()
    {
        return new HondaTire();
    }
}
  • 客户端调用:
class Program
{
    static void Main(string[] args)
    {
        //首先创建一个汽车工厂
        CarFactory carFactory = new FordCarFactory();
        //然后对应工厂中生产出对应的不同产品。
        Car car = carFactory.CreateCar();
        car.GetName();
        Tire tire = carFactory.CreateTire();
        tire.GetName();

        carFactory = new HondaCarFactory();
        car = carFactory.CreateCar();
        car.GetName();
        tire = carFactory.CreateTire();
        tire.GetName();
    }
}

Unity实战

https://dingxiaowei.cn/2017/05/14/

你可能感兴趣的:(Unity,c#,unity,开发语言,工厂模式,设计模式)