工廠模式是為了客戶端簡化物件的建立過程，使建立與表示分離。

程式碼案例：
在ARPG的技能系統中，因為技能的攻擊範圍不同，一般會有不同的技能選擇器。我們以此為案例實現一個建立技能選擇器的工廠模式。

public interface IAttackSelector
{
    GameObject[] FindTargets ();
}

public class SectorAttackSelector:IAttackSelector
{
    public GameObject[] FindTargets ()
    {
        return new GameObject[]{ new
 
 GameObject("Sector1"),new GameObject("Sector2")};
    }
}

public class CircleAttackSelector:IAttackSelector
{
    public GameObject[] FindTargets ()
    {
        return new GameObject[]{ new GameObject("circle1"),new GameObject("circle2")};
    }
}

不使用工廠模式建立Selector物件：
public class Test:MonoBehaviour
{
    {
        GameObject[] arr1 = CreateAttackSelector ("circle"
 
).FindTargets ();
        foreach (var item in arr1)
            Debug.Log (item.name);

        GameObject[] arr2 = CreateAttackSelector ("sector").FindTargets ();
        foreach (var item in arr2)
            Debug.Log (item.name);
    }

    private IAttackSelector CreateAttackSelector (string selector)
    {
        switch
 
 (selector) 
        {
            case "circle":
                return new CircleAttackSelector ();
            case "sector":
                return new SectorAttackSelector ();
            default :
                return null;
        }
    }
}
如果有多個類建立Selector物件就會導致多次重寫CreateAttackSelector方法，這樣就導致了大量的重複程式碼，維護性就變得極差。
我們做得就是將CreateAttackSelector方法封裝到單獨一個類中。

public class Factory
{
    public static IAttackSelector CreateAttackSelector (string selector)
    {
        switch (selector) 
        {
            case "circle":
                return new CircleAttackSelector ();
            case "sector":
                return new SectorAttackSelector ();
            default :
                return null;
        }
    }
這是我們只要在需要建立Selector的地方通過Factory的CreateAttackSelector方法就可以了。
不需要在客戶端多次重寫CreateAttackSelector。

public class FactoryTest : MonoBehaviour
{

    private void Start ()
    {
        GameObject[] arr1 = Factory.CreateAttackSelector ("circle").FindTargets ();
        foreach (var item in arr1)
            Debug.Log (item.name);

        GameObject[] arr2 = Factory.CreateAttackSelector ("sector").FindTargets ();
        foreach (var item in arr2)
            Debug.Log (item.name);
    }
}
}

這樣似乎實現了程式碼的複用性。但是如果再次出現矩形、菱形等其他型別的選擇器時，就不得不再次修改CreateAttackSelector方法，如果選擇器有幾十種，就會使得switch語句極其龐大。
如何避免出現switch驚悚語句，答案就是使用反射。

public class Factory
{
    public static IAttackSelector CreateAttackSelector (string selectorName)
    {
        Type objType = Type.GetType(selectorName + "AttackSelector");
        return Activator.CreateInstance(objType) as IAttackSelector;
    }
}

工廠模式中就是應對多選一的場景的是簡單工廠，也稱為靜態工廠；還有一種多選多（一個系列）的場景，則使用抽象工廠。

例如：
遊戲中的角色資料、技能資料、任務資料都是動態獲取的。那麼獲取資料的方式就會有多中，可能從XML中獲取，也可能從資料庫中獲取，還有可能從普通檔案中獲取。因此我們就需要根據不同的資料型別建立不同的工廠來從不同的資料型別檔案中獲取資料。

public interface ISkillService
{
    string GetSkillData();
}
public class XMLSkillService:ISkillService
{
    public string GetSkillData ()
    {
        return "Skill";
    }   
}
public class DBSkillService:ISkillService
{
    public string GetSkillData ()
    {
        return "Skill";
    }
}


public interface ICharacterService
{
    string GetCharacterData();
}
public class XMLCharacterService: ICharacterService
{
    public string GetCharacterData ()
    {
        return "Character";
    }
}
public class DBCharacterService: ICharacterService
{
    public string GetCharacterData ()
    {
        return "Character";
    }
}

public interface IFactory
{
    ICharacterService GetCharacterService ();
    ISkillService GetSkillService ();
}
public class XMLFactory:IFactory
{
    public ICharacterService GetCharacterService ()
    {
        return new XMLCharacterService ();
    }

