2016年7月11日 星期一

創建者模式 Builder Pattern

PM:小奇,我發現上個月營收不好
PM:這次豁出去了!
PM:直接來賣整套套裝了...
PM:也就是轉一次就給你一個指定套裝,但是數值好壞就看個人運氣了
PM:所以目前總共有5套,但是改版後可能會新增2套
我:好的,沒問題

所以這次的需求,是要抽套裝,套裝裡面有頭盔、上衣、褲子、手套、鞋子
所以這5樣套裝的東西是固定的,只是套裝的種類是會變來變去的
如:王朝套裝、帝國套裝、雜七雜八套裝

PM又說了,改版後會在新增兩件套裝,所以之後會在加兩件套裝上去
於是使用創建者模式寫寫看

using System;

namespace DesignPattern.BuilderPattern
{
    class Run
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Bulider bulider = new KingSet();    //獲取王朝套裝
            director.setBulider(bulider);
            director.create();

            Console.WriteLine("----------");

            bulider = new EmpireSet();  //獲取帝國套裝
            director.setBulider(bulider);
            director.create();
            Console.ReadLine();
        }

        //套裝的裝備項目
        interface Bulider
        {
            //獲得頭盔
            void getHat();
            //獲得上衣     
            void getCoat();
            //獲得褲子      
            void getPants();
            //獲得手套    
            void getGloves();
            //獲得鞋子
            void getShoe();       
        }

        //統一由指揮者 class 執行生產步驟
        class Director
        {
            private Bulider builder;
            public void setBulider(Bulider builder)
            {
                this.builder = builder;
            }
            public void create()
            {
                this.builder.getHat();
                this.builder.getCoat();
                this.builder.getPants();
                this.builder.getGloves();
                this.builder.getShoe();
            }
        }

        //王朝套裝
        class KingSet : Bulider
        {
            public void getHat()
            {
                Console.WriteLine("獲得王朝套裝-頭盔");
            }
            public void getCoat()
            {
                Console.WriteLine("獲得王朝套裝-上衣");
            }

            public void getPants()
            {
                Console.WriteLine("獲得王朝套裝-褲子");
            }

            public void getGloves()
            {
                Console.WriteLine("獲得王朝套裝-手套");
            }

            public void getShoe()
            {
                Console.WriteLine("獲得王朝套裝-鞋子");
            }
        }

        //帝國套裝
        class EmpireSet : Bulider
        {
            public void getHat()
            {
                Console.WriteLine("獲得帝國套裝-頭盔");
            }
            public void getCoat()
            {
                Console.WriteLine("獲得帝國套裝-上衣");
            }

            public void getPants()
            {
                Console.WriteLine("獲得帝國套裝-褲子");
            }

            public void getGloves()
            {
                Console.WriteLine("獲得帝國套裝-手套");
            }

            public void getShoe()
            {
                Console.WriteLine("獲得帝國套裝-鞋子");
            }
        }
    }
}

所以這邊我創建了一個interface  Bulider內容就是套裝的項目,這些都是固定的
然後又創建了一個Director類別,負責產生套裝
然後創建王朝套裝(KingSet)的類別繼承Bulider,來實做得到的內容
所以改版後,新增的兩件套裝,我就可以在新增兩個類別來實做新的套裝
這邊也就不會動到之前的套裝的類別

2016年7月10日 星期日

外觀模式 Facade Pattern

PM:小奇奇,在嗎?
我: 是的,I am here
PM:我又想弄一個轉蛋活動,就是轉一次可以獲得隨機屬性裝備(頭盔、上衣、下衣、手套、鞋子)等等...
PM:但是我有兩種金額的轉蛋,50元可以轉出上衣、下衣,但是100元可以轉出整套的裝備
我:好的,沒問題喔

