Modello di fabbrica senza interruttore o If/Then

Question

Sto cercando un semplice esempio di come implementare una classe factory, ma senza l'uso di uno Switch o di un'istruzione If-Then. Tutti gli esempi che riesco a trovare ne usano uno. Ad esempio, come si può modificare questo semplice esempio (sotto) in modo che la fabbrica effettiva non dipenda dallo Switch? Mi sembra che questo esempio viola il principio di apertura/chiusura. Mi piacerebbe poter aggiungere classi concrete ('Manager', 'Clerk', 'Programmer', ecc.) Senza dover modificare la classe factory.

Grazie!

class Program 
{ 
    abstract class Position 
    { 
     public abstract string Title { get; } 
    } 

    class Manager : Position 
    { 
     public override string Title 
     { 
      get { return "Manager"; } 
     } 
    } 

    class Clerk : Position 
    { 
     public override string Title 
     { 
      get { return "Clerk"; } 
     } 
    } 

    class Programmer : Position 
    { 
     public override string Title 
     { 
      get { return "Programmer"; } 
     } 
    } 

    static class Factory 
    { 
     public static Position Get(int id) 
     { 
      switch (id) 
      { 
       case 0: return new Manager(); 
       case 1: return new Clerk(); 
       case 2: return new Programmer(); 
       default: return new Programmer(); 
      } 
     } 
    } 

    static void Main(string[] args) 
    { 
     for (int i = 0; i <= 2; i++) 
     { 
      var position = Factory.Get(i); 
      Console.WriteLine("Where id = {0}, position = {1} ", i, position.Title); 
     } 
     Console.ReadLine(); 
    } 
} 

UPDATE:

Wow! Grazie a tutti! Ho imparato un sacco. Dopo aver ridestato tutto il feedback, ho mescolato alcune delle risposte e ne sono venuto fuori. Sarei aperto a ulteriori dialoghi su un modo migliore per farlo.

class Program 
{ 

    public interface IPosition 
    { 
     string Title { get; } 
    } 

    class Manager : IPosition 
    { 
     public string Title 
     { 
      get { return "Manager"; } 
     } 
    } 

    class Clerk : IPosition 
    { 
     public string Title 
     { 
      get { return "Clerk"; } 
     } 
    } 

    class Programmer : IPosition 
    { 
     public string Title 
     { 
      get { return "Programmer"; } 
     } 
    } 

static class PositionFactory 
{ 
    public static T Create<T>() where T : IPosition, new() 
    { 
     return new T(); 
    } 
} 


static void Main(string[] args) 
    { 

     IPosition position0 = PositionFactory.Create<Manager>(); 
     Console.WriteLine("0: " + position0.Title); 

     IPosition position1 = PositionFactory.Create<Clerk>(); 
     Console.WriteLine("1: " + position1.Title); 

     IPosition position2 = PositionFactory.Create<Programmer>(); 
     Console.WriteLine("1: " + position2.Title); 

     Console.ReadLine(); 
    } 
} 

Un altro Edit:

E 'anche possibile creare un'istanza della interfaccia utilizzando un tipo sconosciuto:

static class PositionFactory 
{ 
    public static IPosition Create(string positionName) 
    {  
     Type type = Type.GetType(positionName); 
     return (IPosition)Activator.CreateInstance(type); 
    } 
} 

che potrebbero poi essere chiamato come segue:

IPosition position = PositionFactory.Create("Manager"); 
Console.WriteLine(position.Title); 

Answer 1

ne dite di questo (nessun dizionario richiesto e si noti che si otterrà un errore di sintassi se il tentativo di Create<Position>()):

EDIT - Aggiornato per utilizzare un'interfaccia IPosition implementata in modo esplicito. Solo le istanze di IPosition possono accedere alle funzioni membro (ad esempio, <implementation of Manager>.Title non verrà compilato).

EDIT # 2 Factory.Create deve restituire un'Iposizione non T quando si utilizza l'interfaccia correttamente.

using System; 
using System.Collections.Generic; 

class Program 
{ 
    interface IPosition 
    { 
     string Title { get; } 
     bool RequestVacation(); 
    } 

    class Manager : IPosition 
    { 
     string IPosition.Title 
     { 
      get { return "Manager"; } 
     } 

     bool IPosition.RequestVacation() 
     { 
      return true; 
     } 
    } 

    class Clerk : IPosition 
    { 
     int m_VacationDaysRemaining = 1; 

     string IPosition.Title 
     { 
      get { return "Clerk"; } 
     } 

     bool IPosition.RequestVacation() 
     { 
      if (m_VacationDaysRemaining <= 0) 
      { 
       return false; 
      } 
      else 
      { 
       m_VacationDaysRemaining--; 
       return true; 
      } 
     } 
    } 

    class Programmer : IPosition 
    { 
     string IPosition.Title 
     { 
      get { return "Programmer"; } 
     } 

     bool IPosition.RequestVacation() 
     { 
      return false; 
     } 
    } 

