C# 設計模式（一）簡單工廠模式（unity演示）

近來打算過一下設計模式那就從簡單工廠模式開始吧。而使用設計模式就是為了提高“可維護”、“可複用”、“可擴充套件”來展開的。工廠模式可分為三類，即：簡單工廠模式、工廠模式和抽象工廠模式。

一、簡單工廠模式

1、簡單工廠模式(Simple Factory Pattern)

又稱為靜態工廠方法(Static Factory Method)模式，它屬於類建立型模式（同屬於建立型模式的還有工廠方法模式，抽象工廠模式，單例模式，建造者模式）。在簡單工廠模式中，可以根據引數的不同返回不同類的例項。工廠類中根據條件決定一個介面由哪個具體產品類來實現（也就是由一個工廠物件來決定建立哪一種產品類的例項）。

簡單工廠模式專門定義一個類來負責建立其他類的例項，被建立的例項通常都具有共同的父類。

2、模式結構

這裡寫圖片描述

從上圖可以看出，簡單工廠模式由三部分組成：具體工廠、具體產品和抽象產品。

工廠類（Creator）角色：擔任這個角色的是簡單工廠模式的核心，含有與應用緊密相關的商業邏輯。工廠類在客戶端的直接呼叫下建立產品物件，它往往由一個具體類實現。工廠類在客戶端的直接控制下（Create方法）建立產品物件。
抽象產品（AbstractProduct）角色：擔任這個角色的類是由簡單工廠模式所建立的物件的父類，或它們共同擁有的介面。抽象產品角色可以用一個介面或者抽象類實現。定義簡單工廠建立的物件的父類或它們共同擁有的介面。可以是一個類、抽象類或介面。
具體產品（ConcreteProduct）角色：簡單工廠模式所建立的任何物件都是這個角色的例項，具體產品角色由一個具體類實現。定義工廠具體加工出的物件。

3、模式動機

使用簡單工廠模式可以將產品的“消費”和生產完全分開，客戶端只需要知道自己需要什麼產品，如何來使用產品就可以了，具體的產品生產任務由具體的工廠類來實現。工廠類根據傳進來的引數生產具體的產品供消費者使用。這種模式使得更加利於擴充套件，當有新的產品加入時僅僅需要在工廠中加入新產品的構造就可以了。

4、例項分析

計算器栗子，如：
這裡寫圖片描述

Operation運算類：

public class Operation
{
    private 
 double _numA = 0;
    private double _numB = 0;

    public double NumA
    {
        get { return _numA; }
        set { _numA = value; }
    }

    public double NumB
    {
        get { return _numB; }
        set { _numB = value; }
    }

    public virtual double GetResult()
    {
        double result = 0;
        return result;
    }
}

加減乘除類

class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumA + NumB;
        return result;
    }
}

class OperationSub : Operation
{
    public override double GetResult()
    {
        double res = 0;
        res = NumB + NumA;
        return res;
    }
}

class OperationMul : Operation
{
    public override double GetResult()
    {
        double res = 0;
        res = NumB * NumA;
        return res;
    }
}

class OperationDiv : Operation
{
    public override double GetResult()
    {
        double result = 0;
        if (NumB !=0)
        {
            result = NumA / NumB;
        }
        return result;
    }
}

工廠類