於是我將code先寫成這樣
using System;
namespace DesignPattern.FacadePattern
{
    class Run
    {
        static void Main(string[] args)
        {            
            Console.WriteLine("50元轉蛋:");
            Gashapon gash = new Gashapon();
            gash.getCoat();
            gash.getPants();

            Console.WriteLine("100元轉蛋:");
            gash.getHat();
            gash.getCoat();
            gash.getPants();
            gash.getGloves();
            gash.getShoe();
            Console.Read();
        }

        class Gashapon
        {
            //獲得頭盔
            public void getHat()
            {
                Console.WriteLine("獲得隨機屬性頭盔");                
            }

            //獲得上衣
            public void getCoat()
            {
                Console.WriteLine("獲得隨機屬性上衣");
            }

            //獲得褲子
            public void getPants()
            {
                Console.WriteLine("獲得隨機屬性褲子");
            }
            
            //獲得手套
            public void getGloves()
            {
                Console.WriteLine("獲得隨機屬性手套");
            }

            //獲得鞋子
            public void getShoe()
            {
                Console.WriteLine("獲得隨機屬性鞋子");
            }

        }
    }
}
先建立一個Gashapon轉蛋的類別,裡面有getHat()、getCoat()、getPants()、getGloves()、getShoe()分別是獲得各種裝備的方法

這樣寫也沒什麼不對,只是如果PM又要加碼武器(刀、劍、槍....)等等
這樣不就又多了好多個方法,這樣程式變的很雜亂
所以可以透過外觀模式來整理一下介面
using System;

namespace DesignPattern.FacadePattern
{
    class Run
    {
        static void Main(string[] args)
        {
            Console.WriteLine("50元轉蛋:");
            GashaponFacade gash = new GashaponFacade();
            gash.get50Item();

            Console.WriteLine("100元轉蛋:");
            gash.get100Item();
            Console.Read();
        }

        class GashaponFacade
        {
            Gashapon gash;
            public GashaponFacade()
            {
                gash = new Gashapon();
            }

            public void get50Item()
            {
                gash.getCoat();
                gash.getPants();
            }

            public void get100Item()
            {
                gash.getHat();
                gash.getCoat();
                gash.getPants();
                gash.getGloves();
                gash.getShoe();
            }
        }

        class Gashapon
        {
            //獲得頭盔
            public void getHat()
            {
                Console.WriteLine("獲得隨機屬性頭盔");
            }

            //獲得上衣
            public void getCoat()
            {
                Console.WriteLine("獲得隨機屬性上衣");
            }

            //獲得褲子
            public void getPants()
            {
                Console.WriteLine("獲得隨機屬性褲子");
            }

            //獲得手套
            public void getGloves()
            {
                Console.WriteLine("獲得隨機屬性手套");
            }

            //獲得鞋子
            public void getShoe()
            {
                Console.WriteLine("獲得隨機屬性鞋子");
            }

        }
    }
}
這邊新增了一個GashaponFacade類別,來整理出購買50元或100元會得到的虛寶
可以看到我們在使用get50Item()可以不需要去接觸那些繁瑣的事,只要透過get50Item()為我們處理50元的虛寶即可,外觀模式的威力就在於此。

另外,在重構時我們可能會接觸到充滿耦合、邏輯錯綜複雜的程式,其實我們也可以先為這塊加入外觀模式,將不同階層的程式透過中間層隔離,接著在為各區塊進行重構,我們可以就中間層進行測試,就可以避免造成測試不易的問題。

2016年3月6日 星期日

範本方法模式 Template Method Pattern

PM: 小奇奇,小奇奇
我:   0.0
PM: 最近營收很差,我發現我轉蛋賣太貴效果都不好
我:   那你就賣多種價錢的轉蛋阿,便宜到貴的
PM: 好像不錯喔,那我就把轉蛋的寶物都一樣,在依照不同的價錢給不同的屬性
PM: 想要省錢的就去轉比較便宜的
PM: 有錢人要神裝的就去轉貴的,好像也不錯
我:   0.0


所以這次的需求是,轉到的虛寶例如武器、裝備、飾品都是固定的
只有虛寶的屬性在變化,貴的就屬性比較好
所以這次使用範本方法模式寫寫看


