设计模式实战学习笔记（七）：适配器、代理、装饰模式

(十九)适配器模式

适配器模式代码实现

public class DMAdapter:MonoBehaviour
{
    void Start()
    {
        Adapter adapter = new Adapter(new NewPlugin());
        StandardInterface si = adapter;
        si.Request();
    }
}

interface StandardInterface
{
    void Request();
}
class StandardImplementA : StandardInterface
{

    public void Request()
    {
        Debug.Log("使用标准方法实现请求");
    }
}

class Adapter:StandardInterface
{
    private NewPlugin plugin;
    public Adapter(NewPlugin p)
    {
        plugin = p;
    }
    public void Request()
    {
        plugin.SpecificRequest();
    }
}

class NewPlugin
{
    public void SpecificRequest()
    {
        Debug.Log("使用特殊的插件方法实现请求");
    }
}

(二十)代理模式

使用代理模式做性能优化的测试 ：

原有代码不变动，创建新的资源加载代理类，在FactoryManager中将资源工厂改为资源代理工厂

public class ResourcesAssetsProxyFactory : IAssetFactory
{

    private ResourcesAssetFactory mAssetFactory = new ResourcesAssetFactory();
    private Dictionary<string, AudioClip> mAudioClipDict = new Dictionary<string, AudioClip>();
    private Dictionary<string, GameObject> mEffectDict = new Dictionary<string, GameObject>();
    private Dictionary<string, GameObject> mEnemyDict = new Dictionary<string, GameObject>();
    private Dictionary<string, GameObject> mSoldierDict = new Dictionary<string, GameObject>();
    private Dictionary<string, Sprite> mSpritesDict = new Dictionary<string, Sprite>();
    private Dictionary<string, GameObject> mWeaponDict = new Dictionary<string, GameObject>();
    

    public AudioClip LoadAudioClip(string name)
    {
        if (mAudioClipDict.ContainsKey(name))
        {
            return GameObject.Instantiate(mAudioClipDict[name]);
        }
        else
        {
            AudioClip audioClip = mAssetFactory.LoadAudioClip(name);
            mAudioClipDict.Add(name, audioClip);
            return audioClip;
        }
    }

    public GameObject LoadEffect(string name)
    {
        if (mEffectDict.ContainsKey(name))
        {
            return GameObject.Instantiate(mEffectDict[name]);
        }
        else
        {
            GameObject effects = mAssetFactory.LoadAssets(ResourcesAssetFactory.EffectPath + name) as GameObject;
            mEffectDict.Add(name, effects);
            return GameObject.Instantiate(effects);
        }
    }

    public GameObject LoadEnemy(string name)
    {
        if (mEnemyDict.ContainsKey(name))
        {
            return GameObject.Instantiate(mEnemyDict[name]);
        }
        else
        {
            Debug.Log(name);
            GameObject enemy = mAssetFactory.LoadAssets(ResourcesAssetFactory .EnemyPath+ name) as GameObject;
            mEnemyDict.Add(name, enemy);
            return GameObject.Instantiate(enemy);
        }
    }

    public GameObject LoadSoldier(string name)
    {
        if (mSoldierDict.ContainsKey(name))
        {
            return GameObject.Instantiate(mSoldierDict[name]);
        }
        else
        {
            GameObject soldier = mAssetFactory.LoadAssets(ResourcesAssetFactory.SoldierPath + name) as GameObject;
            mSoldierDict.Add(name, soldier);
            return GameObject.Instantiate(soldier);
        }
    }

    public Sprite LoadSprites(string name)
    {
        if (mSpritesDict.ContainsKey(name))
        {
            return GameObject.Instantiate(mSpritesDict[name]);
        }
        else
        {
            Sprite sprites = mAssetFactory.LoadSprites(name);
            mSpritesDict.Add(name, sprites);
            return sprites;
        }
    }

    public GameObject LoadWeapon(string name)
    {
        if (mWeaponDict.ContainsKey(name))
        {
            return GameObject.Instantiate(mWeaponDict[name]);
        }
        else
        {
            GameObject weapon = mAssetFactory.LoadAssets(ResourcesAssetFactory.WeaponPath + name) as GameObject;
            mWeaponDict.Add(name, weapon);
            return GameObject.Instantiate(weapon);
        }
    }
}

FactoryManager:   
 
   public static IAssetFactory assetFactory
    {
        get
        {
            if (mAssetFactory == null)
            {
                mAssetFactory = new ResourcesAssetsProxyFactory();
            }
            return mAssetFactory;
        }
    }

(二十一)装饰模式

装饰模式代码实现

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class DecorationDM : MonoBehaviour
{
    void Start()
    {
        Coffee coffee = new Decaf();

        coffee = coffee.AddDecorator(new Mocha());

        coffee = coffee.AddDecorator(new Mocha());

        coffee = coffee.AddDecorator(new Whip());

        Debug.Log(coffee.Cost());
    }
}

public abstract class Coffee
{

    public abstract double Cost();
    public Coffee AddDecorator(Decorator decorator)
    {
        decorator.coffee = this;
        return decorator;
    }

}

public class Espresso : Coffee
{
    public override double Cost()
    {
        return 2.5;
    }
}

public class Decaf : Coffee
{
    public override double Cost()
    {
        return 2;
    }
}

public class Decorator : Coffee
{
    protected Coffee mCoffee;
    public Coffee coffee { set { mCoffee = value; } }

    public override double Cost()
    {
        return mCoffee.Cost();
    }
}

public class Mocha:Decorator
{
    public override double Cost()
    {
        return mCoffee.Cost() + 0.1;
    }
}

public class Whip : Decorator
{
    public override double Cost()
    {
        return mCoffee.Cost() + 0.5;
    }
}