public class OperationFactory
{
    public static Operation createOperate(string operate)
    {
        Operation oper = null;
        switch (operate)
        {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

呼叫例項，只需要傳入運算子號，工廠就能例項化出合適的物件，通過多型來返回父類的方式獲得了計算結果。

Operation oper;
oper = OperationFactory.createOperate("+");
oper.NumA = 1;
oper.NumB = 2;
double res = oper.GetResult();

那麼後期需要修改運算方式只需修改相應的運算就可以了。如果需要增加運算只需要新增運運算元類，增加工廠類的分支即可。

5、優點

工廠類含有必要的判斷邏輯，可以決定在什麼時候建立哪一個產品類的例項。它提供了專門的工廠類用於建立物件。
無須知道所建立的具體產品類的類名，只需要知道具體產品類所對應的引數即可，對於一些複雜的類名，通過簡單工廠模式可以減少使用者的記憶量。
通過引入配置檔案，可以在不修改任何客戶端程式碼的情況下更換和增加新的具體產品類，在一定程度上提高了系統的靈活性。
當需要引入新的產品是不需要修改客戶端的程式碼，只需要新增相應的產品類並修改工廠類就可以了，所以說從產品的角度上簡單工廠模式是符合“開-閉”原則的。

6、缺點

由於工廠類集中了所有產品建立邏輯，工廠類一般被我們稱作“全能類”或者“上帝類”，因為所有的產品建立他都能完成，這看似是好事，但仔細想想是有問題的。比如全國上下所有的事情都有國家主席一個人幹會不會有問題，當然有！一旦不能正常工作，整個系統都要受到影響。
使用簡單工廠模式將會增加系統中類的個數，在一定程式上增加了系統的複雜度和理解難度。
系統擴充套件困難，一旦新增新產品就不得不修改工廠邏輯，在產品型別較多時，有可能造成工廠邏輯過於複雜，不利於系統的擴充套件和維護。所以說從工廠的角度來說簡單工廠模式是不符合“開-閉”原則的。
簡單工廠模式由於使用了static靜態工廠方法，造成工廠角色無法形成基於繼承的等級結構。

7、適用場景

工廠類負責建立的物件比較少：由於建立的物件較少，不會造成工廠方法中的業務邏輯太過複雜。
只知道傳入工廠類的引數，對於如何建立物件不關心：既不需要關心建立細節，甚至連類名都不需要記住，只需要知道型別所對應的引數。

二、工廠(方法)模式

1、工廠方法模式（Factory Method）

工廠模式又叫工廠方法模式（Factory Method）：是一種常用的物件建立型設計模式,此模式的核心精神是封裝類中不變的部分，提取其中個性化善變的部分為獨立類，通過依賴注入以達到解耦、複用和方便後期維護拓展的目的。它的核心結構有四個角色，分別是抽象工廠、具體工廠、抽象產品、具體產品。

2、工廠方法模式簡介

工廠方法(Factory Method)模式的意義是定義一個建立產品物件的工廠介面，將實際建立工作推遲到子類當中。核心工廠類不再負責產品的建立，這樣核心類成為一個抽象工廠角色，僅負責具體工廠子類必須實現的介面，這樣進一步抽象化的好處是使得工廠方法模式可以使系統在不修改具體工廠角色的情況下引進新的產品。
工廠方法模式是簡單工廠模式的衍生，解決了許多簡單工廠模式的問題。首先完全實現‘開－閉原則’，實現了可擴充套件。其次更復雜的層次結構，可以應用於產品結果複雜的場合。
工廠方法模式對簡單工廠模式進行了抽象。有一個抽象的Factory類（可以是抽象類和介面），這個類將不再負責具體的產品生產，而是隻制定一些規範，具體的生產工作由其子類去完成。在這個模式中，工廠類和產品類往往可以依次對應。即一個抽象工廠對應一個抽象產品，一個具體工廠對應一個具體產品，這個具體的工廠就負責生產對應的產品。
工廠方法模式(Factory Method pattern)是最典型的模板方法模式(Template Method pattern)應用。

3、工廠方法模式角色結構

結構模式如下：
這裡寫圖片描述

抽象工廠(Creator)角色：是工廠方法模式的核心，與應用程式無關。任何在模式中建立的物件的工廠類必須實現這個介面。
具體工廠(Concrete Creator)角色：這是實現抽象工廠介面的具體工廠類，包含與應用程式密切相關的邏輯，並且受到應用程式呼叫以建立產品物件。在上圖中有兩個這樣的角色：BulbCreator與TubeCreator。
抽象產品(Product)角色：工廠方法模式所建立的物件的超型別，也就是產品物件的共同父類或共同擁有的介面。在上圖中，這個角色是Light。
具體產品(Concrete Product)角色：這個角色實現了抽象產品角色所定義的介面。某具體產品有專門的具體工廠建立，它們之間往往一一對應。

4、使用步驟

步驟1：建立抽象工廠類，定義具體工廠的公共介面；
步驟2：建立抽象產品類，定義具體產品的公共介面；
步驟3：建立具體產品類（繼承抽象產品類） & 定義生產的具體產品；
步驟4：建立具體工廠類（繼承抽象工廠類），定義建立對應具體產品例項的方法；
步驟5：外界通過呼叫具體工廠類的方法，從而建立不同具體產品類的例項

5、例項講解

5.1 問題描述

背景：小成有一間塑料加工廠（僅生產A類產品）；隨著客戶需求的變化，客戶需要生產B類產品；
衝突：改變原有塑料加工廠的配置和變化非常困難，假設下一次客戶需要再發生變化，再次改變將增大非常大的成本；
解決方案：小成決定置辦塑料分廠B來生產B類產品；

即工廠方法模式

5.2 使用步驟

步驟1：建立抽象工廠類，定義具體工廠的公共介面

abstract class Factory
{
    public abstract Product Manufacture();
}

步驟2：建立抽象產品類，定義具體產品的公共介面；

abstract class Product
{
    public abstract void Show();
}

步驟3：建立具體產品類（繼承抽象產品類），定義生產的具體產品；

/// <summary>
/// 具體產品A類
/// </summary>
class ProductA : Product
{
    public override void Show()
    {
        Console.WriteLine("生產出了產品A");
    }
}

/// <summary>
/// 具體產品B類
/// </summary>
class ProductB : Product
{
    public override void Show()
    {
        Console.WriteLine("生產出了產品B");
    }
}

步驟4：建立具體工廠類（繼承抽象工廠類），定義建立對應具體產品例項的方法；

/// <summary>
/// 工廠A類 - 生產A類產品
/// </summary>
class FactoryA : Factory
{
    public override Product Manufacture()
    {
        return new ProductA();
    }
}

/// <summary>
/// 工廠B類 - 生產B類產品
/// </summary>
class FactoryB : Factory
{
    public override Product Manufacture()
    {
        return new ProductB();
    }
}

步驟5：外界通過呼叫具體工廠類的方法，從而建立不同具體產品類的例項

//生產工作流程
//客戶要產品A
FactoryA mFactoryA = new FactoryA();
mFactoryA.Manufacture().Show();

//客戶要產品B
FactoryB mFactoryB = new FactoryB();
mFactoryB.Manufacture().Show();

結果

生產出了產品A
生產出了產品B

6、工廠方法模式優點

更符合開-閉原則
新增一種產品時，只需要增加相應的具體產品類和相應的工廠子類即可

簡單工廠模式需要修改工廠類的判斷邏輯

符合單一職責原則
每個具體工廠類只負責建立對應的產品

簡單工廠中的工廠類存在複雜的switch邏輯判斷

不使用靜態工廠方法，可以形成基於繼承的等級結構。

簡單工廠模式的工廠類使用靜態工廠方法

總結：工廠模式可以說是簡單工廠模式的進一步抽象和拓展，在保留了簡單工廠的封裝優點的同時，讓擴充套件變得簡單，讓繼承變得可行，增加了多型性的體現。

7、工廠方法模式缺點

新增新產品時，除了增加新產品類外，還要提供與之對應的具體工廠類，系統類的個數將成對增加，在一定程度上增加了系統的複雜度；同時，有更多的類需要編譯和執行，會給系統帶來一些額外的開銷；
由於考慮到系統的可擴充套件性，需要引入抽象層，在客戶端程式碼中均使用抽象層進行定義，增加了系統的抽象性和理解難度，且在實現時可能需要用到DOM、反射等技術，增加了系統的實現難度。
雖然保證了工廠方法內的對修改關閉，但對於使用工廠方法的類，如果要更換另外一種產品，仍然需要修改例項化的具體工廠類；
一個具體工廠只能建立一種具體產品

8、工廠方法模式適用場景

當一個類不知道它所需要的物件的類時
在工廠方法模式中，客戶端不需要知道具體產品類的類名，只需要知道所對應的工廠即可；
當一個類希望通過其子類來指定建立物件時
在工廠方法模式中，對於抽象工廠類只需要提供一個建立產品的介面，而由其子類來確定具體要建立的物件，利用面向物件的多型性和里氏代換原則，在程式執行時，子類物件將覆蓋父類物件，從而使得系統更容易擴充套件。
將建立物件的任務委託給多個工廠子類中的某一個，客戶端在使用時可以無須關心是哪一個工廠子類建立產品子類，需要時再動態指定，可將具體工廠類的類名儲存在配置檔案或資料庫中。

三、抽象工廠模式

1、抽象工廠模式（Abstract Factory）

前面介紹了工廠方法模式，工廠方法模式是為了克服簡單工廠模式的缺點而設計出來的,簡單工廠模式的工廠類隨著產品類的增加需要增加額外的程式碼），而工廠方法模式每個具體工廠類只完成單個例項的建立,所以它具有很好的可擴充套件性。但是在現實生活中，一個工廠只建立單個產品這樣的例子很少，因為現在的工廠都多元化了，一個工廠建立一系列的產品，如果我們要設計這樣的系統時，工廠方法模式顯然在這裡不適用，然後抽象工廠模式卻可以很好地解決一系列產品建立的問題,這是本專題所要介紹的內容。
抽象工廠模式（Abstract Factory）是圍繞一個超級工廠建立其他工廠。該超級工廠又稱為其他工廠的工廠。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。在抽象工廠模式中，介面是負責建立一個相關物件的工廠，不需要顯式指定它們的類。每個生成的工廠都能按照工廠模式提供物件。

2、抽象工廠模式（Abstract Factory）詳細介紹

這裡首先以一個生活中抽象工廠的例子來實現一個抽象工廠，然後再給出抽象工廠的定義和UML圖來幫助大家更好地掌握抽象工廠模式，同時大家在理解的時候，可以對照抽象工廠生活中例子的實現和它的定義來加深抽象工廠的UML圖理解。

2.1 抽象工廠模式 Abstract Factory）問題描述

下面就以生活中 “絕味” 連鎖店的例子來實現一個抽象工廠模式。例如，絕味鴨脖想在江西南昌和上海開分店，但是由於當地人的口味不一樣，在南昌的所有絕味的東西會做的辣一點，而上海不喜歡吃辣的，所以上海的所有絕味的東西都不會做的像南昌的那樣辣，然而這點不同導致南昌絕味工廠和上海的絕味工廠生成所有絕味的產品都不同，也就是某個具體工廠需要負責一系列產品(指的是絕味所有食物)的建立工作，下面就具體看看如何使用抽象工廠模式來實現這種情況。

2.2 抽象工廠模式 Abstract Factory）具體實現

/// <summary>
/// 抽象工廠類，提供建立兩個不同地方的鴨架和鴨脖的介面
/// </summary>
public abstract class AbstractFactory
{
    // 抽象工廠提供建立一系列產品的介面，這裡作為例子，只給出了絕味中鴨脖和鴨架的建立介面
    public abstract YaBo CreateYaBo();
    public abstract YaJia CreateYaJia();
}

/// <summary>
/// 南昌絕味工廠負責製作南昌的鴨脖和鴨架
/// </summary>
public class NanChangFactory : AbstractFactory
{
    // 製作南昌鴨脖
    public override YaBo CreateYaBo()
    {
        return new NanChangYaBo();
    }
    // 製作南昌鴨架
    public override YaJia CreateYaJia()
    {
        return new NanChangYaJia();
    }
}

/// <summary>
/// 上海絕味工廠負責製作上海的鴨脖和鴨架
/// </summary>
public class ShangHaiFactory : AbstractFactory
{
    // 製作上海鴨脖
    public override YaBo CreateYaBo()
    {
        return new ShangHaiYaBo();
    }
    // 製作上海鴨架
    public override YaJia CreateYaJia()
    {
        return new ShangHaiYaJia();
    }
}

/// <summary>
/// 鴨脖抽象類，供每個地方的鴨脖類繼承
/// </summary>
public abstract class YaBo
{
    /// <summary>
    /// 列印方法，用於輸出資訊
    /// </summary>
    public abstract void Print();
}

/// <summary>
/// 鴨架抽象類，供每個地方的鴨架類繼承
/// </summary>
public abstract class YaJia
{
    /// <summary>
    /// 列印方法，用於輸出資訊
    /// </summary>
    public abstract void Print();
}

/// <summary>
/// 南昌的鴨脖類，因為江西人喜歡吃辣的，所以南昌的鴨脖稍微會比上海做的辣
/// </summary>
public class NanChangYaBo : YaBo
{
    public override void Print()
    {
        Console.WriteLine("南昌的鴨脖");
    }
}

/// <summary>
/// 上海的鴨脖沒有南昌的鴨脖做的辣
/// </summary>
public class ShangHaiYaBo : YaBo
{
    public override void Print()
    {
        Console.WriteLine("上海的鴨脖");
    }
}

/// <summary>
/// 南昌的鴨架
/// </summary>
public class NanChangYaJia : YaJia
{
    public override void Print()
    {
        Console.WriteLine("南昌的鴨架子");
    }
}

/// <summary>
/// 上海的鴨架
/// </summary>
public class ShangHaiYaJia : YaJia
{
    public override void Print()
    {
        Console.WriteLine("上海的鴨架子");
    }
}

下面是呼叫例項：

// 南昌工廠製作南昌的鴨脖和鴨架
AbstractFactory nanChangFactory = new NanChangFactory();
YaBo nanChangYabo = nanChangFactory.CreateYaBo();
nanChangYabo.Print();
YaJia nanChangYajia = nanChangFactory.CreateYaJia();
nanChangYajia.Print();

// 上海工廠製作上海的鴨脖和鴨架
AbstractFactory shangHaiFactory = new ShangHaiFactory();
shangHaiFactory.CreateYaBo().Print();
shangHaiFactory.CreateYaJia().Print();

2.3 抽象工廠模式 (Abstract Factory）的定義和類圖

上面程式碼中都有詳細的註釋，這裡就不再解釋上面的程式碼了，下面就具體看看抽象工廠模式的定義吧（理解定義可以參考上面的實現來加深理解）

抽象工廠模式 Abstract Factory）: 提供一個建立產品的介面來負責建立相關或依賴的物件，而不具體明確指定具體類

抽象工廠允許客戶使用抽象的介面來建立一組相關產品，而不需要知道或關心實際生產出的具體產品是什麼。這樣客戶就可以從具體產品中被解耦。下面通過抽象工模式的類圖來了解各個類中之間的關係：
這裡寫圖片描述

2.4 抽象工廠模式 (Abstract Factory）應對需求變更

看完上面抽象工廠的實現之後，如果 “絕味”公司又想在湖南開一家分店怎麼辦呢？因為湖南人喜歡吃麻辣的，下面就具體看看應用了抽象工廠模式的系統是如何應對這種需求的。

/// <summary>
/// 如果絕味又想開一家湖南的分店時，因為湖南喜歡吃麻的
/// 所以這是有需要有一家湖南的工廠專門製作
/// </summary>
public class HuNanFactory : AbstractFactory
{
    // 製作湖南鴨脖
    public override YaBo CreateYaBo()
    {
        return new HuNanYaBo();
    }

    // 製作湖南鴨架
    public override YaJia CreateYaJia()
    {
        return new HuNanYajia();
    }
}

/// <summary>
/// 湖南的鴨脖
/// </summary>
public class HuNanYaBo : YaBo
{
    public override void Print()
    {
        Console.WriteLine("湖南的鴨脖");
    }
}

/// <summary>
/// 湖南的鴨架
/// </summary>
public class HuNanYajia : YaJia
{
    public override void Print()
    {
        Console.WriteLine("湖南的鴨架子");
    }
}

此時，只需要新增三個類：一個是湖南具體工廠類，負責建立湖南口味的鴨脖和鴨架，另外兩個類是具有湖南口味的鴨脖類和鴨架類。從上面程式碼看出，抽象工廠對於系列產品的變化支援 “開放——封閉”原則（指的是要求系統對擴充套件開放，對修改封閉），擴充套件起來非常簡便，但是，抽象工廠對於新增新產品這種情況就不支援”開放——封閉 “原則，這也是抽象工廠的缺點所在，這點會在後面詳細介紹。

3、抽象工廠模式（Abstract Factory）的分析

抽象工廠模式將具體產品的建立延遲到具體工廠的子類中，這樣將物件的建立封裝起來，可以減少客戶端與具體產品類之間的依賴，從而使系統耦合度低，這樣更有利於後期的維護和擴充套件，這正是抽象工廠模式的優點所在，然而抽象模式同時也存在不足的地方。下面就具體看下抽象工廠的缺點（缺點其實在前面的介紹中以已經涉及了）：
抽象工廠模式很難支援新種類產品的變化。這是因為抽象工廠介面中已經確定了可以被建立的產品集合，如果需要新增新產品，此時就必須去修改抽象工廠的介面，這樣就涉及到抽象工廠類的以及所有子類的改變，這樣也就違背了“開發——封閉”原則。

4、抽象工廠模式（Abstract Factory）適用場景

知道了抽象工廠的優缺點之後，也就能很好地把握什麼情況下考慮使用抽象工廠模式了，下面就具體看看使用抽象工廠模式的系統應該符合那幾個前提：

一個系統不要求依賴產品類例項如何被建立、組合和表達的表達，這點也是所有工廠模式應用的前提；
這個系統有多個系列產品，而系統中只消費其中某一系列產品；
系統要求提供一個產品類的庫，所有產品以同樣的接口出現，客戶端不需要依賴具體實現。

5、.NET中抽象工廠模式實現

抽象工廠模式在實際中的應用也是相當頻繁的，然而在我們.NET類庫中也存在應用抽象工廠模式的類，這個類就是System.Data.Common.DbProviderFactory，這個類位於System.Data.dll程式集中,該類扮演抽象工廠模式中抽象工廠的角色，我們可以用reflector反編譯工具檢視該類的實現：

/// 扮演抽象工廠的角色
/// 建立連線資料庫時所需要的物件集合，
/// 這個物件集合包括有 DbConnection物件（這個是抽象產品類,如絕味例子中的YaBo類）、DbCommand類、DbDataAdapter類，針對不同的具體工廠都需要實現該抽象類中方法，
public abstract class DbProviderFactory
{
    // 提供了建立具體產品的介面方法
    protected DbProviderFactory();
    public virtual DbCommand CreateCommand();
    public virtual DbCommandBuilder CreateCommandBuilder();
    public virtual DbConnection CreateConnection();
    public virtual DbConnectionStringBuilder CreateConnectionStringBuilder();
    public virtual DbDataAdapter CreateDataAdapter();
    public virtual DbDataSourceEnumerator CreateDataSourceEnumerator();
    public virtual DbParameter CreateParameter();
    public virtual CodeAccessPermission CreatePermission(PermissionState state);
}

四、模式應用舉例（unity）

1、簡單工廠模式例項：

抽象產品基類：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/// <summary>
/// 資源管理器基類,抽象產品
/// </summary>
public abstract class ResouceManager
{
    public abstract void LoadConfig(string path);
    public abstract void LoadAsset(string name);
    public abstract void UnLoadResource(bool status);
}

產品例項：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;

/// <summary>
/// UI資源管理器，抽象產品的具體產品
/// </summary>
public class UIResouceManager : ResouceManager
{
    public override void LoadConfig(string path)
    {
        Debug.Log("載入UI的配置檔案");
    }
    public override void LoadAsset(string name)
    {
        Debug.Log("載入UI裡面的資源");
    }
    public override void UnLoadResource(bool status)
    {
        Debug.Log("解除安裝載入的UI資源");
    }
}

產品例項：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;

/// <summary>
/// Audio資源管理器，抽象產品的具體產品
/// </summary>
public class AudioResourceManager : ResouceManager
{
    public override void LoadConfig(string path)
    {
        Debug.Log("載入和音樂有關的配置檔案");
    }
    public override void LoadAsset(string name)
    {
        Debug.Log("載入音樂檔案");
    }
    public override void UnLoadResource(bool status)
    {
        Debug.Log("解除安裝載入的音樂檔案");
    }
}

產品列舉：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


/// <summary>
/// 定義資源列舉型別
/// </summary>
public enum ResourceEnum
{
    None,
    UIResource,
    AudioResouce
}

工廠：

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


/// <summary>
/// 簡單資源工廠類，負責建立UI，Audio等管理器的例項。
/// </summary>
public class ResouceSimpleFactory
{
    // 方式一
    public ResouceManager CreateManager(string type)
    {
        if (type == "UI")
        {
            return new UIResouceManager();
        }
        else if (type == "Audio")
        {
            return new AudioResourceManager();
        }
        else
        {
            return null;
        }
    }
    //方式二
    public ResouceManager CreateManager(ResourceEnum re)
    {
        switch (re)
        {
            case ResourceEnum.UIResource:
                return new UIResouceManager();
            case ResourceEnum.AudioResouce:
                return new AudioResourceManager();
            default:
                return null;
        }
    }
}

客戶端測試：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;


/// <summary>
/// 使用資源管理器的客戶端
/// </summary>
public class ResouceSimpleFactoryClient : MonoBehaviour
{
    ResouceSimpleFactory rf;
    public void Start()
    {
        rf = new ResouceSimpleFactory();
    }
    public void OnGUI()
    {
        if (GUILayout.Button("UI管理器"))
        {
            ResouceManager ui = rf.CreateManager("UI");
            ui.LoadConfig("http:.......");
            ui.LoadAsset("UI...");
            ui.UnLoadResource(false);
        }
        if (GUILayout.Button("Audio管理器"))
        {
            ResouceManager am = rf.CreateManager("Audio");
            am.LoadConfig("http:.....");
            am.LoadAsset("聲音...");
            am.UnLoadResource(false);
        }
    }
}

2、工廠方法模式例項：

工廠方法模式的抽象產品類：

/// <summary>
/// 工廠方法模式的抽象產品類，由具體的產品類繼承實現
/// </summary>
public abstract class ResourceManager
{
    public abstract void LoadConfig(string path);
    public abstract void LoadAsset(string name);
    public abstract void UnLoadResource(bool status);
}

工廠方法模式的抽象工廠：

/// <summary>
/// 簡單方法模式的抽象工廠，由具體工廠來繼承實現
/// </summary>
public abstract class CreatorResourceFactory
{
    public abstract ResourceManager CreateFactory();
}

工廠方法模式的具體產品實現-UI資源管理產品類：

using UnityEngine;

/// <summary>
/// 工廠方法模式抽象產品的具體產品實現-UI資源管理產品類
/// </summary>
public class UIResourceManager : ResourceManager
{
    public override void LoadConfig(string path)
    {
        Debug.Log("載入UI有關的配置檔案");
    }
    public override void LoadAsset(string name)
    {
        Debug.Log("載入UI檔案");
    }
    public override void UnLoadResource(bool status)
    {
        Debug.Log("解除安裝載入的UI檔案");
    }
}

工廠方法模式的具體工廠實現-UI資源管理工廠：

/// <summary>
/// 簡單方法模式裡面的具體產品工廠-UI資源管理工廠
/// </summary>
public class UIResouceManagerFactory : CreatorResourceFactory
{
    public override ResourceManager CreateFactory()
    {
        return new UIResourceManager();
    }
}

工廠方法模式的的具體產品實現-音訊資源管理產品類：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;

/// <summary>
/// 工廠方法模式抽象產品的具體產品實現-音訊資源管理產品類
/// </summary>
public class AudioResouceManager : ResourceManager
{
    public override void LoadConfig(string path)
    {
        Debug.Log("載入和音樂有關的配置檔案");
    }
    public override void LoadAsset(string name)
    {
        Debug.Log("載入音樂檔案");
    }
    public override void UnLoadResource(bool status)
    {
        Debug.Log("解除安裝載入的音樂檔案");
    }
}

工廠方法模式的具體工廠-音訊資源管理工廠：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/// <summary>
/// 簡單方法模式裡面的具體工廠-音訊資源管理工廠
/// </summary>
public class AudioResouceManagerFactory : CreatorResourceFactory
{
    public override ResourceManager CreateFactory()
    {
        return new AudioResouceManager();
    }
}

客戶端測試類：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;

public class ResouceFactoryMethodClient : MonoBehaviour
{
    #region 定義具體產品工廠
    CreatorResourceFactory audioFactory;
    CreatorResourceFactory uiFactory;
    #endregion
    #region 定義具體產品
    AudioResouceManager audioManager;
    UIResourceManager uiManager;
    #endregion
    void Start()
    {
        audioFactory = new AudioResouceManagerFactory();
        uiFactory = new UIResouceManagerFactory();
    }
    void OnGUI()
    {
        if (GUILayout.Button("音樂管理器"))
        {
            audioManager = audioFactory.CreateFactory() as AudioResouceManager;
            audioManager.LoadConfig("http:....");
            audioManager.LoadAsset("聲音...");
            audioManager.UnLoadResource(false);
        }
        
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    C# 設計模式（一）簡單工廠模式（unity演示）
      
							
							
							目錄








  近來打算過一下設計模式那就從簡單工廠模式開始吧。而使用設計模式就是為了提高“可維護”、“可複用”、“可擴充套件”來展開的。工廠模式可分為三類，即：簡單工廠模式、工廠模式和抽象工廠模式。



一、簡單工廠模式



1、簡單工廠模式(S 

  
 

    

    
    C#設計模式（1）——簡單工廠模式
      void   例子   代碼復用   操作   inf   這樣的   man   ger   troy   1.什麽是簡單工廠
　　現實中的工廠負責生產產品，編程中的簡單工廠顧名思義就是一個生產對象的類，它的主要作用是封裝改變。我們在平時的工作必不可免的和各種數據庫打交道，我們就以一個數據庫服務類為例來分 

  
 

    

    
    【設計模式】（一）-簡單工廠模式和策略模式
       
  
  
 前言 
 最近開始和春哥，張鐸 ，銀平討論設計模式，成立了一個小菜變大鳥的小組，每天討論一個模式，並且把這個模式搞懂，每學一個新的模式，再回顧一下之前學的模式。這兩天學了簡單工廠模式和策略模式，發現兩個模式有很多相同之處，下面用商場促銷的例子來對兩個模式總結一下。 
 簡單工廠模式 
 1. 

  
 

    

    
    設計模式（一）簡單工廠模式
      
                先來考慮一道題目：


請用C++、Java、C#或VB.NET任意一種面嚮物件語言實現一個計算器控制檯程式，要求輸入兩個數和運算子號，得到結果。


題目很簡單，我們腦海裡已經有了初步的思路和答案，寫出來可能是這樣的：

class Program
{
 static vo 

  
 

    

    
    設計模式（C#）——簡單工廠模式
       
 
  
  
  
   
   推薦閱讀： 
   
   
    我的CSDN 
    我的部落格園 
    QQ群：704621321 
   
  
       工廠模式主要是為建立物件提供過渡介面 

  
 

    

    
    大話設計模式（一）簡單工廠模式
       
 
  
  
 簡單工廠模式就是解決不同場景下例項化物件的問題。 
 問題場景：做一個簡單的計算器功能，實現加減乘除的功能，要實現這個功能很簡單，但是卻又要使用到面向物件的方法，降低程式的耦合度，符合開閉原則，就沒有想象中那麼簡單，demo如下： 
  
  首先建立一個抽象的父類 Calculate， 

  
 

    

    
    設計模式（四）簡單工廠模式
      spa   電腦   tco   null   繼承   string   我們   實例   tro   
        相關文章 
 設計模式（一）設計六大原則 
設計模式（二）單例模式的七種寫法 
設計模式（三）建造者模式

1.簡單工廠模式簡單介紹



定義

簡單工廠模式屬於創建型模式又叫做靜 

  
 

    

    
    一（1）簡單工廠模式
      ner   log   factory   auto   過多   測試   extend   耦合度   工廠   1 設計模式中經常用到程序設計中的封裝，繼承，多態的思想。不同的設計模式使代碼更加靈活，容易擴展。
2 設計模式中一般都會存在父類的概念，父類一般是抽象類，內部維護的變量，用於子類繼承；維護的 

  
 

    

    
    設計模式學習筆記（二）--簡單工廠模式和工廠模式
      bsp   bubuko   rac   oid   nds   gen   body   ()   pri   老生長談的兩個設計模式了，這裏把這兩個設計模式對比著來總結一下。
什麽是簡單工廠模式？
簡單工廠模式：根據傳入工廠類的參數動態決定要創建哪一個產品類的實例。
UML圖如下（以實現一個計算器為例）： 

  
 

    

    
    設計模式（2）----簡單工廠模式
      只知道   wid   lin   通過   trac   復雜   創建   調用   lvs   說明一下：
簡單工廠模式不屬於23種GOF設計模式之一，我之所以寫出來，是應為簡單工廠模式是工廠模式的基礎，23種中的工廠方法模式是從中衍生的。
簡介：
簡單工廠模式是屬於創建型模式，又叫做靜態工廠方法（St 

  
 

    

    
    常用的軟體設計模式（二）簡單工廠模式
       
 
 剛參加工作的時候，絲毫沒有面向物件的思想，所有分支都使用一堆的if...else...，現在回頭看以前的程式碼，著實low。但是隻要一心想著進步的人，一定是會總結和反省的，為什麼以前的程式碼出現bug這麼難維護，功能擴充套件那麼難，程式碼難得到複用，過了段時間連自己寫的程式碼都不知道什麼意思。都說女 

  
 

    

    
    設計模式（二）簡單工廠模式
       
 
 
 簡單工廠模式： 
 用一個單獨的類來做創造例項的過程。例如加減乘除運算，可以將這些類抽象成一個基類，然後繼承，實現自己的功能，如果有其他的類要建立，只需要新建一個類，在創造例項的類中加一種情況。 
 類圖： 
 選自《大話設計模式》 
 public abstract class Operati 

  
 

    

    
    設計模式學習總結（1）簡單工廠模式、工廠方法模式、抽象工廠模式
      
                設計模式學習

做了幾個專案，發現設計模式的好處還是很多的，這東西就是隻有你真正用到的時候才知道他的好處，否則學了也不知道所以然。所以設計模式學習我認為可以在先進行幾個專案後，再來學習，這樣學習的效果和感受才是最好的。

這次是做一個學習的筆記，內容還是主要以我看的兩本書《大 

  
 

    

    
    大話設計模式--（1）簡單工廠模式
      實現一個計算器控制檯程式，要求輸入兩個數和運算子號，得到結果。 
我的第一反應是和書裡的是一樣的就是向下面這樣寫 
 
 /*
* 要求輸入兩個數和運算子號，得到結果
* */
public class Test {
    public static void main(String []args) thr 

  
 

    

    
    設計模式練習（1）——簡單工廠模式
      
								
								            
							
							
							簡單工廠模式

一、題目： 
使用簡單工廠模式模擬女媧（Nvwa）造人(Person)，如果傳入引數M，則返回一個Man物件，如果傳入引數W。則返回一個物件Woman，用java語言實現該場景。現在需要 

  
 

    

    
    設計模式（2）簡單工廠模式
      
                
定義：簡單工廠模式（Simple Factory Pattern）屬於類的創新型模式，又叫靜態工廠方法模式（Static FactoryMethod Pattern）,是通過專門定義一個類來負責建立其他類的例項，被建立的例項通常都具有共同的父類。
型別：建立類模式
類圖：
 

  
 

    

    
    設計模式-（3）簡單工廠模式（Simple Factory Pattern）
      
							
							
							一、引言 

在面向物件程式設計中, 最通常的方法是一個new操作符產生一個物件例項,new操作符就是用來構造物件例項的。但是在一些情況下, new操作符直接生成物件會帶來一些問題。舉例來說, 許多型別物件的創造需要一系列的步驟: 你可能需要計算或取得物件的初始 

  
 

    

    
    小白學習JavaScript設計模式（1）——簡單工廠模式
      
                前言

本人也是一名小白，自學進入了前端的這個行業，無論是前端也好，後臺也罷，都離不開敲程式碼。我自己在學習的過程中也做過許多專案，前期主要是為了練習基礎，每個專案的程式碼量比不多。後來到了一個公司實習，這是我第一次出來實習工作，之前一直都是沉浸在自己的自學中，根本不知道自己 

  
 

    

    
    設計模式（Java語言）- 簡單工廠模式
      　　簡單工廠模式有稱為靜態工廠模式，屬於設計模式中的建立型模式。簡單工廠模式通過對外提供一個靜態方法來統一為類建立例項。簡單工廠模式的目的是實現類與類之間解耦，其次是客戶端不需要知道這個物件是如何被穿創建出來的，只需要呼叫簡單工廠模式的方法來統一建立就可以了，從而明確了各個類的職責。
　　一、建立簡單工廠模式 

  
 

    

    
    大話設計模式一：簡單工廠模式
      
                一.模式定義

簡單工廠模式也稱為靜態工廠模式。屬於類建立型設計模式。實質是一個“”工廠系統“”可以產生出多種不同的”產品物件”，使用者不需要知道“”產品物件“”是怎麼產生的，只需要知道關於該“產品物件”的關鍵引數，將該引數傳給“工廠系統”就可以由工廠系統生產出對應的產品。