首先先建立一個轉蛋的類別
    class Gashapon
    {
        public void ArmsItem()
        {
            Console.WriteLine("恭喜您獲得武器:" + getArmsItem());            
        }

        public void ArmorItem()
        {
            Console.WriteLine("恭喜您獲得盔甲:" + getArmorItem());            
        }

        public void AccessoriesItem()
        {
            Console.WriteLine("恭喜您獲得飾品:" + getAccessoriesItem());            
        }

        protected virtual string getArmsItem()
        {
            return "";
        }

        protected virtual string getArmorItem()
        {
            return "";
        }

        protected virtual string getAccessoriesItem()
        {
            return "";
        }   
    }
在建立3個不同價錢的轉蛋屬性Item
    //50元轉蛋的商品
    class Gashapon50 : Gashapon
    {
        protected override string getArmsItem()
        {
            return "+3武器";
        }

        protected override string getArmorItem()
        {
            return "+3盔甲";
        }

        protected override string getAccessoriesItem()
        {
            return "+3飾品";
        }
    }

    //500元轉蛋的商品
    class Gashapon500 : Gashapon
    {
        protected override string getArmsItem()
        {
            return "+7武器";
        }

        protected override string getArmorItem()
        {
            return "+7盔甲";
        }

        protected override string getAccessoriesItem()
        {
            return "+7飾品";
        }
    }

    //5000元轉蛋的商品
    class Gashapon5000 : Gashapon
    {
        protected override string getArmsItem()
        {
            return "+16武器";
        }

        protected override string getArmorItem()
        {
            return "+16盔甲";
        }

        protected override string getAccessoriesItem()
        {
            return "+16飾品";
        }
    }
主控台與完整的程式碼
using System;

namespace DesignPattern.TemplateMethodPattern
{
    class Run
    {
        static void Main()
        {
            Console.WriteLine("50元轉蛋:");
            Gashapon gash = new Gashapon50();
            gash.ArmsItem();
            gash.ArmorItem();
            gash.AccessoriesItem();

            Console.WriteLine("500元轉蛋:");
            gash = new Gashapon500();
            gash.ArmsItem();
            gash.ArmorItem();
            gash.AccessoriesItem();

            Console.WriteLine("5000元轉蛋:");
            gash = new Gashapon5000();
            gash.ArmsItem();
            gash.ArmorItem();
            gash.AccessoriesItem();

            Console.Read();
        }
    }

    class Gashapon
    {
        public void ArmsItem()
        {
            Console.WriteLine("恭喜您獲得武器:" + getArmsItem());            
        }

        public void ArmorItem()
        {
            Console.WriteLine("恭喜您獲得盔甲:" + getArmorItem());            
        }

        public void AccessoriesItem()
        {
            Console.WriteLine("恭喜您獲得飾品:" + getAccessoriesItem());            
        }

        protected virtual string getArmsItem()
        {
            return "";
        }

        protected virtual string getArmorItem()
        {
            return "";
        }

        protected virtual string getAccessoriesItem()
        {
            return "";
        }   
    }

    //50元轉蛋的商品
    class Gashapon50 : Gashapon
    {
        protected override string getArmsItem()
        {
            return "+3武器";
        }

        protected override string getArmorItem()
        {
            return "+3盔甲";
        }

        protected override string getAccessoriesItem()
        {
            return "+3飾品";
        }
    }

    //500元轉蛋的商品
    class Gashapon500 : Gashapon
    {
        protected override string getArmsItem()
        {
            return "+7武器";
        }

        protected override string getArmorItem()
        {
            return "+7盔甲";
        }

        protected override string getAccessoriesItem()
        {
            return "+7飾品";
        }
    }

    //5000元轉蛋的商品
    class Gashapon5000 : Gashapon
    {
        protected override string getArmsItem()
        {
            return "+16武器";
        }

        protected override string getArmorItem()
        {
            return "+16盔甲";
        }

