Autofac - Come creare un factory generato con parametri

Question

Sto provando a creare con Autofac uno factory "generato" che risolverà le dipendenze in tempo reale sulla base di un parametro enum.

Date le seguenti interfacce/classi:

public delegate IConnection ConnectionFactory(ConnectionType connectionType); 

public enum ConnectionType 
{ 
    Telnet, 
    Ssh 
} 

public interface IConnection 
{ 
    bool Open(); 
} 

public class SshConnection : ConnectionBase, IConnection 
{ 
    public bool Open() 
    { 
     return false; 
    } 
} 

public class TelnetConnection : ConnectionBase, IConnection 
{ 
    public bool Open() 
    { 
     return true; 
    } 
} 

public interface IEngine 
{ 
    string Process(ConnectionType connectionType); 
} 

public class Engine : IEngine 
{ 
    private ConnectionFactory _connectionFactory; 

    public Engine(ConnectionFactory connectionFactory) 
    { 
     _connectionFactory = connectionFactory; 
    } 

    public string Process(ConnectionType connectionType) 
    { 
     var connection = _connectionFactory(connectionType); 

     return connection.Open().ToString(); 
    } 
} 

Mi piacerebbe usare Autofac per generare una sorta di fabbrica che ha un metodo che riceve un parametro: ConnectionType e restituisce il corretto collegamento oggetto.

Ho iniziato con le seguenti iscrizioni:

builder.RegisterType<AutoFacConcepts.Engine.Engine>() 
    .As<IEngine>() 
    .InstancePerDependency(); 

builder.RegisterType<SshConnection>() 
    .As<IConnection>(); 
builder.RegisterType<TelnetConnection>() 
    .As<IConnection>(); 

Ho poi continuato a giocare con le iscrizioni TelnetConnection/SshConnection con diverse opzioni:

1. Chiamato
2. con chiave
3. metadati

Non sono riuscito a trovare la combinazione corretta delle registrazioni che consentirà di definire un delegato di fabbrica generato che restituirà l'oggetto di connessione corretto (SshConnection per ConnectionType.Ssh e TelnetConnection per ConnectionType.Telnet).

Answer 1

Aggiornare la classe Engine per prendere un Func<ConnectionType, IConnection> invece del delegato. Autofac supports creating delegate factories on the fly via Func<T>.

public class Engine : IEngine 
{ 
    private Func<ConnectionType, IConnection> _connectionFactory; 

    public Engine(Func<ConnectionType, IConnection> connectionFactory) 
    { 
     _connectionFactory = connectionFactory; 
    } 

    public string Process(ConnectionType connectionType) 
    { 
     var connection = _connectionFactory(connectionType); 

     return connection.Open().ToString(); 
    } 
} 

Nella tua registrazione utilizzare una lambda che afferra il parametro e restituisce il corretto IConnection istanza.

builder.Register<IConnection>((c, p) => 
{ 
    var type = p.TypedAs<ConnectionType>(); 
    switch (type) 
    { 
     case ConnectionType.Ssh: 
      return new SshConnection(); 
     case ConnectionType.Telnet: 
      return new TelnetConnection(); 
     default: 
      throw new ArgumentException("Invalid connection type"); 
    } 
}) 
.As<IConnection>(); 

Se la connessione in sé necessaria una dipendenza si potrebbe chiamare Resolve sul parametro c risolverlo dal contesto chiamata in corso. Ad esempio, new SshConnection(c.Resolve<IDependency>()).

Answer 2

Se è necessario selezionare un tipo di implementazione basata su paramter è necessario utilizzare il IIndex<T,B> implicit relation type:

public class Engine : IEngine 
{ 
    private IIndex<ConnectionType, IConnection> _connectionFactory; 

    public Engine(IIndex<ConnectionType, IConnection> connectionFactory) 
    { 
     _connectionFactory = connectionFactory; 
    } 

    public string Process(ConnectionType connectionType) 
    { 
     var connection = _connectionFactory[connectionType]; 

     return connection.Open().ToString(); 
    } 
} 

e registrare il IConnection implementazioni con i tasti enum:

builder.RegisterType<Engine>() 
.   As<IEngine>() 
    .InstancePerDependency(); 

builder.RegisterType<SshConnection>() 
    .Keyed<IConnection>(ConnectionType.Ssh); 
builder.RegisterType<TelnetConnection>() 
    .Keyed<IConnection>(ConnectionType.Telnet); 

Se si desidera tieni il tuo ConnectionFactory puoi registrarlo manualmente per utilizzare uno IIndex<T,B> interno con:

builder.Register<ConnectionFactory>(c => 
{ 
    var context = c.Resolve<IComponentContext>(); 
    return t => context.Resolve<IIndex<ConnectionType, IConnection>>()[t]; 
}); 

In questo caso è ancora necessario registrare i tipi IConnection come digitati ma l'implementazione Engine può rimanere invariata.