L'accès ASP.NET Core DI Conteneur De Statique de la Classe Factory

Vous pouvez éviter les classes statiques et utiliser l'Injection de Dépendance tout le chemin à travers combiné avec:

• L'utilisation de IApplicationLifetime pour démarrer/arrêter l'auditeur à chaque fois que l'application démarre/s'arrête.
• L'utilisation de IServiceProvider pour créer des instances du message processeurs.

Première chose, nous allons passer à la configuration de sa propre classe, qui peut être rempli à partir de la appsettings.json:

public class RabbitOptions
{
public string HostName { get; set; }
public string UserName { get; set; }
public string Password { get; set; }
public int Port { get; set; }
}
//In appsettings.json:
{
"Rabbit": {
"hostName": "192.168.99.100",
"username": "guest",
"password": "guest",
"port": 5672
}
}

Ensuite, convertir MessageHandlerFactory dans une situation de non-statique de la classe qui reçoit un IServiceProvider comme une dépendance. Il va utiliser le fournisseur de service pour résoudre le message processeur instances:

public class MessageHandlerFactory
{
private readonly IServiceProvider services;
public MessageHandlerFactory(IServiceProvider services)
{
this.services = services;
}
public IMessageProcessor Create(string messageType)
{
switch (messageType.ToLower())
{
case "ipset":
return services.GetService<IpSetMessageProcessor>();                
case "endpoint":
return services.GetService<EndpointMessageProcessor>();
default:
throw new Exception("Unknown message type");
}
}
}

De cette façon, votre message processeur classes peuvent recevoir dans le constructeur de toutes les dépendances dont ils ont besoin (tant que vous configurez dans Startup.ConfigureServices). Par exemple, je suis en injectant une ILogger dans un de mes échantillon de processeurs:

public class IpSetMessageProcessor : IMessageProcessor
{
private ILogger<IpSetMessageProcessor> logger;
public IpSetMessageProcessor(ILogger<IpSetMessageProcessor> logger)
{
this.logger = logger;
}
public void Process(string message)
{
logger.LogInformation("Received message: {0}", message);
}
}

Maintenant convertir MessageListener dans une situation de non-statique de la classe qui dépend IOptions<RabbitOptions> et MessageHandlerFactory.Il est très similaire à la votre celui d'origine, j'ai juste remplacé les paramètres de la méthode de Démarrage avec les options de dépendance et le gestionnaire de l'usine est maintenant une dépendance à la place d'une classe statique:

public class MessageListener
{
private readonly RabbitOptions opts;
private readonly MessageHandlerFactory handlerFactory;
private IConnection _connection;
private IModel _channel;
public MessageListener(IOptions<RabbitOptions> opts, MessageHandlerFactory handlerFactory)
{
this.opts = opts.Value;
this.handlerFactory = handlerFactory;
}
public void Start()
{
var factory = new ConnectionFactory
{
HostName = opts.HostName,
Port = opts.Port,
UserName = opts.UserName,
Password = opts.Password,
VirtualHost = "/",
AutomaticRecoveryEnabled = true,
NetworkRecoveryInterval = TimeSpan.FromSeconds(15)
};
_connection = factory.CreateConnection();
_channel = _connection.CreateModel();
_channel.ExchangeDeclare(exchange: "myExchange", type: "direct", durable: true);
var queueName = "myQueue";
QueueDeclareOk ok = _channel.QueueDeclare(queueName, true, false, false, null);
_channel.QueueBind(queue: queueName, exchange: "myExchange", routingKey: "myRoutingKey");
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += ConsumerOnReceived;
_channel.BasicConsume(queue: queueName, noAck: false, consumer: consumer);
}
public void Stop()
{
_channel.Close(200, "Goodbye");
_connection.Close();
}
private void ConsumerOnReceived(object sender, BasicDeliverEventArgs ea)
{
//get the details from the event
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
var messageType = "endpoint";  //hardcoding the message type while we dev...
//var messageType = Encoding.UTF8.GetString(ea.BasicProperties.Headers["message-type"] as byte[]);
//instantiate the appropriate handler based on the message type
IMessageProcessor processor = handlerFactory.Create(messageType);
processor.Process(message);
//Ack the event on the queue
IBasicConsumer consumer = (IBasicConsumer)sender;
consumer.Model.BasicAck(ea.DeliveryTag, false);
}
}

Près de là, vous devrez mettre à jour le Startup.ConfigureServices méthode de sorte qu'il sait au sujet de vos services et options (Vous pouvez créer des interfaces pour l'écouteur et un gestionnaire d'usine si vous voulez):

public void ConfigureServices(IServiceCollection services)
{            
//...
//Add RabbitMQ services
services.Configure<RabbitOptions>(Configuration.GetSection("rabbit"));
services.AddTransient<MessageListener>();
services.AddTransient<MessageHandlerFactory>();
services.AddTransient<IpSetMessageProcessor>();
services.AddTransient<EndpointMessageProcessor>();
}

Enfin, la mise à jour de la Startup.Configure méthode de prendre un supplément de IApplicationLifetime de paramètres et démarrer/arrêter l'auditeur de message dans le ApplicationStarted/ApplicationStopped événements (Bien que j'ai remarqué il y a quelques problèmes avec la ApplicationStopping événement à l'aide de IISExpress, comme dans cette question):

public MessageListener MessageListener { get; private set; }
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IApplicationLifetime appLifetime)
{
appLifetime.ApplicationStarted.Register(() =>
{
MessageListener = app.ApplicationServices.GetService<MessageListener>();
MessageListener.Start();
});
appLifetime.ApplicationStopping.Register(() =>
{
MessageListener.Stop();
});
//...
}

OriginalL'auteur Daniel J.G.

Voici mon avis sur votre cas:

Si possible, j'aimerais envoyer résolu service en tant que paramètre

public static IMessageProcessor Create(string messageType, IIpSetService ipService)
{
//
}

Sinon durée de vie en service serait important.

Si le service est un singleton, je voudrais juste mis de la dépendance sur la méthode configure ():

 //configure method
public IApplicationBuilder Configure(IApplicationBuilder app)
{
var ipService = app.ApplicationServices.GetService<IIpSetService>();
MessageHandlerFactory.IIpSetService = ipService;
}
//static class
public static IIpSetService IpSetService;
public static IMessageProcessor Create(string messageType)
{
//use IpSetService
}

Si la durée de vie est limitée, je voudrais utiliser HttpContextAccessor:

//Startup.cs
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
}
public IApplicationBuilder Configure(IApplicationBuilder app)
{
var httpContextAccessor= app.ApplicationServices.GetService<IHttpContextAccessor>();
MessageHandlerFactory.HttpContextAccessor = httpContextAccessor;
}
//static class
public static IHttpContextAccessor HttpContextAccessor;
public static IMessageProcessor Create(string messageType)
{
var ipSetService = HttpContextAccessor.HttpContext.RequestServices.GetService<IIpSetService>();
//use it
}

OriginalL'auteur adem caglin