        protected override string getAccessoriesItem()
        {
            return "+16飾品";
        }
    }
}


2016年3月1日 星期二

工廠方法模式 Factory Pattern

這篇將由第一篇文章簡單工廠模式修改為工廠方法模式

第一篇 : 簡單工廠模式 Simple Factory Pattern

Gashapon.cs
using System;

namespace DesignPattern.FactoryPattern
{
    /*建立一個轉蛋的類別*/
    public class Gashapon
    {
        /*玩家被騙的金額*/
        private double _Amount = 0;

        public double Amount
        {
            get { return _Amount; }
            set { _Amount = value; }
        }

        /*玩家獲得的虛寶*/
        public virtual string GetItem()
        {
            string result = "";
            return result;
        }
    }

    class AdvancedItem : Gashapon
    {
        /*高級實體商品*/
        public override string GetItem()
        {
            /*高級實體商品邏輯運算,這邊簡略不實作*/
            return "高級實體商品";
        }
    }

    class GeneralItem : Gashapon
    {
        /*一般虛寶*/
        public override string GetItem()
        {
            /*一般爛虛寶邏輯運算,這邊簡略不實作*/
            return "一般爛虛寶";
        }
    }


    interface IFactory
    {
        Gashapon CreateGashapon();
    }

    class AdvancedFactory : IFactory
    {
        public Gashapon CreateGashapon()
        {
            return new AdvancedItem();
        }
    }

    class GeneralFactory : IFactory
    {
        public Gashapon CreateGashapon()
        {
            return new GeneralItem();
        }
    }

}

主控台

using System;

namespace DesignPattern.FactoryPattern
{
    class Run
    {
        static void Main(string[] args)
        {

            IFactory ghFactory = new AdvancedFactory();
            Gashapon gh = ghFactory.CreateGashapon();
            Console.WriteLine("大於1000元 : " + gh.GetItem());

            ghFactory = new GeneralFactory();
            gh = ghFactory.CreateGashapon();
            Console.WriteLine("小於1000元 : " + gh.GetItem());

            Console.Read();
        }
    }
}


工廠方法克服了簡單工廠違背開放-封閉原則的缺點,又維持了封裝物件建立過程的優點

2016年2月29日 星期一

裝飾模式 Decorator Pattern

PM: 小奇,這次轉蛋活動營收不錯ㄟ~
我:   是喔~恭喜
PM: 所以我想再弄一個活動
PM: 就是把轉蛋轉到的裝備可以再次轉蛋
我:   .........
PM: 就是可利用轉蛋把裝備加上隨機四種屬性
PM: 例如XX裝備去轉蛋,轉蛋之後隨機增加裝備屬性
PM: 範例1: 力量 + 178  體 + 587 敏捷 + 20 智慧 + 50
PM: 範例2: 力量 + 58  體 + 1500 敏捷 + 35 智慧 + 98
PM: 轉一次50元,應該又可以在賺一波
我:   好的,交給我!
PM: 對了小奇,我可能還會加其他屬性,留點空間新增喔~

PM這次的需求一個某件裝備,可以加上N種屬性
再次翻一翻書,好像裝飾模式可以使用,來套套看好了!!

於是乎新增了一個
Armor.cs
using System;

namespace DesignPattern.DecoratorPattern
{
    /*裝備*/
    class Armor
    {
        public Armor()
        {}

        private string name;
        public Armor(string name)
        {
            this.name = name;
        }

        public virtual void Show()
        {
            Console.WriteLine("[" + name + "]");
        }
    }

    /*屬性*/
    class Attribute : Armor
    {
        protected Armor component;
        public void Decorate(Armor component)
        {
            this.component = component;
        }

        public override void Show()
        {
            if (component != null)
            {
                component.Show();
            }
        }
    }

    /*力量屬性*/
    class STR : Attribute
    {
        private int _val { get; set; }
        public STR(int val)
        {
            _val = val;
        }
        public override void Show()
        {
            Console.Write(" 力量 +" + _val);
            base.Show();
        }
    }

