デザインパターン：三工場モード

工場出荷時のパターンの三種類

シンプルなファクトリの実装

スキーマを作成するための簡単なファクトリパターンは（GOFは、厳密にこれを言えば、それはより多くのプログラミングの練習のようなデザインパターンです）また、静的ファクトリメソッドパターンとして知られている、クラスに属します。特に、クラスのインスタンスの別のインスタンスを作成するための責任を負うクラスは通常、同じ親を持って作成され、アプリケーションが直接顧客に行われているものの製品工場の生産の決定を決定します継承を定義することで、顧客は自分たちのニーズを入力します最終的な結果を得ることができます。

ビジネスシナリオの生産を達成するために、簡単なピザのファクトリパターンを使用します。

/// <summary>
/// pizza创建工厂
/// </summary>
public class PizzaFactory
{
     public static Pizza CreatePizza(string pizzaType)
     {
          switch (pizzaType)
          {
               case "Cheese":
               return new CheesePizza();
               case "ApplePie":
               return new ApplePiePizza();
               default:
               return new SomeOtherPizza();
          }
     }
}
public abstract class Pizza
{
     public string Name { get; set; }

     public void Prepare()
     {
          Console.WriteLine($"Preparing {Name}");
          
     }

     public void Cut()
     {
          Console.WriteLine($"Cutting the {Name}");
     }

     public void Bake()
     {
          Console.WriteLine($"Baking the {Name}");
     }

     public void Box()
     {
          Console.WriteLine($"Boxing the {Name}");
     }
}

public class ApplePiePizza : Pizza
{
     public ApplePiePizza()
     {
          Name = "ApplePie";
     }
}

public class CheesePizza : Pizza
{
     public CheesePizza()
     {
          Name = "Cheese";
     }
}

public class SomeOtherPizza : Pizza
{
     public SomeOtherPizza()
     {
          Name = "Other";
     }
}
//调用
class Program
{
     static void Main(string[] args)
     {
          Pizza pizza = PizzaFactory.CreatePizza("cheese");
          pizza.Box();
     }
}
//输出：
//Preparing Cheese
//Cutting the Cheese
//Baking the Cheese
//Boxing the Cheese

クライアントコード、あなたがピザを生成するのに必要なロジックのコードを追加することができますが、簡単な工場を満たしていないファクトリクラスとコード生成ピザの種類を達成するために、単純なファクトリパターン - 、拡張子にオープン（原則「を開いては閉じて」 ）変更のため閉鎖あなたがタイプVeggiePizzaを追加したい場合は、あなたがSwich-ケースを増やす必要がファクトリクラスの製品の内部で生成されたコードを、変更します。そのことについては、私たちのファクトリメソッドは、この問題を解決することができます。

ファクトリパターン

工場モデルの使用は、生産ピザビジネスシナリオを実現しています。

/// <summary>
/// 工厂接口
/// </summary>
interface IFactory
{
     Pizza CreatePizza();
}
/// <summary>
/// CheesePizza工厂方法
/// </summary>
public class CheesePizzaFactory : IFactory
{
     public Pizza CreatePizza()
     {
          return new CheesePizza();

     }
}
/// <summary>
/// ApplePiePizza工厂方法
/// </summary>
public class ApplePiePizzaFactory : IFactory
{
     public Pizza CreatePizza()
     {
          return new ApplePiePizza();
     }
}
class Program
{
     static void Main(string[] args)
     {
          IFactory factory = new CheesePizzaFactory();
          Pizza cheesePizza = factory.CreatePizza();
          cheesePizza.Prepare();
          cheesePizza.Cut();
          cheesePizza.Bake();
          cheesePizza.Box();
          //输出：
          //Preparing Cheese
          //Cutting the Cheese
          //Baking the Cheese
          //Boxing the Cheese
     }
}