    static class Factory 
    { 
     public static IPosition Create<T>() where T : IPosition, new() 
     { 
      return new T(); 
     } 
    } 

    static void Main(string[] args) 
    { 
     List<IPosition> positions = new List<IPosition>(3); 
     positions.Add(Factory.Create<Manager>()); 
     positions.Add(Factory.Create<Clerk>()); 
     positions.Add(Factory.Create<Programmer>()); 

     foreach (IPosition p in positions) { Console.WriteLine(p.Title); } 
     Console.WriteLine(); 

     Random rnd = new Random(0); 
     for (int i = 0; i < 10; i++) 
     { 
      int index = rnd.Next(3); 
      Console.WriteLine("Title: {0}, Request Granted: {1}", positions[index].Title, positions[index].RequestVacation()); 
     } 

     Console.ReadLine(); 
    } 
} 

Answer 2

Si potrebbe fare uso di attributi personalizzati e reflec zione.

[PositionType(1)] 
class Manager : Position 
{ 
    public override string Title 
    { 
     get 
     { return "Manager"; } 
    } 
} 

[PositionType(2)] 
class Clerk : Position 
{ 
    public override string Title 
    { 
     get 
     { return "Clerk"; } 
    } 
} 

Nella fabbrica si potrebbe quindi ottenere tutte le classi che ereditano da Position e trovare quello che ha l'attributo PositionType con il valore corretto.

static class Factory 
{ 
    public static Position Get(int id) 
    { 
     var types = typeof(Position).Assembly.GetTypes() 
      .Where(t => !t.IsAbstract && t.IsSubclassOf(typeof(Position))) 
      .ToList(); 

     Position position = null; 
     foreach(var type in types) 
     { 
      type.GetCustomAttributes<PositionTypeAttribute>(); 

      if(type.PositionId == id) 
      { 
       position = Activator.CreateInstance(type) as Position; 
       break; 
      } 
     } 

     if(position == null) 
     { 
      var message = $"Could not find a Position to create for id {id}."; 
      throw new NotSupportedException(message); 
     } 

     return position; 
    } 
} 

Answer 3

public class PositionFactory 
{ 
    private Dictionary<int, Type> _positions; 

    public PositionFactory() 
    { 
     _positions = new Dictionary<int, Type>(); 
    } 

    public void RegisterPosition<PositionType>(int id) where PositionType : Position 
    { 
     _positions.Add(id, typeof(PositionType)); 
    } 

    public Position Get(int id) 
    { 
     return (Position) Activator.CreateInstance(_positions[id]); 
    } 
} 

Utilizzato in questo modo:

  var factory = new PositionFactory(); 
      factory.RegisterPosition<Manager>(0); 
      factory.RegisterPosition<Clerk>(1); 

      Position p = factory.Get(0); //Returns a new Manager instance 

Answer 4

Perché complicare eccessivamente le cose? Qui è una soluzione semplice:

using System; 
using System.Collections.Generic; 

class Program 
{ 
    interface IPosition 
    { 
     string Title { get; } 
    } 

    class Manager : IPosition 
    { 
     public string Title 
     { 
      get { return "Manager"; } 
     } 
    } 

    class Clerk : IPosition 
    { 
     public string Title 
     { 
      get { return "Clerk"; } 
     } 
    } 

    class Programmer : IPosition 
    { 
     public string Title 
     { 
      get { return "Programmer"; } 
     } 
    } 

    class Factory 
    { 
     private List<IPosition> positions = new List<IPosition>(); 
     public Factory() 
     { 
      positions.Add(new Manager()); 
      positions.Add(new Clerk()); 
      positions.Add(new Programmer()); 
      positions.Add(new Programmer()); 
     } 

     public IPosition GetPositions(int id) 
     { 
      return positions[id]; 
     } 
    } 

    static void Main(string[] args) 
    { 
     Factory factory = new Factory(); 

     for (int i = 0; i <= 2; i++) 
     { 
      var position = factory.GetPositions(i); 
      Console.WriteLine("Where id = {0}, position = {1} ", i, position.Title); 
     } 
     Console.ReadLine(); 
    } 
} 

Ecco come fare questo senza usare classe factory a tutti:

using System; 
using System.Collections.Generic; 

class Program 
{ 
    interface IPosition 
    { 
     string Title { get; } 
    } 

    class Manager : IPosition 
    { 
     public string Title 
     { 
      get { return "Manager"; } 
     } 
    } 

    class Clerk : IPosition 
    { 
     public string Title 
     { 
      get { return "Clerk"; } 
     } 
    } 

    class Programmer : IPosition 
    { 
     public string Title 
     { 
      get { return "Programmer"; } 
     } 
    } 

    static void Main(string[] args) 
    { 
     List<IPosition> positions = new List<IPosition> { new Manager(), new Clerk(), new Programmer(), new Programmer() }; 

     for (int i = 0; i <= 2; i++) 
     { 
      var position = positions[i]; 
      Console.WriteLine("Where id = {0}, position = {1} ", i, position.Title); 
     } 
     Console.ReadLine(); 
    } 
}