공장 패턴

Question

내 제품 공장

public interface IProductFactory 
{ 
    void Drive(int miles); 
} 

내 자동차 공장

public interface IVehicleFactory 
{ 
    IProdctFactory GetVehicle(string Vehicle); 
} 

제품 자전거

class Bike:IProdctFactory 
{ 
    public void Drive(int miles) 
    { 
     Console.WriteLine("Drive the Bike : " + miles.ToString() + "km"); 
    } 
} 

제품 스쿠터

class Scooter:IProdctFactory 
{ 
    public void Drive(int miles) 
    { 
     Console.WriteLine("Drive the Scooter : " + miles.ToString() + "km"); 
    } 
} 

,

제품 자동차

class Car:IProdctFactory 
{ 
    public void Drive(int miles) 
    { 
     Console.WriteLine("Drive the Car : " + miles.ToString() + "km"); 
    } 
} 

제품 지프

class Jeep:IProdctFactory 
{ 
    public void Drive(int miles) 
    { 
     Console.WriteLine("Drive the Jeep : " + miles.ToString() + "km"); 
    } 
} 

두 휠러 공장

public class TwoWheelerFactory : IVehicleFactory 
{ 

    public IProdctFactory GetVehicle(string Vehicle) 
    { 
     switch (Vehicle) 
     { 
      case "Scooter": 
       return new Scooter(); 
      case "Bike": 
       return new Bike(); 
      default: 
       throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Vehicle)); 
     } 
    } 
} 

4 휠러 공장

class FourWheelerFactory:IVehicleFactory 
{ 

    public IProdctFactory GetVehicle(string Vehicle) 
    { 
     switch (Vehicle) 
     { 
      case "Car": 
       return new Car(); 
      case "Jeep": 
       return new Jeep(); 
      default: 
       throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Vehicle)); 
     } 
    } 
} 

클라이언트

class Program 
{ 
    static void Main(string[] args) 
    { 
     IVehicleFactory twoWheelerfactory = new TwoWheelerFactory(); 

     IProdctFactory scooter = twoWheelerfactory.GetVehicle("Scooter"); 
     scooter.Drive(10); 

     IProdctFactory bike = twoWheelerfactory.GetVehicle("Bike"); 
     bike.Drive(20); 

     IVehicleFactory fourWheelerFactory = new FourWheelerFactory(); 
     IProdctFactory car = fourWheelerFactory.GetVehicle("Car"); 
     car.Drive(100); 

     IProdctFactory jeep = fourWheelerFactory.GetVehicle("Car"); 
     jeep.Drive(200); 

     Console.ReadKey(); 
    } 
} 

두 개의 구체적인 차량 클래스 (TwoWheelerFactory, FourWheelerFactory)를 공장 패턴으로 사용하고 있습니까? 나는 추상 팩토리 패턴에 대해 많이 읽고 있지만

, 나는