「オン・オフ」の原則と矛盾ピザを、対応する対応するファクトリクラスによって生成された当社の工場モード、どんなに多くのクラスピザプラス、私たちは元のクラスのコードを変更する必要はありませんが、ファクトリクラスを増加させることにより達成されます。しかし、それはまだ欠点を持って、あまりにも多くの製品カテゴリのピザならば、我々はファクトリクラスの多くを生成します。我々は、製品に複数のインターフェイスを実現したい場合、つまり、複数の製品のインターフェイス、対応する製品ファミリと異なる製品のインターフェイスがあります。製品ファミリーは何をするのですか？これは、単にさまざまな分野でのピザの種類は製品ファミリーを形成することができるピザ領域の異なるタイプのように準備の異なる方法、変更の味ながら、異なる材料（生地生地、ジャムソース）とを、持っていることを意味します。このケースでは、Abstract Factoryパターンを使用することができます。

Abstract Factoryパターン

工場モデルの使用は、生産ピザビジネスシナリオを実現しています。

/// <summary>
/// 面团
/// </summary>
public interface Dough
{
     void Dough();
}
/// <summary>
/// 纽约面团
/// </summary>
public class NYDough : Dough
{
     public void Dough()
     {
          Console.WriteLine("NYDough");
     }
}
/// <summary>
/// 芝加哥面团
/// </summary>
public class ChicagoDough : Dough
{
     public void Dough()
     {
          Console.WriteLine("ChicagoDough");
     }
}
/// <summary>
/// 果酱
/// </summary>
public interface Sauce
{
     void Sauce();
}
/// <summary>
/// 纽约果酱
/// </summary>
public class NYSauce : Sauce
{
     public void Sauce()
     {
          Console.WriteLine("NYSauce");
     }
}
/// <summary>
/// 芝加哥果酱
/// </summary>
public class ChicagoSauce : Sauce
{
     public void Sauce()
     {
          Console.WriteLine("ChicagoSauce");
     }
}
/// <summary>
/// 建造披萨原料工厂 接口
/// </summary>
public interface IPizzaIngredientFactory
{
     Dough CreateDough();
     Sauce CreateSauce();
}
/// <summary>
/// 纽约披萨工厂
/// </summary>
public class NYPizzaIngredientFactory : IPizzaIngredientFactory
{
     public Dough CreateDough()
     {           
          return new NYDough();
     }
     public Sauce CreateSauce()
     {
          return new NYSauce();
     }
}
/// <summary>
/// 芝加哥披萨工厂
/// </summary>
public class ChicagoPizzaIngredientFactory : IPizzaIngredientFactory
{
     public Dough CreateDough()
     {
          return new ChicagoDough();
     }
     public Sauce CreateSauce()
     {
          return new ChicagoSauce();
     }
}
public abstract class Pizza
{
     public string Name { get; set; }
     /// <summary>
     /// 面团
     /// </summary>
     public Dough Dough { get; set; }
     /// <summary>
     /// 酱汁
     /// </summary>
     public Sauce Sauce { get; set; }

     public abstract void Prepare();


     public void Cut()
     {
          Console.WriteLine($"Cutting the {Name}");
     }

     public void Bake()
     {
          Console.WriteLine($"Baking the {Name}");
     }

     public void Box()
     {
          Console.WriteLine($"Boxing the {Name}");
     }
}
public class ApplePiePizza : Pizza
{
     IPizzaIngredientFactory _pizzaIngredientFactory;
     public ApplePiePizza(IPizzaIngredientFactory pizzaIngredient)
     {
          this._pizzaIngredientFactory = pizzaIngredient;
          Name = "ApplePie";
     }

     public override void Prepare()
     {
          Console.WriteLine($"Preparing { Name}");
          Dough = _pizzaIngredientFactory.CreateDough();
          Dough.Dough();
          Sauce = _pizzaIngredientFactory.CreateSauce();
          Sauce.Sauce();
     }
}
public class CheesePizza : Pizza
{
     IPizzaIngredientFactory _pizzaIngredientFactory;
     public CheesePizza(IPizzaIngredientFactory pizzaIngredient)
     {
          this._pizzaIngredientFactory = pizzaIngredient;
          Name = "Cheese";
     }

     public override void Prepare()
     {
          Console.WriteLine($"Preparing { Name}");
          Dough = _pizzaIngredientFactory.CreateDough();
          Dough.Dough();
          Sauce = _pizzaIngredientFactory.CreateSauce();
          Sauce.Sauce();
     }
}
public class SomeOtherPizza : Pizza
{
     public SomeOtherPizza()
     {
          Name = "Other";
     }

