C#设计模式之适配器模式与装饰器模式的实现

//已有的旧接口,不兼容于现在的系统
    public interface IAmericanElectrictService
    {
        int Get110VElectric();
    }
    
    //adaptee，需要适配的SDK
    public class AmericanElectrictService : IAmericanElectrictService
    {
        public int Get110VElectric()
        {
            Console.WriteLine("美国的电压是110v，只能提供110V的电压");
            return 110;
        }
    }
    
    //已有接口，现在的系统需要使用这个接口
    public interface IChineseElectricService
    {
        int Get220VElectric();
    }
    
    //适配器，采取组合的方式
    //这里是为了适配已有接口，所以实现了这个接口
    public class AdapterPattern : IChineseElectricService
    {
        private readonly IAmericanElectrictService _service;
 
        public AdapterPattern(IAmericanElectrictService service)
        {
            this._service = service;
        }
        public int Get220VElectric()
        {
            var electric = this._service.Get110VElectric();
            Console.WriteLine("劈里啪啦劈里啪啦，经过一番操作，现在电压转换为220V的了");
            return electric + 110;
        }
    }
    
    //使用适配器，将110V电压转换成220V
    public class AdapterRunner : IRunner
    {
        public void Run()
        {
            //实际情况中，adaptee有可能是已有SDK，有可能是interface，通过IOC容器对应具体实现类
            var americanElectric = new AmericanElectrictService();
            var electric = americanElectric.Get110VElectric();
            Console.WriteLine($"获得了{electric}V电压");
            Console.WriteLine("使用适配器");
            var adapter = new AdapterPattern(americanElectric);
            electric = adapter.Get220VElectric();
            Console.WriteLine($"使用适配器后获得了{electric}V电压");
        }
    }
    //输出
    //------------------------------------
    //美国的电压是110v，只能提供110V的电压
    //获得了110V电压
    //使用适配器
    //美国的电压是110v，只能提供110V的电压
    //劈里啪啦劈里啪啦，经过一番操作，现在电压转换为220V的了
    //使用适配器后获得了220V电压

//抽象基础类
public abstract class AbstractStudent
{
    public abstract void Study();
}
 
//具体实现类
public class Student : AbstractStudent
{
    public override void Study()
    {
        Console.WriteLine("我正在学习！！！");
    }
}
 
//基础装饰器，什么也不做
//注意，这里标记为抽象类，此后的装饰器以此为基础
public abstract class BaseDecorator : AbstractStudent
{
    private readonly AbstractStudent _student;
    public BaseDecorator(AbstractStudent student)
    {
        this._student = student;
    }
    //这里使用override还是Virtual取决于AbstractStudent基础类是抽象类还是接口
    public override void Study()
    {
        this._student.Study();
    }
}
 
//前缀装饰器，在调用具体功能前做点什么
 public class PreDecorator : BaseDecorator
{
    public PreDecorator(AbstractStudent student) : base(student)
    {
    }
    public override void Study()
    {
        Console.WriteLine("学习前看会儿小说");
        base.Study();
    }
}
 
//后缀装饰器，在调用具体功能后做点什么
public class NextDecorator : PreDecorator
{
    public NextDecorator(AbstractStudent student) : base(student)
    {
    }
    public override void Study()
    {
        base.Study();
        Console.WriteLine("学习辛苦啦，奖励自己一包辣条");
    }
}
 
//测试代码
public class DecoratorRunner : IRunner
{
    public void Run()
    {
        Console.WriteLine("没有用装饰器的基本功能：");
        var student = new Student();
        student.Study();
        Console.WriteLine();
        
        Console.WriteLine("使用前缀装饰器在基础功能之前做点什么");
        var preDecorator = new PreDecorator(student);
        preDecorator.Study();
        Console.WriteLine();
        
        Console.WriteLine("使用后缀装饰器在前缀装饰器功能之后做点什么");
        //注意：这里传入的前缀装饰器，在前缀装饰器的基础之上做扩展
        var nextDecorator = new NextDecorator(student);
        nextDecorator.Study();
    }
}
 
//输出：  
//没有用装饰器的基本功能：
//我正在学习！！！
//
//使用前缀装饰器在基础功能之前做点什么
//学习前看会儿小说
//我正在学习！！！
//
//使用后缀装饰器在前缀装饰器功能之后做点什么
//学习前看会儿小说
//我正在学习！！！
//学习辛苦啦，奖励自己一包辣条