    /*體力屬性*/
    class CON : Attribute
    {
        private int _val { get; set; }
        public CON(int val)
        {
            _val = val;
        }
        public override void Show()
        {
            Console.Write(" 體力 +" + _val);
            base.Show();
        }
    }

    /*敏捷屬性*/
    class DEX : Attribute
    {
        private int _val { get; set; }
        public DEX(int val)
        {
            _val = val;
        }
        public override void Show()
        {
            Console.Write(" 敏捷 +" + _val);
            base.Show();
        }
    }

    /*智慧屬性*/
    class WIT : Attribute
    {
        private int _val { get; set; }
        public WIT(int val)
        {
            _val = val;
        }
        public override void Show()
        {
            Console.Write(" 智慧 +" + _val);
            base.Show();
        }
    }

    /*智力屬性*/
    class INT : Attribute
    {
        private int _val { get; set; }
        public INT(int val)
        {
            _val = val;
        }
        public override void Show()
        {
            Console.Write(" 智力 +" + _val);
            base.Show();
        }
    }

    /*精神屬性*/
    class MEN : Attribute
    {
        private int _val { get; set; }
        public MEN(int val)
        {
            _val = val;
        }
        public override void Show()
        {
            Console.Write(" 精神 +" + _val);
            base.Show();
        }
    }

}
新增主控台程式
Run.cs
using System;

namespace DesignPattern.DecoratorPattern
{
    class Run
    {
        static void Main()
        {
            Random rnd = new Random();
            
            Armor ar = new Armor("金屬盔甲");       /* 裝備*/

            /*PM第一種組合屬性*/
            STR str = new STR(rnd.Next(100));           
            str.Decorate(ar);  
            DEX dex = new DEX(rnd.Next(100));      
            dex.Decorate(str);
            CON con = new CON(rnd.Next(1000)); 
            con.Decorate(dex);
            WIT wit = new WIT(rnd.Next(500));       
            wit.Decorate(con);
            wit.Show();

            /*PM第二種組合屬性*/
            MEN men = new MEN(rnd.Next(100));
            men.Decorate(ar);
            INT _int = new INT(rnd.Next(100));
            _int.Decorate(men);
            _int.Show();

            Console.Read();
        }
    }
}

2016年2月26日 星期五

策略模式 Strategy Pattern

在轉蛋活動進行中的第2天,我還是一如往常的跟正妹聊MSN
突然PM又敲我MSN了... 

PM: 小奇,轉蛋活動賺翻拉,玩家都沒點數拉...
我: 是喔!
PM: 我想趁虛而入,阿~說錯是趁勝追擊
PM: 我想辦這個禮拜儲值點數到平台,多回饋20%點數
PM: 恩~算了!~還是買1000元送100點好了
PM: 哀阿~真的很難抉擇...我先想想好了你就先寫程式好了
我: 0.0...

我心中想了一會兒,這PM好像很善變,好像會有很多種折扣方式
看了一下書,好像可以使用策略模式來滿足PM的需求

於是乎我建立了一個
CashPurchasing.cs
using System;

namespace DesignPattern.StrategyPattern
{
    /*現金收取父類別*/
    abstract class CashPurchasing
    {
        public abstract double acceptCash(double money);
    }
}



再新增一個滿xxx元送xxx點的class繼承CashPurchasing
CashReturn.cs
using System;

namespace DesignPattern.StrategyPattern
{
    /*滿xxx元送xxx點*/
    class CashReturn : CashPurchasing
    {
        private double moneyCondition = 0.0d;
        private double moneyReturn = 0.0d;
        /*初始化時必須要輸入紅利條件和紅利值,比如滿300送100,則moneyCondition為300,moneyReturn為100*/
        public CashReturn(string moneyCondition, string moneyReturn)
        {
            this.moneyCondition = double.Parse(moneyCondition);
            this.moneyReturn = double.Parse(moneyReturn);
        }