     public override void Prepare()
     {
          throw new NotImplementedException();
     }
}
// <summary>
/// 工厂接口
/// </summary>
interface IFactory
{
     Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory);
}
/// <summary>
/// CheesePizza工厂方法
/// </summary>
public class CheesePizzaFactory : IFactory
{
     public Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory)
     {
          return new CheesePizza(pizzaIngredientFactory);

     }
}

/// <summary>
/// ApplePiePizza工厂方法
/// </summary>
public class ApplePiePizzaFactory : IFactory
{
     public Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory)
     {
          return new ApplePiePizza(pizzaIngredientFactory);
     }
}
//调用
class Program
{
     static void Main(string[] args)
     {
          IPizzaIngredientFactory pizzaIngredientFactory = new NYPizzaIngredientFactory();
          IFactory factory = new CheesePizzaFactory();
          Pizza cheesePizza = factory.CreatePizza(pizzaIngredientFactory);
          cheesePizza.Prepare();
          cheesePizza.Cut();
          cheesePizza.Bake();
          cheesePizza.Box();
          //输出：
          //Preparing Cheese
          //NYDough
          //NYSauce
          //Cutting the Cheese
          //Baking the Cheese
          //Boxing the Cheese
     }
}

概要

シンプルな工場の優位性

• 作成し、別の使用目的を達成するために、呼び出し側は、直接の義務の対象が、唯一の「消費者」の製品を作成して製品を削除することができます。

• 作成したクラス名、特定の製品カテゴリを知らなくても、発信者は、唯一のパラメータに対応する特定の製品クラスを知っている必要があります。

  シンプル工場欠陥

• あまりにも重いが、一度動作しないすべての責任の論理積を作成することに焦点を当てたファクトリクラスは、システム全体が影響を受けなければなりません。

• 新製品は、製品の多くの種類がある場合、それは植物のロジックを引き起こす可能性があり、植物を変更するロジックを追加する必要があります一度、困難なシステムの拡張は、システムの拡張やメンテナンスを助長されていません、あまりにも複雑です。

工場の利点

• 顧客が必要とする製品を作成するために使用されるファクトリメソッドでなく、顧客に特定の製品クラスは、この詳細をインスタンス化されるか非表示になります。したがって、ユーザは、作成の詳細を気にすることなく、植物に対応する所望の生成物を心配する必要があります。

• システムに新製品を追加する場合は、インターフェースの抽象化抽象工場と製品の提供を変更することなく、そこにクライアントを変更する必要はありませんが、また、特定の植物やその他の特定の製品の変更なしで、ちょうどその上で特定の植物や特定の製品を追加します。そのため、システムの拡張性は開閉の原則に沿って、保証されています。

  工場欠陥

• 新製品を追加するときは、特定の製品の新しいクラスを書くために、だけでなく、ある程度対応する具体的なファクトリクラス、クラスのシステムは増加のペアの数は、システムの複雑さを提供する必要があります。

• アカウントにシステムの拡張性を取ると、抽象化の層を導入する必要性と反射技術を実装する際に必要になることがあり、システムの実装の難易度を高めます。

抽象工場の優位性

• 分離された顧客が作成されているかを知る必要がないように、特定のクラスを生成します。このため、分離のため、特定の植物の交換が比較的容易になります。
• 製品ファミリは、複数のオブジェクトが一緒に動作するように設計されて呼び出された場合、それは、クライアントが常に同じ製品ファミリにオブジェクトのみを使用するようにすることができます。

• 開閉の原則に沿ったもので、既存のシステムを変更することなく、簡単に新しい製品ファミリを追加します。

  抽象工場欠陥

• なぜなら、必然的にこのような観点で、大きな不便をもたらす既存のシステム、コードを変更することも、抽象化レイヤの必要性、に大きな変更を行う必要の新製品階層を追加し、それが開口部に反するとのために、拡張子にオープン（クローズ修正）の原則のため閉鎖。

ダウンロードソース