    public ISkillService GetSkillService ()
    {
        return new XMLSkillService ();
    }
}
public class DBFactory:IFactory
{
    public ICharacterService GetCharacterService ()
    {
        return new DBCharacterService ();
    }

    public ISkillService GetSkillService ()
    {
        return new DBSkillService ();
    }
}

public class Test:MonoBehaviour
{
    private void Start()
    {
        ISkillService skillService = new DBFactory ().GetSkillService ();
        skillService.GetSkillData ();
        ICharacterService characterService = new DBFactory ().GetCharacterService ();
        characterService.GetCharacterData ();
    }
}

當出現從File普通檔案中獲取資料時，只需要建立FileFactory工廠類和FileCharacterService和FileSkillService就可以，不需要修改以前的程式碼，符合開閉原則。
1.但是這樣會帶來平行繼承的問題，如果此時增加從伺服器獲取資料就需要再次增加工廠類，使得客戶端呼叫者需記住使用哪個型別的工廠，因為我們希望資料來源來自一個地方，技能和角色資料統一來自XML或者來自資料庫，這樣如果中間修改資料來源，就需要客戶端呼叫地方全部替換為一個系列，這樣的修改對於客戶端而言是比較痛苦的。
2.如果此時增加一個獲取任務資料的方式，就會造成更麻煩的事情，我們必須要修改IFactory介面，增加GetTaskService()的方法。這樣一來所用工廠類都需要修改。
注：抽象工廠類適合解決縱向變化（比如增加File獲取資料方式，不需要修改以前的程式碼），而不適合解決橫向變化（增加獲取任務的方式，需要修改介面，改動較大）。雖然會帶來平行繼承的問題，但實際開發中可能並沒有那麼多平行類，因此抽象工廠還是比較有用的。

有沒好的方式解決平行繼承，切換資料獲取方式不需要修改客戶端程式碼：
那還得使用簡單工廠，但是需要做一下簡單修改：利用傳參的方式，通過switch…case 判斷來建立不同的Service,但是因為switch語句帶有會使程式碼膨脹的風險，所以改用反射，這是簡單工廠的實現方式。

public class FactoryNormal
{
    public static ISkillService CreateSkillService (string type)
    {
        Type objType = Type.GetType (type + "SkillService");
        return Activator.CreateInstance (objType) as ISkillService;
    }

    public static ICharacterService CreateCharacterService (string type)
    {
        Type objType = Type.GetType (type + "CharacterService");
        return Activator.CreateInstance (objType) as ICharacterService;
    }
}

public class Test:MonoBehaviour
    {
        private void Start()
        {
            ISkillService skillService = FactoryNormal.CreateSkillService ("XML");
            print(skillService.GetSkillData ());
            ICharacterService characterService = FactoryNormal.CreateCharacterService ("XML");
            print(characterService.GetCharacterData ());
        }
    }

解決了平行繼承的問題，但是客戶端呼叫比較麻煩，因為需要記住獲取資料的方式。這裡就不能使用傳統的簡單工廠，因為是多選多（一個系列），因此我們應該將type封裝在工廠類中。

public class FactoryNormal
{
    private static string type;

    static FactoryNormal()
    {
        type = Resources.Load<TextAsset> ("Version").text;
    }

    public static ISkillService CreateSkillService ()
    {
        return CreateService<ISkillService>("Skill");
    }

    public static ICharacterService CreateCharacterService ()
    {
        return CreateService<ICharacterService>("Character");
    }

    private static T CreateService<T>(string name) where T:class
    {
        Type objType = Type.GetType (type + name +"Service");
        return Activator.CreateInstance (objType) as T;
    }
}

修改Resources資料夾下Version檔案中內容就可以切換資料獲取方式(“XML”換成“DB”就可以將從XML檔案中獲取資料的方式切為從DB中)；如果增加檔案資料獲取方式，不需要修改Factory類，若果增加任務資料，只需要在Factory類中增加一個CreateTaskService的方法即可，改動相對也比較小。

關於抽象工廠和簡單工廠的對比：（工廠方法模式不再舉例）
靜態（簡單）工廠模式（Switch…case變龐大） 改進：（通過反射解決Switch驚悚現身）

抽象工廠模式（多選多 成系列建立）（平行繼承體系） 改進：（簡單工廠方式實現抽象抽象工場思維，利用反射） 配置注入 設定注入 構造注入

工廠方法 模式（多選一）(工廠實現類增多，平行繼承體系)（廢棄）