        public override double acceptCash(double money)
        {
            double result = money;
            if (money >= moneyCondition)
                result = moneyReturn;

            return result;
        }
    }
}


在新增另一個計算回饋的class一樣繼承CashPurchasing
CashRebate.cs
using System;

namespace DesignPattern.StrategyPattern
{
    /*回饋點數,繼承CashSuper*/
    class CashRebate : CashPurchasing
    {
        private double moneyRebate = 1d;
        /*初始化時,必需要輸入回饋率,如20%,就是0.2*/
        public CashRebate(string moneyRebate)
        {
            this.moneyRebate = double.Parse(moneyRebate);
        }

        public override double acceptCash(double money)
        {
            return money * moneyRebate;
        }
    }
}

PM要的兩種類別都寫好了!!
若以後PM再想到有的沒得運算邏輯就在新增類別即可
寫到這邊,好像似曾相識怎麼跟簡單工廠的做法一樣
再來是不是又要像簡單工廠一樣使用一個SimpleFactory來呼叫需要使用的類別?
所以邊要利用策略模式加上簡單工廠模式

於是乎又建立一個策略模式的class
CashContext.cs
using System;

namespace DesignPattern.StrategyPattern
{
    class CashContext
    {
        CashPurchasing cp = null;

        //根據條件返回相應的物件
        public CashContext(string type)
        {
            switch (type)
            {
                /*滿1000送100*/
                case "return":
                    CashReturn cr1 = new CashReturn("1000", "100");
                    cp = cr1;
                    break;
                /*回饋20%*/
                case "rebate":
                    CashRebate cr2 = new CashRebate("0.2");
                    cp = cr2;
                    break;
            }
        }

        public double GetResult(double money)
        {
            return cp.acceptCash(money);
        }
    }
}

再利用主控台跑一下這一個策略模式
using System;

namespace DesignPattern.StrategyPattern
{
    class RunGame
    {
        static void Main()
        {
            try
            {                
                Console.Write("請輸入玩家儲值的點數:");
                string strAmount = Console.ReadLine();

                /*PM要做回饋20%*/
                CashContext cp = new CashContext("rebate");
                Console.WriteLine("PM要做回饋20%,恭喜您可以額外獲得:" + cp.GetResult(Convert.ToInt32(strAmount)));

                /*PM要做滿1000送100*/
                cp = new CashContext("return");
                Console.WriteLine("PM要做滿1000送100,恭喜您可以額外獲得:" + cp.GetResult(Convert.ToInt32(strAmount)));

                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("您輸入有錯:" + ex.Message);
                Console.ReadLine();
            }

        }
    }
}

所以策略模式中我只要認識CashContext類別就好了
但上一篇的簡單工廠模式我要認識Gashapon與SimpleFactory類別
所以使用策略模式就降低了耦合度


比較 簡單工場模式 與 策略模式: 

1. 簡單工廠模式解決的是物件建立的問題,策略模式的重點則在用一個方式調用一系列演算法,使演算法的變動不會影響到用戶端
2. 對用戶端來說,使用簡單工廠模式必須 import 父類別跟 Factory 類別;但使用策略模式時只需 import 一個 Context 類別就行,降低耦合度

2016年2月25日 星期四

簡單工廠模式 Simple Factory Pattern

有一天當我在逛著Facebook的時候,PM突然敲我MSN,那時候非常流行MSN真的不要懷疑
我當時引以自豪的收集非常多的MSN表情圖示,讓我被當神一樣的崇拜
好了廢話不多說,以下是我跟PM的對話...

PM: 小奇,可以幫我弄一個營收活動嗎?
我:   當然可以
PM: 我想做一個轉蛋的活動
我:   是喔
PM: 就做成小瑪莉那樣好了,總共有12格

就類似以下圖示12格每一個會放一個虛寶

我:   好的沒問題喔
PM: 但我想要有一個條件,就是轉一次50元
PM: 我想讓玩家轉了1000元以上才有機會獲得高級實體虛寶,可以嗎?
我:   這.....雖然黑心了一點,當然沒問題XD

