public RabbitMQProducer(
     IOptions <RabbitMQOptions> options,
     IRabbitMQChannelProvider channelProvider)
 {
     this.options         = options.Value;
     this.channelProvider = channelProvider;
 }
 public RabbitMQExchangeHostedService(
     IOptions <RabbitMQOptions> options,
     IRabbitMQConnectionProvider connectionProvider)
 {
     this.options            = options.Value;
     this.connectionProvider = connectionProvider;
 }
Exemple #3
0
        public static RabbitMQOptions UseConnectionFactory(
            this RabbitMQOptions options,
            Action <ConnectionFactory> factory)
        {
            factory(options.ConnectionFactory);

            return(options);
        }
        public RabbitMQConnectionProvider(IServiceProvider serviceProvider)
        {
            connections = new ConcurrentDictionary <string, RabbitMQConnection>();
            options     = serviceProvider.GetRequiredService <IOptions <RabbitMQOptions> >().Value;

            channelLogger    = serviceProvider.GetService <ILogger <RabbitMQChannel> >();
            connectionLogger = serviceProvider.GetService <ILogger <RabbitMQConnection> >();
        }
Exemple #5
0
 public RabbitMQConsumerHostedService(
     IServiceProvider serviceProvider,
     IOptions <RabbitMQOptions> options,
     IRabbitMQConnectionProvider connectionProvider)
 {
     this.options            = options.Value;
     this.serviceProvider    = serviceProvider;
     this.connectionProvider = connectionProvider;
 }
Exemple #6
0
        public static RabbitMQOptions UseSerialization(
            this RabbitMQOptions options,
            Func <object, byte[]> serializer,
            Func <byte[], Type, object> deserializer)
        {
            options.Serializer   = serializer;
            options.Deserializer = deserializer;

            return(options);
        }
Exemple #7
0
 public RabbitMQConsumer(
     IModel channel,
     RabbitMQOptions options,
     IServiceProvider serviceProvider,
     RabbitMQConsumerDeclaration declaration,
     CancellationToken cancellationToken) : base(channel)
 {
     this.options           = options;
     this.declaration       = declaration;
     this.cancellationToken = cancellationToken;
     this.serviceProvider   = serviceProvider;
 }
 // Consumers
 public void BasicConsume(
     IServiceProvider serviceProvider,
     RabbitMQOptions options,
     RabbitMQQueueDeclaration queue,
     RabbitMQConsumerDeclaration declaration,
     CancellationToken cancellationToken)
 {
     lock (@lock)
     {
         for (var index = 0; index < declaration.Count; index++)
         {
             channel.BasicConsume(
                 queue: queue.Name,
                 autoAck: declaration.AutoAck,
                 consumerTag: declaration.Tag is null
                                                 ? string.Empty
                                                 : $"{declaration.Tag}_{index}",
                 noLocal: declaration.NoLocal,
                 exclusive: declaration.Exclusive,
                 arguments: declaration.Arguments,
                 consumer: new RabbitMQConsumer(channel, options, serviceProvider, declaration, cancellationToken));
         }
     }
 }
Exemple #9
0
 public static RabbitMQOptions UseClientProvidedName(
     this RabbitMQOptions options,
     string clientProvidedName)
 {
     return(options.UseConnectionFactory(factory => factory.ClientProvidedName = clientProvidedName));
 }
Exemple #10
0
 public static RabbitMQOptions UseConnectionUrl(
     this RabbitMQOptions options,
     string url)
 {
     return(options.UseConnectionFactory(factory => factory.Uri = new Uri(url)));
 }