? 아직도 :(누군가가 추상 팩토리 패턴으로 변환하는 데 도움이 수 무엇인지 확실하지 않다 나는

Design Patterns: Abstract Factory vs Factory Method

읽기

및

Wikipedia에서

http://www.dotnet-tricks.com/Tutorial/designpatterns/FUcV280513-Factory-Method-Design-Pattern---C

Answer 1

- 추상 팩토리 패턴의 본질은 "구체적인 클래스를 지정하지 않고 관련 객체 또는 종속 객체의 패밀리를 작성하기위한 인터페이스를 제공하는 것"입니다.

핵심 부분은 클라이언트가 자동차 나 자전거 등의 인스턴스를 가지고 있다는 것을 결코 알지 못한다는 것입니다. 핵심 유형은 추상 유형 만 처리하는 것입니다.

서로 다른 팩토리는 서로 다른 인스턴스를 제공하지만 추상 유형은 동일합니다.

자전거, 스쿠터, 지프 및 자동차는 모두 공장 방법으로 만들어야하는 구체적인 제품입니다. 귀하의 예에서 인터페이스에서 제품을 상속 받으면 특히 '공장'이라는 제품이 잘못되어 혼동을 일으 킵니다. 일반적으로 인터페이스가 잘못되었다는 것은 아닙니다.

아래의 내용을 약간의 확장과 함께 적용하면 데이터 &에 의해 제공된 Abstract Factory 패턴으로 일부 문맥을 제공하는 데 도움이됩니다.

새로운 패턴과 기법을 배우는 것이 위대하고 흥미롭지 만 모든 상황에 대해 배운이 새로운 패턴을 적용하려고 시도하는 동안 함정에 빠지지 마십시오.가장 좋은 방법은 간단한 코드를 작성하는 것입니다. 추가적인 복잡성은 실제로 필요할 때까지는 피해야합니다.

class MainApp 
{ 

    public static void Main() 
    { 

     // Abstract factory #1 
     AbstractFactory factory1 = new EuropeVehicleFactory(); 
     Client client1 = new Client(factory1); 
     client1.Run(); 

     // Abstract factory #2 
     AbstractFactory factory2 = new UsaVehicleFactory(); 
     Client client2 = new Client(factory2); 
     client2.Run(); 

    } 
} 

/// <summary> 
/// The 'AbstractFactory' abstract class 
/// </summary> 
abstract class AbstractFactory 
{ 
    public abstract TwoWheelerProduct CreateTwoWheelerProduct(); 
    public abstract FourWheelerProduct CreateFourWheelerProduct(); 
} 


/// <summary> 
/// The 'ConcreteFactory1' class 
/// </summary> 
class UsaVehicleFactory : AbstractFactory 
{ 
    public override TwoWheelerProduct CreateTwoWheelerProduct() 
    { 
    return new Bike(); 
    } 
    public override FourWheelerProduct CreateFourWheelerProduct() 
    { 
    return new Car(); 
    } 
} 

/// <summary> 
/// The 'ConcreteFactory2' class 
/// </summary> 
class EuropeVehicleFactory : AbstractFactory 
{ 
    public override TwoWheelerProduct CreateTwoWheelerProduct() 
    { 
    return new Scooter(); 
    } 
    public override FourWheelerProduct CreateFourWheelerProduct() 
    { 
    return new Jeep(); 
    } 
} 

/// <summary> 
/// The 'AbstractProductA' abstract class 
/// </summary> 
abstract class TwoWheelerProduct 
{ 
} 

/// <summary> 
/// The 'AbstractProductB' abstract class 
/// </summary> 
abstract class FourWheelerProduct 
{ 
    //Disclaimer: I am a temporary citizen... 
    public abstract void RunOver(TwoWheelerProduct twoWheeler); 
} 


/// <summary> 
/// The 'ProductA1' class 
/// </summary> 
class Scooter : TwoWheelerProduct 
{ 
} 

/// <summary> 
/// The 'ProductB1' class 
/// </summary> 
class Car : FourWheelerProduct 
{ 
    public override void RunOver(TwoWheelerProduct twoWheeler) 
    { 
    Console.WriteLine(this.GetType().Name + 
     " smashes into " + a.GetType().Name); 
    } 
} 

/// <summary> 
/// The 'ProductA2' class 
/// </summary> 
class Bike : TwoWheelerProduct 
{ 
} 

/// <summary> 
/// The 'ProductB2' class 
/// </summary> 
class Jeep : FourWheelerProduct 
{ 
    public override void RunsOver(TwoWheelerProduct twoWheeler) 
    { 
    Console.WriteLine(this.GetType().Name + 
     " collides with " + a.GetType().Name); 
    } 
} 

/// <summary> 
/// The 'Client' class. Interaction environment for the products. 
/// </summary> 
class Client 
{ 
    private TwoWheelerProduct _abstractTwoWheeler; 
    private FourWheelerProduct _abstractFourWheeler; 

    // Constructor 
    public Client(AbstractFactory factory) 
    { 
    _abstractTwoWheeler = factory.CreateTwoWheeler(); 
    _abstractFourWheeler = factory.CreateFourWheeler(); 
    } 

    public void Run() 
    { 
    _abstractFourWheeler.RunOver(_abstractTwoWheeler); 
    } 
}