於是乎我就建立了一個
Gashapon.cs
using System;

namespace DesignPattern.SimpleFactoryPattern
{
    /*建立一個轉蛋的類別*/
    public class Gashapon
    {
        /*玩家被騙的金額*/
        private double _Amount = 0;

        public double Amount
        {
            get { return _Amount; }
            set { _Amount = value; }
        }

        /*玩家獲得的虛寶*/
        public virtual string GetItem()
        {
            string result = "";
            return result;
        }
    }
}


接著再建立一個高級虛寶的class繼承Gashapon

   class AdvancedItem : Gashapon
    {
        /*高級實體商品*/
        public override string GetItem()
        {
            /*高級實體商品邏輯運算,這邊簡略不實作*/
            return "高級實體商品";
        }
    }

在建立一個只能獲得普通虛寶的class繼承Gashapon
這一個類別裡面就只會計算普通虛寶的編號
    class GeneralItem : Gashapon
    {
        /*一般虛寶*/
        public override string GetItem()
        {
            /*一般爛虛寶邏輯運算,這邊簡略不實作*/
            return "一般爛虛寶";
        }
    }

所以這三個類別的用意就是,當如果玩家被騙了超過1000元我就要呼叫高級虛寶的類別來計算獲得高級虛寶的編號
如果未滿1000元就呼叫普通虛寶的類別計算,這樣玩家就會不知不覺狂抽,來增加營收
所以此時就可以利用簡單工廠模式來達成這樣的需求

所以在建立一個簡單工廠的class
    class SimpleFactory
    {
        public static Gashapon getItem(int amount)
        {
            Gashapon gash = null;

            /*當玩家消費超過1000元*/
            if (amount >= 1000)
                gash = new AdvancedItem();  /*呼叫高級實體商品*/
            else
                gash = new GeneralItem();   /*呼叫一般爛虛寶*/

            return gash;
        }
    }

所以整個完整的類別如以下
using System;

namespace DesignPattern.SimpleFactoryPattern
{
    /*建立一個轉蛋的類別*/
    public class Gashapon
    {
        /*玩家被騙的金額*/
        private double _Amount = 0;

        public double Amount
        {
            get { return _Amount; }
            set { _Amount = value; }
        }

        /*玩家獲得的虛寶*/
        public virtual string GetItem()
        {
            string result = "";
            return result;
        }
    }

    class AdvancedItem : Gashapon
    {
        /*高級實體商品*/
        public override string GetItem()
        {
            /*高級實體商品邏輯運算,這邊簡略不實作*/
            return "高級實體商品";
        }
    }

    class GeneralItem : Gashapon
    {
        /*一般虛寶*/
        public override string GetItem()
        {
            /*一般爛虛寶邏輯運算,這邊簡略不實作*/
            return "一般爛虛寶";
        }
    }

    /*簡單工廠類別*/
    class SimpleFactory
    {
        public static Gashapon getItem(int amount)
        {
            Gashapon gash = null;

            /*當玩家消費超過1000元*/
            if (amount >= 1000)
                gash = new AdvancedItem();  /*呼叫高級實體商品*/
            else
                gash = new GeneralItem();   /*呼叫一般爛虛寶*/

            return gash;
        }
    }
}
再利用主控台跑一下這一個簡單工廠模式,沒有問題就開始痛宰玩家了~哈哈
using System;

namespace DesignPattern.SimpleFactoryPattern
{
    class RunGame
    {
        static void Main()
        {
            try
            {
                Console.WriteLine("轉蛋開始...");
                Console.Write("請輸入玩家已消費金額");
                string strAmount = Console.ReadLine();

                Gashapon gash = null;
                gash = SimpleFactory.getItem(Convert.ToInt32(strAmount));

                Console.WriteLine("恭喜您獲得:" + gash.GetItem());
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("您輸入有錯:" + ex.Message);
                Console.ReadLine();
            }

        }
    }
}