EasyNetQ by Mike Hadlow,Michael Denny,Yury Pliner,Wiebe Tijsma,Contributors (see GitHub repo)

<PackageReference Include="EasyNetQ" Version="3.4.0-alpha0019" />

---

API Diff between 3.4.0-alpha0019 and 2.2.0-alpha0002

927 Additions 356 Removals

EasyNetQ

• public static class AdvancedBusExtensions
  • public static IBinding Bind(this IAdvancedBus bus, IExchange source, IExchange destination, string routingKey, CancellationToken cancellationToken = default)
  • public static IBinding Bind(this IAdvancedBus bus, IExchange source, IExchange destination, string routingKey, IDictionary<string, object> headers, CancellationToken cancellationToken = default)
  • public static IBinding Bind(this IAdvancedBus bus, IExchange exchange, IQueue queue, string routingKey, CancellationToken cancellationToken = default)
  • public static IBinding Bind(this IAdvancedBus bus, IExchange exchange, IQueue queue, string routingKey, IDictionary<string, object> headers, CancellationToken cancellationToken = default)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage, Action<IConsumerConfiguration> configure)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public static IDisposable Consume(this IAdvancedBus bus, IQueue queue, Action<IHandlerRegistration> addHandlers)
  • public static IDisposable Consume(this IAdvancedBus bus, IQueue queue, Action<byte[], MessageProperties, MessageReceivedInfo> onMessage)
  • public static IDisposable Consume(this IAdvancedBus bus, IQueue queue, Action<byte[], MessageProperties, MessageReceivedInfo> onMessage, Action<IConsumerConfiguration> configure)
  • public static IDisposable Consume(this IAdvancedBus bus, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
  • public static IDisposable Consume(this IAdvancedBus bus, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public static IExchange ExchangeDeclare(this IAdvancedBus bus, string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, string alternateExchange = null, bool delayed = false, CancellationToken cancellationToken = default)
  • public static void ExchangeDelete(this IAdvancedBus bus, IExchange exchange, bool ifUnused = false, CancellationToken cancellationToken = default)
  • public static IBasicGetResult<T> GetMessage<T>(this IAdvancedBus bus, IQueue queue, CancellationToken cancellationToken = default)
  • public static IBasicGetResult GetMessage(this IAdvancedBus bus, IQueue queue, CancellationToken cancellationToken = default)
  • public static uint GetMessagesCount(this IAdvancedBus bus, IQueue queue, CancellationToken cancellationToken = default)
  • public static void Publish(this IAdvancedBus bus, IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body, CancellationToken cancellationToken = default)
  • public static void Publish<T>(this IAdvancedBus bus, IExchange exchange, string routingKey, bool mandatory, IMessage<T> message, CancellationToken cancellationToken = default)
  • public static IQueue QueueDeclare(this IAdvancedBus bus, CancellationToken cancellationToken = default)
  • public static IQueue QueueDeclare(this IAdvancedBus bus, string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int? perQueueMessageTtl = default, int? expires = default, int? maxPriority = default, string deadLetterExchange = null, string deadLetterRoutingKey = null, int? maxLength = default, int? maxLengthBytes = default, CancellationToken cancellationToken = default)
  • public static void QueueDelete(this IAdvancedBus bus, IQueue queue, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • public static void QueuePurge(this IAdvancedBus bus, IQueue queue, CancellationToken cancellationToken = default)
  • public static void Unbind(this IAdvancedBus bus, IBinding binding, CancellationToken cancellationToken = default)
• public sealed delegate CancelSubscription : MulticastDelegate
• public class ComponentRegistration
• public class ConnectionConfiguration
  • public bool CancelOnHaFailover { get; set; }
• public class DefaultMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage<T> DeserializeMessage<T>(MessageProperties properties, byte[] body)
• public class DefaultServiceProvider : IContainer, IServiceProvider, IServiceRegister
• public class DefaultTypeNameSerializer : ITypeNameSerializer
  • public DefaultTypeNameSerializer()
  • public Type DeSerialize(string typeName)
  • public string Serialize(Type type)
• public class EasyNetQInvalidMessageTypeException : EasyNetQException
• public sealed delegate ErrorQueueNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(MessageReceivedInfo info, AsyncCallback callback, object object)
  • public virtual string Invoke()
  • public virtual string Invoke(MessageReceivedInfo info)
• public class EventBus : IEventBus
  • public CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
  • public IDisposable Subscribe<TEvent>(Action<TEvent> eventHandler)
• public static class Extensions
  • public static TimeSpan Double(this TimeSpan timeSpan)
  • public static void SafeDispose(this IDisposable disposable)
  • public static string Trim(this string s, int start, int length)
• public interface IAdvancedBus : IDisposable
  • IContainer Container { get; }
  • IServiceResolver Container { get; }
  • IBinding Bind(IExchange exchange, IQueue queue, string routingKey)
  • IBinding Bind(IExchange exchange, IQueue queue, string routingKey, IDictionary<string, object> headers)
  • IBinding Bind(IExchange source, IExchange destination, string routingKey)
  • IBinding Bind(IExchange source, IExchange destination, string routingKey, IDictionary<string, object> headers)
  • Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey)
  • Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey, IDictionary<string, object> headers)
  • Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey)
  • Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey, IDictionary<string, object> headers)
  • void BindingDelete(IBinding binding)
  • Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey, CancellationToken cancellationToken = default)
  • Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey, IDictionary<string, object> headers, CancellationToken cancellationToken = default)
  • Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey, CancellationToken cancellationToken = default)
  • Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey, IDictionary<string, object> headers, CancellationToken cancellationToken = default)
  • IDisposable Consume<T>(IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage)
  • IDisposable Consume<T>(IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Consume(IQueue queue, Action<IHandlerRegistration> addHandlers)
  • IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Consume(IQueue queue, Action<byte[], MessageProperties, MessageReceivedInfo> onMessage)
  • IDisposable Consume(IQueue queue, Action<byte[], MessageProperties, MessageReceivedInfo> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
  • IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • IExchange ExchangeDeclare(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null, bool delayed = false)
  • Task<IExchange> ExchangeDeclareAsync(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null, bool delayed = false)
  • void ExchangeDelete(IExchange exchange, bool ifUnused = false)
  • IBasicGetResult<T> Get<T>(IQueue queue)
  • IBasicGetResult Get(IQueue queue)
  • uint MessageCount(IQueue queue)
  • void Publish(IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body)
  • void Publish<T>(IExchange exchange, string routingKey, bool mandatory, IMessage<T> message)
  • Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, IMessage message)
  • Task PublishAsync<T>(IExchange exchange, string routingKey, bool mandatory, IMessage<T> message)
  • Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body)
  • IQueue QueueDeclare(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int? perQueueMessageTtl = default, int? expires = default, int? maxPriority = default, string deadLetterExchange = null, string deadLetterRoutingKey = null, int? maxLength = default, int? maxLengthBytes = default)
  • Task<IQueue> QueueDeclareAsync(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int? perQueueMessageTtl = default, int? expires = default, int? maxPriority = default, string deadLetterExchange = null, string deadLetterRoutingKey = null, int? maxLength = default, int? maxLengthBytes = default)
  • void QueueDelete(IQueue queue, bool ifUnused = false, bool ifEmpty = false)
  • void QueuePurge(IQueue queue)
  • IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure)
  • Task<IExchange> ExchangeDeclareAsync(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, string alternateExchange = null, bool delayed = false, CancellationToken cancellationToken = default)
  • Task ExchangeDeleteAsync(IExchange exchange, bool ifUnused = false, CancellationToken cancellationToken = default)
  • Task<IBasicGetResult<T>> GetMessageAsync<T>(IQueue queue, CancellationToken cancellationToken = default)
  • Task<IBasicGetResult> GetMessageAsync(IQueue queue, CancellationToken cancellationToken = default)
  • Task<uint> GetMessagesCountAsync(IQueue queue, CancellationToken cancellationToken = default)
  • Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, IMessage message, CancellationToken cancellationToken = default)
  • Task PublishAsync<T>(IExchange exchange, string routingKey, bool mandatory, IMessage<T> message, CancellationToken cancellationToken = default)
  • Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body, CancellationToken cancellationToken = default)
  • Task<IQueue> QueueDeclareAsync(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int? perQueueMessageTtl = default, int? expires = default, int? maxPriority = default, string deadLetterExchange = null, string deadLetterRoutingKey = null, int? maxLength = default, int? maxLengthBytes = default, CancellationToken cancellationToken = default)
  • Task<IQueue> QueueDeclareAsync(CancellationToken cancellationToken = default)
  • Task QueueDeleteAsync(IQueue queue, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • Task QueuePurgeAsync(IQueue queue, CancellationToken cancellationToken = default)
  • Task UnbindAsync(IBinding binding, CancellationToken cancellationToken = default)
• public interface IBus : IDisposable
  • bool IsConnected { get; }
  • void Publish<T>(T message)
  • void Publish<T>(T message, Action<IPublishConfiguration> configure)
  • void Publish<T>(T message, string topic)
  • Task PublishAsync<T>(T message)
  • Task PublishAsync<T>(T message, Action<IPublishConfiguration> configure)
  • Task PublishAsync<T>(T message, string topic)
  • IDisposable Receive<T>(string queue, Action<T> onMessage)
  • IDisposable Receive<T>(string queue, Action<T> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers, Action<IConsumerConfiguration> configure)
  • TResponse Request<TRequest, TResponse>(TRequest request)
  • TResponse Request<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder, Action<IResponderConfiguration> configure)
  • IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, Action<IResponderConfiguration> configure)
  • void Send<T>(string queue, T message)
  • Task SendAsync<T>(string queue, T message)
  • ISubscriptionResult Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • ISubscriptionResult Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • ISubscriptionResult SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • ISubscriptionResult SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
  • IPubSub PubSub { get; }
  • IRpc Rpc { get; }
  • IScheduler Scheduler { get; }
  • ISendReceive SendReceive { get; }
• public interface IContainer : IServiceProvider, IServiceRegister
• public interface IEasyNetQLogger
• public interface IEventBus
  • CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
  • IDisposable Subscribe<TEvent>(Action<TEvent> eventHandler)
• public interface IMessageSerializationStrategy
  • IMessage<T> DeserializeMessage<T>(MessageProperties properties, byte[] body)
• public interface ISerializer
  • object BytesToMessage(string typeName, byte[] bytes)
  • object BytesToMessage(Type type, byte[] bytes)
• public interface IServiceProvider
• public interface IServiceRegister
• public class JsonSerializer : ISerializer
  • public JsonSerializer(ITypeNameSerializer typeNameSerializer)
  • public JsonSerializer()
  • public JsonSerializer(JsonSerializerSettings serializerSettings)
  • public object BytesToMessage(string typeName, byte[] bytes)
  • public object BytesToMessage(Type type, byte[] bytes)
• public class LegacyTypeNameSerializer : ITypeNameSerializer
  • public LegacyTypeNameSerializer()
  • public Type DeSerialize(string typeName)
  • public string Serialize(Type type)
• public static class LegacyTypeNamingExtensions
  • public static IServiceRegister EnableLegacyTypeNaming(this IServiceRegister serviceRegister)
• public class Message<T> : IMessage<T>, IMessage
  • public void SetProperties(MessageProperties properties)
• public class PersistentConnection : IPersistentConnection, IDisposable
  • public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger, IEventBus eventBus)
  • public PersistentConnection(IConnectionFactory connectionFactory, IEventBus eventBus)
  • public void OnConnected()
  • public void OnDisconnected()
• public class PersistentConnectionFactory : IPersistentConnectionFactory
  • public PersistentConnectionFactory(IEasyNetQLogger logger, IConnectionFactory connectionFactory, IEventBus eventBus)
  • public PersistentConnectionFactory(IConnectionFactory connectionFactory, IEventBus eventBus)
• public class QueueConsumerPair
  • public Func<byte[], MessageProperties, MessageReceivedInfo, Task> OnMessage { get; }
  • public Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> OnMessage { get; }
• public class RabbitAdvancedBus : IAdvancedBus, IDisposable
  • public IContainer Container { get; }
  • public IServiceResolver Container { get; }
  • public RabbitAdvancedBus(IConnectionFactory connectionFactory, IConsumerFactory consumerFactory, IEasyNetQLogger logger, IClientCommandDispatcherFactory clientCommandDispatcherFactory, IPublishConfirmationListener confirmationListener, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, IContainer container, ConnectionConfiguration connectionConfiguration, IProduceConsumeInterceptor produceConsumeInterceptor, IMessageSerializationStrategy messageSerializationStrategy, IConventions conventions, AdvancedBusEventHandlers advancedBusEventHandlers, IPersistentConnectionFactory persistentConnectionFactory)
  • public virtual IBinding Bind(IExchange exchange, IQueue queue, string routingKey)
  • public virtual IBinding Bind(IExchange exchange, IQueue queue, string routingKey, IDictionary<string, object> headers)
  • public virtual IBinding Bind(IExchange source, IExchange destination, string routingKey)
  • public virtual IBinding Bind(IExchange source, IExchange destination, string routingKey, IDictionary<string, object> headers)
  • public Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey)
  • public Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey, IDictionary<string, object> headers)
  • public Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey)
  • public Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey, IDictionary<string, object> headers)
  • public virtual void BindingDelete(IBinding binding)
  • public RabbitAdvancedBus(IConnectionFactory connectionFactory, IConsumerFactory consumerFactory, IClientCommandDispatcherFactory clientCommandDispatcherFactory, IPublishConfirmationListener confirmationListener, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, IServiceResolver container, ConnectionConfiguration connectionConfiguration, IProduceConsumeInterceptor produceConsumeInterceptor, IMessageSerializationStrategy messageSerializationStrategy, IConventions conventions, AdvancedBusEventHandlers advancedBusEventHandlers, IPersistentConnectionFactory persistentConnectionFactory)
  • public Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey, CancellationToken cancellationToken)
  • public Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey, IDictionary<string, object> headers, CancellationToken cancellationToken)
  • public Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey, CancellationToken cancellationToken)
  • public Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey, IDictionary<string, object> headers, CancellationToken cancellationToken)
  • public IDisposable Consume<T>(IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage)
  • public IDisposable Consume<T>(IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • public IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Consume(IQueue queue, Action<IHandlerRegistration> addHandlers)
  • public IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public IDisposable Consume(IQueue queue, Action<byte[], MessageProperties, MessageReceivedInfo> onMessage)
  • public IDisposable Consume(IQueue queue, Action<byte[], MessageProperties, MessageReceivedInfo> onMessage, Action<IConsumerConfiguration> configure)
  • public IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
  • public virtual IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IExchange ExchangeDeclare(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null, bool delayed = false)
  • public Task<IExchange> ExchangeDeclareAsync(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null, bool delayed = false)
  • public virtual void ExchangeDelete(IExchange exchange, bool ifUnused = false)
  • public IBasicGetResult<T> Get<T>(IQueue queue)
  • public IBasicGetResult Get(IQueue queue)
  • public uint MessageCount(IQueue queue)
  • public Task<IExchange> ExchangeDeclareAsync(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, string alternateExchange = null, bool delayed = false, CancellationToken cancellationToken = default)
  • public virtual Task ExchangeDeleteAsync(IExchange exchange, bool ifUnused = false, CancellationToken cancellationToken = default)
  • public Task<IBasicGetResult<T>> GetMessageAsync<T>(IQueue queue, CancellationToken cancellationToken)
  • public Task<IBasicGetResult> GetMessageAsync(IQueue queue, CancellationToken cancellationToken)
  • public Task<uint> GetMessagesCountAsync(IQueue queue, CancellationToken cancellationToken)
  • public void Publish(IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body)
  • public void Publish<T>(IExchange exchange, string routingKey, bool mandatory, IMessage<T> message)
  • public virtual Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, IMessage message)
  • public virtual Task PublishAsync<T>(IExchange exchange, string routingKey, bool mandatory, IMessage<T> message)
  • public virtual Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body)
  • public virtual IQueue QueueDeclare(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int? perQueueMessageTtl = default, int? expires = default, int? maxPriority = default, string deadLetterExchange = null, string deadLetterRoutingKey = null, int? maxLength = default, int? maxLengthBytes = default)
  • public Task<IQueue> QueueDeclareAsync(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int? perQueueMessageTtl = default, int? expires = default, int? maxPriority = default, string deadLetterExchange = null, string deadLetterRoutingKey = null, int? maxLength = default, int? maxLengthBytes = default)
  • public virtual void QueueDelete(IQueue queue, bool ifUnused = false, bool ifEmpty = false)
  • public virtual void QueuePurge(IQueue queue)
  • public virtual Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, IMessage message, CancellationToken cancellationToken)
  • public virtual Task PublishAsync<T>(IExchange exchange, string routingKey, bool mandatory, IMessage<T> message, CancellationToken cancellationToken)
  • public virtual Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body, CancellationToken cancellationToken)
  • public Task<IQueue> QueueDeclareAsync(CancellationToken cancellationToken)
  • public Task<IQueue> QueueDeclareAsync(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int? perQueueMessageTtl = default, int? expires = default, int? maxPriority = default, string deadLetterExchange = null, string deadLetterRoutingKey = null, int? maxLength = default, int? maxLengthBytes = default, CancellationToken cancellationToken = default)
  • public virtual Task QueueDeleteAsync(IQueue queue, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • public virtual Task QueuePurgeAsync(IQueue queue, CancellationToken cancellationToken)
  • public virtual Task UnbindAsync(IBinding binding, CancellationToken cancellationToken)
• public class RabbitBus : IBus, IDisposable
  • public virtual bool IsConnected { get; }
  • public RabbitBus(IConventions conventions, IAdvancedBus advancedBus, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, IRpc rpc, ISendReceive sendReceive, ConnectionConfiguration connectionConfiguration)
  • public IPubSub PubSub { get; }
  • public IRpc Rpc { get; }
  • public IScheduler Scheduler { get; }
  • public ISendReceive SendReceive { get; }
  • public RabbitBus(IAdvancedBus advanced, IPubSub pubSub, IRpc rpc, ISendReceive sendReceive, IScheduler scheduler)
  • public virtual void Publish<T>(T message)
  • public virtual void Publish<T>(T message, string topic)
  • public virtual void Publish<T>(T message, Action<IPublishConfiguration> configure)
  • public virtual Task PublishAsync<T>(T message)
  • public virtual Task PublishAsync<T>(T message, string topic)
  • public virtual Task PublishAsync<T>(T message, Action<IPublishConfiguration> configure)
  • public virtual IDisposable Receive<T>(string queue, Action<T> onMessage)
  • public virtual IDisposable Receive<T>(string queue, Action<T> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • public virtual IDisposable Receive<T>(string queue, Func<T, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • public virtual IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers, Action<IConsumerConfiguration> configure)
  • public virtual TResponse Request<TRequest, TResponse>(TRequest request)
  • public virtual TResponse Request<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure)
  • public virtual Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • public virtual Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure)
  • public virtual IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • public IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder, Action<IResponderConfiguration> configure)
  • public virtual IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • public IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, Action<IResponderConfiguration> configure)
  • public virtual void Send<T>(string queue, T message)
  • public virtual Task SendAsync<T>(string queue, T message)
  • public virtual ISubscriptionResult Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • public virtual ISubscriptionResult Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • public virtual ISubscriptionResult SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • public virtual ISubscriptionResult SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
• public static class RabbitHutch
  • public static IBus CreateBus(string connectionString, AdvancedBusEventHandlers advancedBusEventHandlers)
  • public static IBus CreateBus(string connectionString, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string connectionString, AdvancedBusEventHandlers advancedBusEventHandlers, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string hostName, ushort hostPort, string virtualHost, string username, string password, ushort requestedHeartbeat, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string hostName, ushort hostPort, string virtualHost, string username, string password, ushort requestedHeartbeat, AdvancedBusEventHandlers advancedBusEventHandlers, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(ConnectionConfiguration connectionConfiguration, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(ConnectionConfiguration connectionConfiguration, AdvancedBusEventHandlers advancedBusEventHandlers, Action<IServiceRegister> registerServices)
  • public static void SetContainerFactory(Func<IContainer> createContainer)
  • public static IBus CreateBus(string connectionString, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string hostName, ushort hostPort, string virtualHost, string username, string password, ushort requestedHeartbeat, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(ConnectionConfiguration connectionConfiguration, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(Func<IServiceResolver, ConnectionConfiguration> connectionConfigurationFactory, Action<IServiceRegister> registerServices)
  • public static void RegisterBus(IServiceRegister serviceRegister, Func<IServiceResolver, ConnectionConfiguration> connectionConfigurationFactory, Action<IServiceRegister> registerServices)
• public static class ReflectionHelpers
  • public static T CreateInstance<T>()
  • public static object CreateInstance(Type objectType, object arg)
  • public static object CreateInstance(Type objectType, object firstArg, object secondArg)
• public sealed class SubscriptionResult : ISubscriptionResult, IDisposable
  • public IDisposable ConsumerCancellation { get; }
  • public IExchange Exchange { get; }
  • public IQueue Queue { get; }
  • public SubscriptionResult(IExchange exchange, IQueue queue, IDisposable consumerCancellation)
  • public void Dispose()
• public sealed class TimeBudget
  • public TimeBudget(TimeSpan budget, TimeSpan precision)
  • public TimeBudget(TimeSpan budget)
  • public TimeSpan GetRemainingTime()
  • public static TimeBudget Infinite()
  • public static TimeSpan op_Implicit(TimeBudget source)
  • public static TimeBudget Start(TimeSpan budget)
  • public TimeBudget Start()
• public class TypeNameSerializer : ITypeNameSerializer

EasyNetQ.AmqpExceptions

• public class AmapExceptionPreface
• public class AmqpException
  • public AmapExceptionPreface Preface { get; }
  • public AmqpException(AmapExceptionPreface preface, IList<IAmqpExceptionElement> elements)
  • public AmqpExceptionPreface Preface { get; }
  • public AmqpException(AmqpExceptionPreface preface, IList<IAmqpExceptionElement> elements)
• public class AmqpExceptionPreface
  • public string Text { get; }
  • public AmqpExceptionPreface(string text)

EasyNetQ.AutoSubscribe

• public class AutoSubscriber
  • protected const string ConsumeMethodName = "Consume"
  • protected const string DispatchAsyncMethodName = "DispatchAsync"
  • protected const string DispatchMethodName = "Dispatch"
  • protected readonly IBus bus
  • protected readonly IBus Bus
  • protected virtual MethodInfo GetSubscribeMethodOfBus(string methodName, Type parmType)
  • protected virtual IEnumerable<AutoSubscriberConsumerInfo> GetSubscriberConsumerInfos(IEnumerable<Type> types, Type interfaceType)
  • protected virtual IEnumerable<KeyValuePair<Type, AutoSubscriberConsumerInfo[]>> GetSubscriptionInfos(IEnumerable<Type> types, Type interfaceType)
  • protected virtual void InvokeMethods(IEnumerable<KeyValuePair<Type, AutoSubscriberConsumerInfo[]>> subscriptionInfos, string dispatchName, MethodInfo genericBusSubscribeMethod, Func<Type, Type> subscriberTypeFromMessageTypeDelegate)
  • protected virtual bool IsValidMarkerType(Type markerType)
  • public virtual void Subscribe(Assembly[] assemblies)
  • public virtual void Subscribe(Type[] consumerTypes)
  • public virtual void SubscribeAsync(Assembly[] assemblies)
  • public virtual void SubscribeAsync(Type[] consumerTypes)
  • public virtual Task<IDisposable> SubscribeAsync(Type[] consumerTypes, CancellationToken cancellationToken = default)
• public class AutoSubscriberConsumerInfo
  • public readonly Type ConcreteType
  • public readonly Type InterfaceType
  • public readonly Type MessageType
  • public Type ConcreteType { get; }
  • public MethodInfo ConsumeMethod { get; }
  • public Type MessageType { get; }
• public static class AutoSubscriberExtensions
  • public static IDisposable Subscribe(this AutoSubscriber autoSubscriber, Assembly[] assemblies, CancellationToken cancellationToken = default)
  • public static IDisposable Subscribe(this AutoSubscriber autoSubscriber, Type[] consumerTypes, CancellationToken cancellationToken = default)
  • public static Task<IDisposable> SubscribeAsync(this AutoSubscriber autoSubscriber, Assembly[] assemblies, CancellationToken cancellationToken = default)
• public class DefaultAutoSubscriberMessageDispatcher : IAutoSubscriberMessageDispatcher
  • public DefaultAutoSubscriberMessageDispatcher(IServiceResolver resolver)
  • public void Dispatch<TMessage, TConsumer>(TMessage message) where TConsumer : IConsume<TMessage>
  • public Task DispatchAsync<TMessage, TConsumer>(TMessage message) where TConsumer : IConsumeAsync<TMessage>
  • public void Dispatch<TMessage, TConsumer>(TMessage message, CancellationToken cancellationToken = default) where TConsumer : IConsume<TMessage>
  • public Task DispatchAsync<TMessage, TAsyncConsumer>(TMessage message, CancellationToken cancellationToken = default) where TAsyncConsumer : IConsumeAsync<TMessage>
• public interface IAutoSubscriberMessageDispatcher
  • void Dispatch<TMessage, TConsumer>(TMessage message) where TConsumer : IConsume<TMessage>
  • Task DispatchAsync<TMessage, TConsumer>(TMessage message) where TConsumer : IConsumeAsync<TMessage>
  • void Dispatch<TMessage, TConsumer>(TMessage message, CancellationToken cancellationToken = default) where TConsumer : IConsume<TMessage>
  • Task DispatchAsync<TMessage, TConsumer>(TMessage message, CancellationToken cancellationToken = default) where TConsumer : IConsumeAsync<TMessage>
• public interface IConsume<T>
  • void Consume(T message)
  • void Consume(T message, CancellationToken cancellationToken = default)
• public interface IConsumeAsync<T>
  • Task Consume(T message)
  • Task ConsumeAsync(T message, CancellationToken cancellationToken = default)
• public class SubscriptionConfigurationAttribute : Attribute
  • public bool CancelOnHaFailover { get; set; }

EasyNetQ.Consumer

• public static class AckStrategies
  • public static AckStrategy Nothing
• public class BasicConsumer : IBasicConsumer, IDisposable
  • public Func<byte[], MessageProperties, MessageReceivedInfo, Task> OnMessage { get; }
  • public Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> OnMessage { get; }
  • public BasicConsumer(Action<BasicConsumer> cancelled, IConsumerDispatcher consumerDispatcher, IQueue queue, IEventBus eventBus, IHandlerRunner handlerRunner, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IEasyNetQLogger logger, IModel model)
  • public BasicConsumer(Action<BasicConsumer> cancelled, IConsumerDispatcher consumerDispatcher, IQueue queue, IEventBus eventBus, IHandlerRunner handlerRunner, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IModel model)
• public class ConsumerCancellation : IDisposable
  • public sealed delegate ConsumerCancel : MulticastDelegate
  • public event ConsumerCancel ConsumerCancelled
  • public void OnCancel(object queue)
• public class ConsumerConfiguration : IConsumerConfiguration
  • public bool CancelOnHaFailover { get; }
  • public IConsumerConfiguration AsExclusive()
  • public IConsumerConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • public IConsumerConfiguration WithExclusive(bool isExclusive)
• public class ConsumerDispatcher : IConsumerDispatcher, IDisposable
  • public ConsumerDispatcher(ConnectionConfiguration configuration, IEasyNetQLogger logger)
  • public ConsumerDispatcher(ConnectionConfiguration configuration)
• public class ConsumerDispatcherFactory : IConsumerDispatcherFactory, IDisposable
  • public ConsumerDispatcherFactory(ConnectionConfiguration configuration, IEasyNetQLogger logger)
  • public ConsumerDispatcherFactory(ConnectionConfiguration configuration)
• public class ConsumerExecutionContext
  • public IBasicConsumer Consumer { get; }
  • public Func<byte[], MessageProperties, MessageReceivedInfo, Task> UserHandler { get; }
  • public ConsumerExecutionContext(Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler, MessageReceivedInfo info, MessageProperties properties, byte[] body, IBasicConsumer consumer)
  • public Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> UserHandler { get; }
  • public ConsumerExecutionContext(Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> userHandler, MessageReceivedInfo info, MessageProperties properties, byte[] body)
• public class ConsumerFactory : IConsumerFactory, IDisposable
  • public IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
  • public IConsumer CreateConsumer(ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, Task>>> queueConsumerPairs, IPersistentConnection connection, IConsumerConfiguration configuration)
  • public IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
  • public IConsumer CreateConsumer(ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task>>> queueConsumerPairs, IPersistentConnection connection, IConsumerConfiguration configuration)
• public class DefaultConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable
  • public DefaultConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer, IEasyNetQLogger logger, IConventions conventions, ITypeNameSerializer typeNameSerializer, IErrorMessageSerializer errorMessageSerializer)
  • protected IConnection Connection { get; }
  • public DefaultConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer, IConventions conventions, ITypeNameSerializer typeNameSerializer, IErrorMessageSerializer errorMessageSerializer)
  • protected void Connect()
• public class ExclusiveConsumer : IConsumer, IDisposable
  • public ExclusiveConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public ExclusiveConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
• public class HandlerCollection : IHandlerCollection, IHandlerRegistration
  • public HandlerCollection(IEasyNetQLogger logger)
  • public IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • public IHandlerRegistration Add<T>(Action<IMessage<T>, MessageReceivedInfo> handler)
  • public Func<IMessage<T>, MessageReceivedInfo, Task> GetHandler<T>()
  • public Func<IMessage, MessageReceivedInfo, Task> GetHandler(Type messageType)
  • public HandlerCollection()
  • public IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler)
  • public Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> GetHandler<T>()
  • public Func<IMessage, MessageReceivedInfo, CancellationToken, Task> GetHandler(Type messageType)
• public class HandlerCollectionFactory : IHandlerCollectionFactory
  • public HandlerCollectionFactory(IEasyNetQLogger logger)
  • public HandlerCollectionFactory()
• public class HandlerCollectionPerQueueFactory : IHandlerCollectionFactory
  • public HandlerCollectionPerQueueFactory(IEasyNetQLogger logger)
  • public HandlerCollectionPerQueueFactory()
• public static class HandlerRegistrationExtensions
  • public static IHandlerRegistration Add<T>(this IHandlerRegistration handlerRegistration, Action<IMessage<T>, MessageReceivedInfo> handler)
  • public static IHandlerRegistration Add<T>(this IHandlerRegistration handlerRegistration, Func<IMessage<T>, MessageReceivedInfo, Task> handler)
• public class HandlerRunner : IHandlerRunner, IDisposable
  • public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus)
  • protected virtual string BuildErrorMessage(ConsumerExecutionContext context, Exception exception)
  • public HandlerRunner(IConsumerErrorStrategy consumerErrorStrategy)
  • protected virtual void Dispose(bool disposing)
  • protected virtual void DoAck(ConsumerExecutionContext context, AckStrategy ackStrategy)
  • protected virtual AckStrategy GetAckStrategy(ConsumerExecutionContext context, Task task)
  • public virtual void InvokeUserMessageHandler(ConsumerExecutionContext context)
  • public virtual Task<AckStrategy> InvokeUserMessageHandlerAsync(ConsumerExecutionContext context, CancellationToken cancellationToken)
• public interface IConsumerConfiguration
  • bool CancelOnHaFailover { get; }
  • IConsumerConfiguration AsExclusive()
  • IConsumerConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • IConsumerConfiguration WithExclusive(bool isExclusive)
• public interface IConsumerFactory : IDisposable
  • IConsumer CreateConsumer(ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, Task>>> queueConsumerPairs, IPersistentConnection connection, IConsumerConfiguration configuration)
  • IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
  • IConsumer CreateConsumer(ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task>>> queueConsumerPairs, IPersistentConnection connection, IConsumerConfiguration configuration)
  • IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
• public interface IHandlerCollection : IHandlerRegistration
  • Func<IMessage<T>, MessageReceivedInfo, Task> GetHandler<T>()
  • Func<IMessage, MessageReceivedInfo, Task> GetHandler(Type messageType)
  • Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> GetHandler<T>()
  • Func<IMessage, MessageReceivedInfo, CancellationToken, Task> GetHandler(Type messageType)
• public interface IHandlerRegistration
  • IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • IHandlerRegistration Add<T>(Action<IMessage<T>, MessageReceivedInfo> handler)
  • IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler)
• public interface IHandlerRunner : IDisposable
  • void InvokeUserMessageHandler(ConsumerExecutionContext context)
  • Task<AckStrategy> InvokeUserMessageHandlerAsync(ConsumerExecutionContext context, CancellationToken cancellationToken = default)
• public interface IInternalConsumer : IDisposable
  • StartConsumingStatus StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
  • StartConsumingStatus StartConsuming(IPersistentConnection connection, ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, Task>>> queueConsumerPairs, IConsumerConfiguration configuration)
  • StartConsumingStatus StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IConsumerConfiguration configuration)
  • StartConsumingStatus StartConsuming(IPersistentConnection connection, ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task>>> queueConsumerPairs, IConsumerConfiguration configuration)
• public class InternalConsumer : IInternalConsumer, IDisposable
  • public event EventHandler<ConsumerEventArgs> ConsumerCancelled
  • public InternalConsumer(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConsumerDispatcher consumerDispatcher, IConventions conventions, ConnectionConfiguration connectionConfiguration, IEventBus eventBus)
  • public InternalConsumer(IHandlerRunner handlerRunner, IConsumerDispatcher consumerDispatcher, IConventions conventions, IEventBus eventBus)
  • public StartConsumingStatus StartConsuming(IPersistentConnection connection, ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, Task>>> queueConsumerPairs, IConsumerConfiguration configuration)
  • public StartConsumingStatus StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
  • public StartConsumingStatus StartConsuming(IPersistentConnection connection, ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task>>> queueConsumerPairs, IConsumerConfiguration configuration)
  • public StartConsumingStatus StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IConsumerConfiguration configuration)
• public class InternalConsumerFactory : IInternalConsumerFactory, IDisposable
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConventions conventions, ConnectionConfiguration connectionConfiguration, IConsumerDispatcherFactory consumerDispatcherFactory, IEventBus eventBus)
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IConventions conventions, IConsumerDispatcherFactory consumerDispatcherFactory, IEventBus eventBus)
• public interface IReceiveRegistration
• public class PersistentConsumer : IConsumer, IDisposable
  • public PersistentConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public PersistentConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
• public class PersistentMultipleConsumer : IConsumer, IDisposable
  • public PersistentMultipleConsumer(ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, Task>>> queueConsumerPairs, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public PersistentMultipleConsumer(ICollection<Tuple<IQueue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task>>> queueConsumerPairs, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
• public class SubscriptionResult : ISubscriptionResult, IDisposable
• public class TransientConsumer : IConsumer, IDisposable
  • public TransientConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public TransientConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)

EasyNetQ.DI

• public class DefaultServiceContainer : IServiceRegister
  • public DefaultServiceContainer()
  • public IServiceRegister Register<TService, TImplementation>(Lifetime lifetime = 1) where TImplementation : TService
  • public IServiceRegister Register<TService>(TService instance)
  • public IServiceRegister Register<TService>(Func<IServiceResolver, TService> factory, Lifetime lifetime = 1)
  • public TService Resolve<TService>()
• public static class DefaultServicesRegistration
  • public static void RegisterDefaultServices(this IServiceRegister container)
• public interface IServiceRegister
  • IServiceRegister Register<TService, TImplementation>(Lifetime lifetime = 1) where TImplementation : TService
  • IServiceRegister Register<TService>(TService instance)
  • IServiceRegister Register<TService>(Func<IServiceResolver, TService> factory, Lifetime lifetime = 1)
• public interface IServiceResolver
  • IServiceResolverScope CreateScope()
  • TService Resolve<TService>()
• public interface IServiceResolverScope : IServiceResolver, IDisposable
• public enum Lifetime
  • Singleton = 1
  • Transient = 0
• public class ServiceResolverScope : IServiceResolverScope, IServiceResolver, IDisposable
  • public ServiceResolverScope(IServiceResolver resolver)
  • public IServiceResolverScope CreateScope()
  • public void Dispose()
  • public TService Resolve<TService>()

EasyNetQ.Events

• public enum AckResult
  • Nothing = 3

EasyNetQ.FluentConfiguration

• public interface ISubscriptionConfiguration
  • ISubscriptionConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
• public class SubscriptionConfiguration : ISubscriptionConfiguration
  • public bool CancelOnHaFailover { get; }
  • public ISubscriptionConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)

EasyNetQ.Interception

• public static class InterceptionExtensions
  • public static IServiceRegister EnableInterception(this IServiceRegister serviceRegister, Action<IInterceptorRegistrator> configure)
  • public static IServiceRegister EnableInterception(this IServiceRegister serviceRegister, Action<IInterceptorRegistrator> configure)
• public class InterceptorRegistrator : IInterceptorRegistrator
  • public InterceptorRegistrator(IServiceRegister serviceRegister)
  • public InterceptorRegistrator(IServiceRegister serviceRegister)
  • public IServiceRegister Register()
  • public IServiceRegister Register()

EasyNetQ.Internals

• public class AsyncSemaphore
• public sealed class AsyncLock
  • public AsyncLock()
  • public Task<IDisposable> AcquireAsync(CancellationToken cancellationToken = default)
• public struct AwaitableDisposable<T> where T : IDisposable
  • public AwaitableDisposable(Task<T> task)
  • public static Task<T> op_Implicit(AwaitableDisposable<T> source)
  • public Task<T> AsTask()
  • public ConfiguredTaskAwaitable<T> ConfigureAwait(bool continueOnCapturedContext)
  • public TaskAwaiter<T> GetAwaiter()
• public static class AwaitableDisposableExtensions
  • public static AwaitableDisposable<T> ToAwaitableDisposable<T>(this Task<T> source) where T : IDisposable
• public static class TaskHelpers
  • public static readonly Task Completed
  • public static Task Delay(TimeSpan delay, CancellationToken cancellation)
  • public static Task ExecuteSynchronously(Action action)
  • public static Task Completed { get; }
  • public static TaskCompletionSource<T> CreateTcs<T>()
  • public static Func<T1, T2, T3, CancellationToken, Task> FromAction<T1, T2, T3>(Action<T1, T2, T3, CancellationToken> action)
  • public static Func<T1, T2, CancellationToken, Task> FromAction<T1, T2>(Action<T1, T2, CancellationToken> action)
  • public static Func<T1, CancellationToken, Task> FromAction<T1>(Action<T1, CancellationToken> action)
  • public static Task FromCancelled()
  • public static Task<T> FromCancelled<T>()
  • public static Task<T> FromException<T>(Exception exception)
  • public static Func<T1, CancellationToken, Task<T2>> FromFunc<T1, T2>(Func<T1, CancellationToken, T2> func)
  • public static void TrySetCanceledSafe<T>(this TaskCompletionSource<T> source)
  • public static void TrySetExceptionSafe<T>(this TaskCompletionSource<T> source, Exception exception)
  • public static void TrySetResultSafe<T>(this TaskCompletionSource<T> source, T result)
  • public static Task<Task> WhenAny(Task[] tasks)
  • public static void TrySetCanceledAsynchronously<T>(this TaskCompletionSource<T> source)
  • public static void TrySetExceptionAsynchronously<T>(this TaskCompletionSource<T> source, Exception exception)
  • public static void TrySetResultAsynchronously<T>(this TaskCompletionSource<T> source, T result)
• public static class Timers
  • public static void RunOnce(TimerCallback callback, TimeSpan dueTime)
  • public static IDisposable Start(TimerCallback callback, TimeSpan dueTime, TimeSpan period)

EasyNetQ.LightInject

• public class AssemblyScanner : IAssemblyScanner
  • public AssemblyScanner(ITypeExtractor concreteTypeExtractor, ITypeExtractor compositionRootTypeExtractor, ICompositionRootExecutor compositionRootExecutor, IGenericArgumentMapper genericArgumentMapper)
  • public void Scan(Assembly assembly, IServiceRegistry serviceRegistry, Func<ILifetime> lifetimeFactory, Func<Type, Type, bool> shouldRegister, Func<Type, Type, string> serviceNameProvider)
  • public void Scan(Assembly assembly, IServiceRegistry serviceRegistry)
• public class CachedTypeExtractor : ITypeExtractor
  • public CachedTypeExtractor(ITypeExtractor typeExtractor)
  • public Type[] Execute(Assembly assembly)
• public class CompositionRootAttributeExtractor : ICompositionRootAttributeExtractor
  • public CompositionRootAttributeExtractor()
  • public CompositionRootTypeAttribute[] GetAttributes(Assembly assembly)
• public class CompositionRootExecutor : ICompositionRootExecutor
  • public CompositionRootExecutor(IServiceRegistry serviceRegistry, Func<Type, ICompositionRoot> activator)
  • public void Execute(Type compositionRootType)
• public class CompositionRootTypeAttribute : Attribute
  • public Type CompositionRootType { get; }
  • public CompositionRootTypeAttribute(Type compositionRootType)
• public class CompositionRootTypeExtractor : ITypeExtractor
  • public CompositionRootTypeExtractor(ICompositionRootAttributeExtractor compositionRootAttributeExtractor)
  • public Type[] Execute(Assembly assembly)
• public class ConcreteTypeExtractor : ITypeExtractor
  • public ConcreteTypeExtractor()
  • public Type[] Execute(Assembly assembly)
• public class ConstructionInfo
  • public ConstructorInfo Constructor { get; set; }
  • public List<ConstructorDependency> ConstructorDependencies { get; }
  • public Delegate FactoryDelegate { get; set; }
  • public Type ImplementingType { get; set; }
  • public List<PropertyDependency> PropertyDependencies { get; }
  • public ConstructionInfo()
• public class ConstructionInfoProvider : IConstructionInfoProvider
  • public ConstructionInfoProvider(IConstructionInfoBuilder constructionInfoBuilder)
  • public ConstructionInfo GetConstructionInfo(Registration registration)
• public class ConstructorDependency : Dependency
  • public bool IsDecoratorTarget { get; set; }
  • public ParameterInfo Parameter { get; set; }
  • public ConstructorDependency()
• public class ConstructorDependencySelector : IConstructorDependencySelector
  • public ConstructorDependencySelector()
  • public virtual IEnumerable<ConstructorDependency> Execute(ConstructorInfo constructor)
• public class ContainerOptions
  • public static ContainerOptions Default { get; }
  • public bool EnablePropertyInjection { get; set; }
  • public bool EnableVariance { get; set; }
  • public Func<Type, Action<LogEntry>> LogFactory { get; set; }
  • public ContainerOptions()
• public class DecoratorRegistration : Registration
  • public Func<ServiceRegistration, bool> CanDecorate { get; set; }
  • public bool HasDeferredImplementingType { get; }
  • public Func<IServiceFactory, ServiceRegistration, Type> ImplementingTypeFactory { get; set; }
  • public int Index { get; set; }
  • public DecoratorRegistration()
• public abstract class Dependency
  • public Delegate FactoryExpression { get; set; }
  • public bool IsRequired { get; set; }
  • public abstract string Name { get; }
  • public string ServiceName { get; set; }
  • public Type ServiceType { get; set; }
  • protected Dependency()
• public class DynamicMethod
  • public DynamicMethod(Type returnType, Type[] parameterTypes)
  • public Delegate CreateDelegate(Type delegateType)
  • public Delegate CreateDelegate(Type delegateType, object target)
  • public ILGenerator GetILGenerator()
• public class Emitter : IEmitter
  • public List<Instruction> Instructions { get; }
  • public Type StackType { get; }
  • public Emitter(ILGenerator generator, Type[] parameterTypes)
  • public LocalBuilder DeclareLocal(Type type)
  • public void Emit(OpCode code)
  • public void Emit(OpCode code, int arg)
  • public void Emit(OpCode code, sbyte arg)
  • public void Emit(OpCode code, byte arg)
  • public void Emit(OpCode code, Type type)
  • public void Emit(OpCode code, ConstructorInfo constructor)
  • public void Emit(OpCode code, LocalBuilder localBuilder)
  • public void Emit(OpCode code, MethodInfo methodInfo)
• public static class EmitterExtensions
  • public static void Call(this IEmitter emitter, MethodInfo methodInfo)
  • public static void Cast(this IEmitter emitter, Type type)
  • public static void New(this IEmitter emitter, ConstructorInfo constructorInfo)
  • public static void Push(this IEmitter emitter, LocalBuilder localBuilder)
  • public static void Push(this IEmitter emitter, int value)
  • public static void PushArgument(this IEmitter emitter, int index)
  • public static void PushArguments(this IEmitter emitter, ParameterInfo[] parameters)
  • public static void PushArrayElement(this IEmitter emitter)
  • public static void PushConstant(this IEmitter emitter, int index, Type type)
  • public static void PushConstant(this IEmitter emitter, int index)
  • public static void PushNewArray(this IEmitter emitter, Type elementType)
  • public static void Return(this IEmitter emitter)
  • public static void Store(this IEmitter emitter, LocalBuilder localBuilder)
  • public static void UnboxOrCast(this IEmitter emitter, Type type)
• public static class Ensure
  • public static void IsNotNull<T>(T value, string paramName)
• public class ExcludeFromCodeCoverageAttribute : Attribute
  • public ExcludeFromCodeCoverageAttribute()
• public class GenericArgumentMapper : IGenericArgumentMapper
  • public GenericArgumentMapper()
  • public GenericMappingResult Map(Type genericServiceType, Type openGenericImplementingType)
• public class GenericMappingResult
  • public bool IsValid { get; }
  • public Type[] GetMappedArguments()
• public interface IAssemblyScanner
  • void Scan(Assembly assembly, IServiceRegistry serviceRegistry, Func<ILifetime> lifetime, Func<Type, Type, bool> shouldRegister, Func<Type, Type, string> serviceNameProvider)
  • void Scan(Assembly assembly, IServiceRegistry serviceRegistry)
• public interface ICompositionRoot
  • void Compose(IServiceRegistry serviceRegistry)
• public interface ICompositionRootAttributeExtractor
  • CompositionRootTypeAttribute[] GetAttributes(Assembly assembly)
• public interface ICompositionRootExecutor
  • void Execute(Type compositionRootType)
• public interface IConstructionInfoBuilder
  • ConstructionInfo Execute(Registration registration)
• public interface IConstructionInfoProvider
  • ConstructionInfo GetConstructionInfo(Registration registration)
• public interface IConstructorDependencySelector
  • IEnumerable<ConstructorDependency> Execute(ConstructorInfo constructor)
• public interface IConstructorSelector
  • ConstructorInfo Execute(Type implementingType)
• public interface IEmitter
  • List<Instruction> Instructions { get; }
  • Type StackType { get; }
  • LocalBuilder DeclareLocal(Type type)
  • void Emit(OpCode code)
  • void Emit(OpCode code, int arg)
  • void Emit(OpCode code, sbyte arg)
  • void Emit(OpCode code, byte arg)
  • void Emit(OpCode code, Type type)
  • void Emit(OpCode code, ConstructorInfo constructor)
  • void Emit(OpCode code, LocalBuilder localBuilder)
  • void Emit(OpCode code, MethodInfo methodInfo)
• public interface IGenericArgumentMapper
  • GenericMappingResult Map(Type genericServiceType, Type openGenericImplementingType)
• public class ILGenerator
  • public Expression CurrentExpression { get; }
  • public ILGenerator(ParameterExpression[] parameters)
  • public LocalBuilder DeclareLocal(Type type)
  • public void Emit(OpCode code, ConstructorInfo constructor)
  • public void Emit(OpCode code)
  • public void Emit(OpCode code, LocalBuilder localBuilder)
  • public void Emit(OpCode code, int arg)
  • public void Emit(OpCode code, sbyte arg)
  • public void Emit(OpCode code, byte arg)
  • public void Emit(OpCode code, string arg)
  • public void Emit(OpCode code, Type type)
  • public void Emit(OpCode code, MethodInfo methodInfo)
• public interface ILifetime
  • object GetInstance(Func<object> createInstance, Scope scope)
• public interface IMethodSkeleton
  • Delegate CreateDelegate(Type delegateType)
  • IEmitter GetEmitter()
• public sealed class ImmutableHashTable<TKey, TValue>
  • public static readonly ImmutableHashTable<TKey, TValue> Empty
  • public readonly int Count
• public static class ImmutableHashTableExtensions
  • public static ImmutableHashTable<TKey, TValue> Add<TKey, TValue>(this ImmutableHashTable<TKey, TValue> hashTable, TKey key, TValue value)
  • public static TValue Search<TKey, TValue>(this ImmutableHashTable<TKey, TValue> hashTable, TKey key)
• public sealed class ImmutableHashTree<TKey, TValue>
  • public static readonly ImmutableHashTree<TKey, TValue> Empty
  • public readonly ImmutableList<KeyValue<TKey, TValue>> Duplicates
  • public readonly int HashCode
  • public readonly int Height
  • public readonly bool IsEmpty
  • public readonly TKey Key
  • public readonly ImmutableHashTree<TKey, TValue> Left
  • public readonly ImmutableHashTree<TKey, TValue> Right
  • public readonly TValue Value
  • public ImmutableHashTree(TKey key, TValue value, ImmutableHashTree<TKey, TValue> hashTree)
  • public ImmutableHashTree(TKey key, TValue value, ImmutableHashTree<TKey, TValue> left, ImmutableHashTree<TKey, TValue> right)
• public static class ImmutableHashTreeExtensions
  • public static ImmutableHashTree<TKey, TValue> Add<TKey, TValue>(this ImmutableHashTree<TKey, TValue> tree, TKey key, TValue value)
  • public static IEnumerable<KeyValue<TKey, TValue>> InOrder<TKey, TValue>(this ImmutableHashTree<TKey, TValue> hashTree)
  • public static TValue Search<TKey, TValue>(this ImmutableHashTree<TKey, TValue> tree, TKey key)
• public sealed class ImmutableList<T>
  • public static readonly ImmutableList<T> Empty
  • public readonly int Count
  • public readonly T[] Items
  • public ImmutableList(ImmutableList<T> previousList, T value)
  • public ImmutableList<T> Add(T value)
• public class Instruction
  • public OpCode Code { get; }
  • public Action<ILGenerator> Emit { get; }
  • public Instruction(OpCode code, Action<ILGenerator> emitAction)
• public class Instruction<T> : Instruction
  • public T Argument { get; }
  • public Instruction(OpCode code, T argument, Action<ILGenerator> emitAction)
• public interface IPropertyDependencySelector
  • IEnumerable<PropertyDependency> Execute(Type type)
• public interface IPropertySelector
  • IEnumerable<PropertyInfo> Execute(Type type)
• public interface IScopeManager
  • Scope CurrentScope { get; set; }
  • IServiceFactory ServiceFactory { get; }
  • Scope BeginScope()
  • void EndScope(Scope scope)
• public interface IScopeManagerProvider
  • IScopeManager GetScopeManager(IServiceFactory serviceFactory)
• public interface IServiceContainer : IServiceRegistry, IServiceFactory, IDisposable
  • IScopeManagerProvider ScopeManagerProvider { get; set; }
  • bool CanGetInstance(Type serviceType, string serviceName)
  • object InjectProperties(object instance)
• public interface IServiceFactory
  • Scope BeginScope()
  • object Create(Type serviceType)
  • IEnumerable<object> GetAllInstances(Type serviceType)
  • object GetInstance(Type serviceType)
  • object GetInstance(Type serviceType, object[] arguments)
  • object GetInstance(Type serviceType, string serviceName, object[] arguments)
  • object GetInstance(Type serviceType, string serviceName)
  • object TryGetInstance(Type serviceType)
  • object TryGetInstance(Type serviceType, string serviceName)
• public interface IServiceNameProvider
  • string GetServiceName(Type serviceType, Type implementingType)
• public interface IServiceRegistry
  • IEnumerable<ServiceRegistration> AvailableServices { get; }
  • IServiceRegistry Decorate(Type serviceType, Type decoratorType, Func<ServiceRegistration, bool> predicate)
  • IServiceRegistry Decorate(Type serviceType, Type decoratorType)
  • IServiceRegistry Decorate<TService, TDecorator>() where TDecorator : TService
  • IServiceRegistry Decorate<TService>(Func<IServiceFactory, TService, TService> factory)
  • IServiceRegistry Decorate(DecoratorRegistration decoratorRegistration)
  • IServiceRegistry Initialize(Func<ServiceRegistration, bool> predicate, Action<IServiceFactory, object> processor)
  • IServiceRegistry Override(Func<ServiceRegistration, bool> serviceSelector, Func<IServiceFactory, ServiceRegistration, ServiceRegistration> serviceRegistrationFactory)
  • IServiceRegistry Register(Type serviceType, Type implementingType)
  • IServiceRegistry Register(Type serviceType, Type implementingType, ILifetime lifetime)
  • IServiceRegistry Register(Type serviceType, Type implementingType, string serviceName)
  • IServiceRegistry Register(Type serviceType, Type implementingType, string serviceName, ILifetime lifetime)
  • IServiceRegistry Register<TService, TImplementation>() where TImplementation : TService
  • IServiceRegistry Register<TService, TImplementation>(ILifetime lifetime) where TImplementation : TService
  • IServiceRegistry Register<TService, TImplementation>(string serviceName) where TImplementation : TService
  • IServiceRegistry Register<TService, TImplementation>(string serviceName, ILifetime lifetime) where TImplementation : TService
  • IServiceRegistry Register<TService>()
  • IServiceRegistry Register<TService>(ILifetime lifetime)
  • IServiceRegistry Register(Type serviceType)
  • IServiceRegistry Register(Type serviceType, ILifetime lifetime)
  • IServiceRegistry Register<TService>(Func<IServiceFactory, TService> factory)
  • IServiceRegistry Register<T, TService>(Func<IServiceFactory, T, TService> factory)
  • IServiceRegistry Register<T, TService>(Func<IServiceFactory, T, TService> factory, string serviceName)
  • IServiceRegistry Register<T1, T2, TService>(Func<IServiceFactory, T1, T2, TService> factory)
  • IServiceRegistry Register<T1, T2, TService>(Func<IServiceFactory, T1, T2, TService> factory, string serviceName)
  • IServiceRegistry Register<T1, T2, T3, TService>(Func<IServiceFactory, T1, T2, T3, TService> factory)
  • IServiceRegistry Register<T1, T2, T3, TService>(Func<IServiceFactory, T1, T2, T3, TService> factory, string serviceName)
  • IServiceRegistry Register<T1, T2, T3, T4, TService>(Func<IServiceFactory, T1, T2, T3, T4, TService> factory)
  • IServiceRegistry Register<T1, T2, T3, T4, TService>(Func<IServiceFactory, T1, T2, T3, T4, TService> factory, string serviceName)
  • IServiceRegistry Register<TService>(Func<IServiceFactory, TService> factory, ILifetime lifetime)
  • IServiceRegistry Register<TService>(Func<IServiceFactory, TService> factory, string serviceName)
  • IServiceRegistry Register<TService>(Func<IServiceFactory, TService> factory, string serviceName, ILifetime lifetime)
  • IServiceRegistry Register(ServiceRegistration serviceRegistration)
  • IServiceRegistry RegisterAssembly(Assembly assembly)
  • IServiceRegistry RegisterAssembly(Assembly assembly, Func<Type, Type, bool> shouldRegister)
  • IServiceRegistry RegisterAssembly(Assembly assembly, Func<ILifetime> lifetimeFactory)
  • IServiceRegistry RegisterAssembly(Assembly assembly, Func<ILifetime> lifetimeFactory, Func<Type, Type, bool> shouldRegister)
  • IServiceRegistry RegisterAssembly(Assembly assembly, Func<ILifetime> lifetimeFactory, Func<Type, Type, bool> shouldRegister, Func<Type, Type, string> serviceNameProvider)
  • IServiceRegistry RegisterConstructorDependency<TDependency>(Func<IServiceFactory, ParameterInfo, TDependency> factory)
  • IServiceRegistry RegisterConstructorDependency<TDependency>(Func<IServiceFactory, ParameterInfo, object[], TDependency> factory)
  • IServiceRegistry RegisterFallback(Func<Type, string, bool> predicate, Func<ServiceRequest, object> factory)
  • IServiceRegistry RegisterFallback(Func<Type, string, bool> predicate, Func<ServiceRequest, object> factory, ILifetime lifetime)
  • IServiceRegistry RegisterFrom<TCompositionRoot>() where TCompositionRoot : ICompositionRoot
  • IServiceRegistry RegisterInstance<TService>(TService instance)
  • IServiceRegistry RegisterInstance<TService>(TService instance, string serviceName)
  • IServiceRegistry RegisterInstance(Type serviceType, object instance)
  • IServiceRegistry RegisterInstance(Type serviceType, object instance, string serviceName)
  • IServiceRegistry RegisterOrdered(Type serviceType, Type[] implementingTypes, Func<Type, ILifetime> lifetimeFactory)
  • IServiceRegistry RegisterOrdered(Type serviceType, Type[] implementingTypes, Func<Type, ILifetime> lifeTimeFactory, Func<int, string> serviceNameFormatter)
  • IServiceRegistry RegisterPropertyDependency<TDependency>(Func<IServiceFactory, PropertyInfo, TDependency> factory)
  • IServiceRegistry SetDefaultLifetime<T>() where T : ILifetime
• public interface ITypeConstructionInfoBuilder
  • ConstructionInfo Execute(Registration registration)
• public interface ITypeExtractor
  • Type[] Execute(Assembly assembly)
• public sealed class KeyValue<TKey, TValue>
  • public readonly TKey Key
  • public readonly TValue Value
  • public KeyValue(TKey key, TValue value)
• public class LocalBuilder
  • public int LocalIndex { get; }
  • public Type LocalType { get; }
  • public ParameterExpression Variable { get; }
  • public LocalBuilder(Type type, int localIndex)
• public class LogEntry
  • public LogLevel Level { get; }
  • public string Message { get; }
  • public LogEntry(LogLevel level, string message)
• public static class LogExtensions
  • public static void Info(this Action<LogEntry> logAction, string message)
  • public static void Warning(this Action<LogEntry> logAction, string message)
• public class LogicalThreadStorage<T>
  • public T Value { get; set; }
  • public LogicalThreadStorage()
• public enum LogLevel
  • Info = 0
  • Warning = 1
• public class MostResolvableConstructorSelector : IConstructorSelector
  • public MostResolvableConstructorSelector(Func<Type, string, bool> canGetInstance)
  • public ConstructorInfo Execute(Type implementingType)
  • protected virtual string GetServiceName(ParameterInfo parameter)
• public class PerContainerLifetime : ILifetime, IDisposable
  • public PerContainerLifetime()
  • public void Dispose()
  • public object GetInstance(Func<object> createInstance, Scope scope)
• public class PerLogicalCallContextScopeManager : ScopeManager
  • public PerLogicalCallContextScopeManager(IServiceFactory serviceFactory)
• public class PerLogicalCallContextScopeManagerProvider : ScopeManagerProvider
  • public PerLogicalCallContextScopeManagerProvider()
• public class PerRequestLifeTime : ILifetime
  • public PerRequestLifeTime()
  • public object GetInstance(Func<object> createInstance, Scope scope)
• public class PerScopeLifetime : ILifetime
  • public PerScopeLifetime()
  • public object GetInstance(Func<object> createInstance, Scope scope)
• public class PerThreadScopeManager : ScopeManager
  • public PerThreadScopeManager(IServiceFactory serviceFactory)
• public class PerThreadScopeManagerProvider : ScopeManagerProvider
  • public PerThreadScopeManagerProvider()
• public class PropertyDependency : Dependency
  • public PropertyInfo Property { get; set; }
  • public PropertyDependency()
• public class PropertyDependencySelector : IPropertyDependencySelector
  • protected IPropertySelector PropertySelector { get; }
  • public PropertyDependencySelector(IPropertySelector propertySelector)
  • public virtual IEnumerable<PropertyDependency> Execute(Type type)
• public class PropertySelector : IPropertySelector
  • public PropertySelector()
  • public IEnumerable<PropertyInfo> Execute(Type type)
  • protected virtual bool IsInjectable(PropertyInfo propertyInfo)
• public abstract class Registration
  • public Delegate FactoryExpression { get; set; }
  • public virtual Type ImplementingType { get; set; }
  • public Type ServiceType { get; set; }
  • protected Registration()
• public static class RuntimeArgumentsLoader
  • public static object[] Load(object[] constants)
• public class Scope : IServiceFactory, IDisposable
  • public Scope ChildScope { get; }
  • public bool IsDisposed { get; set; }
  • public Scope ParentScope { get; }
  • public event EventHandler<EventArgs> Completed
  • public Scope(IScopeManager scopeManager, Scope parentScope)
  • public Scope BeginScope()
  • public object Create(Type serviceType)
  • public void Dispose()
  • public IEnumerable<object> GetAllInstances(Type serviceType)
  • public object GetInstance(Type serviceType)
  • public object GetInstance(Type serviceType, string serviceName)
  • public object GetInstance(Type serviceType, object[] arguments)
  • public object GetInstance(Type serviceType, string serviceName, object[] arguments)
  • public void TrackInstance(IDisposable disposable)
  • public object TryGetInstance(Type serviceType)
  • public object TryGetInstance(Type serviceType, string serviceName)
• public abstract class ScopeManager : IScopeManager
  • public abstract Scope CurrentScope { get; set; }
  • public IServiceFactory ServiceFactory { get; }
  • protected ScopeManager(IServiceFactory serviceFactory)
  • public Scope BeginScope()
  • public void EndScope(Scope scope)
  • protected Scope GetThisScopeOrFirstValidAncestor(Scope scope)
• public abstract class ScopeManagerProvider : IScopeManagerProvider
  • protected ScopeManagerProvider()
  • protected abstract IScopeManager CreateScopeManager(IServiceFactory serviceFactory)
  • public IScopeManager GetScopeManager(IServiceFactory serviceFactory)
• public class ServiceContainer : IServiceContainer, IServiceRegistry, IServiceFactory, IDisposable
  • public IAssemblyScanner AssemblyScanner { get; set; }
  • public IEnumerable<ServiceRegistration> AvailableServices { get; }
  • public ICompositionRootExecutor CompositionRootExecutor { get; set; }
  • public ITypeExtractor CompositionRootTypeExtractor { get; set; }
  • public IConstructorDependencySelector ConstructorDependencySelector { get; set; }
  • public IConstructorSelector ConstructorSelector { get; set; }
  • public IGenericArgumentMapper GenericArgumentMapper { get; set; }
  • public IPropertyDependencySelector PropertyDependencySelector { get; set; }
  • public IScopeManagerProvider ScopeManagerProvider { get; set; }
  • public IServiceNameProvider ServiceNameProvider { get; set; }
  • public ServiceContainer()
  • public ServiceContainer(ContainerOptions options)
  • public Scope BeginScope()
  • public bool CanGetInstance(Type serviceType, string serviceName)
  • public ServiceContainer Clone()
  • public object Create(Type serviceType)
  • public IServiceRegistry Decorate(Type serviceType, Type decoratorType, Func<ServiceRegistration, bool> predicate)
  • public IServiceRegistry Decorate(Type serviceType, Type decoratorType)
  • public IServiceRegistry Decorate<TService, TDecorator>() where TDecorator : TService
  • public IServiceRegistry Decorate<TService>(Func<IServiceFactory, TService, TService> factory)
  • public IServiceRegistry Decorate(DecoratorRegistration decoratorRegistration)
  • public void Dispose()
  • public IEnumerable<object> GetAllInstances(Type serviceType)
  • public object GetInstance(Type serviceType)
  • public object GetInstance(Type serviceType, object[] arguments)
  • public object GetInstance(Type serviceType, string serviceName, object[] arguments)
  • public object GetInstance(Type serviceType, string serviceName)
  • public IServiceRegistry Initialize(Func<ServiceRegistration, bool> predicate, Action<IServiceFactory, object> processor)
  • public object InjectProperties(object instance)
  • public IServiceRegistry Override(Func<ServiceRegistration, bool> serviceSelector, Func<IServiceFactory, ServiceRegistration, ServiceRegistration> serviceRegistrationFactory)
  • public IServiceRegistry Register<TService>(Func<IServiceFactory, TService> factory, string serviceName, ILifetime lifetime)
  • public IServiceRegistry Register(ServiceRegistration serviceRegistration)
  • public IServiceRegistry Register(Type serviceType, Type implementingType, ILifetime lifetime)
  • public IServiceRegistry Register(Type serviceType, Type implementingType, string serviceName, ILifetime lifetime)
  • public IServiceRegistry Register<TService, TImplementation>() where TImplementation : TService
  • public IServiceRegistry Register<TService, TImplementation>(ILifetime lifetime) where TImplementation : TService
  • public IServiceRegistry Register<TService, TImplementation>(string serviceName) where TImplementation : TService
  • public IServiceRegistry Register<TService, TImplementation>(string serviceName, ILifetime lifetime) where TImplementation : TService
  • public IServiceRegistry Register<TService>(Func<IServiceFactory, TService> factory, ILifetime lifetime)
  • public IServiceRegistry Register<TService>(Func<IServiceFactory, TService> factory, string serviceName)
  • public IServiceRegistry Register<TService>()
  • public IServiceRegistry Register(Type serviceType)
  • public IServiceRegistry Register(Type serviceType, ILifetime lifetime)
  • public IServiceRegistry Register<TService>(ILifetime lifetime)
  • public IServiceRegistry Register<TService>(Func<IServiceFactory, TService> factory)
  • public IServiceRegistry Register<T, TService>(Func<IServiceFactory, T, TService> factory)
  • public IServiceRegistry Register<T, TService>(Func<IServiceFactory, T, TService> factory, string serviceName)
  • public IServiceRegistry Register<T1, T2, TService>(Func<IServiceFactory, T1, T2, TService> factory)
  • public IServiceRegistry Register<T1, T2, TService>(Func<IServiceFactory, T1, T2, TService> factory, string serviceName)
  • public IServiceRegistry Register<T1, T2, T3, TService>(Func<IServiceFactory, T1, T2, T3, TService> factory)
  • public IServiceRegistry Register<T1, T2, T3, TService>(Func<IServiceFactory, T1, T2, T3, TService> factory, string serviceName)
  • public IServiceRegistry Register<T1, T2, T3, T4, TService>(Func<IServiceFactory, T1, T2, T3, T4, TService> factory)
  • public IServiceRegistry Register<T1, T2, T3, T4, TService>(Func<IServiceFactory, T1, T2, T3, T4, TService> factory, string serviceName)
  • public IServiceRegistry Register(Type serviceType, Type implementingType, string serviceName)
  • public IServiceRegistry Register(Type serviceType, Type implementingType)
  • public IServiceRegistry RegisterAssembly(Assembly assembly)
  • public IServiceRegistry RegisterAssembly(Assembly assembly, Func<Type, Type, bool> shouldRegister)
  • public IServiceRegistry RegisterAssembly(Assembly assembly, Func<ILifetime> lifetimeFactory)
  • public IServiceRegistry RegisterAssembly(Assembly assembly, Func<ILifetime> lifetimeFactory, Func<Type, Type, bool> shouldRegister)
  • public IServiceRegistry RegisterAssembly(Assembly assembly, Func<ILifetime> lifetimeFactory, Func<Type, Type, bool> shouldRegister, Func<Type, Type, string> serviceNameProvider)
  • public IServiceRegistry RegisterConstructorDependency<TDependency>(Func<IServiceFactory, ParameterInfo, TDependency> factory)
  • public IServiceRegistry RegisterConstructorDependency<TDependency>(Func<IServiceFactory, ParameterInfo, object[], TDependency> factory)
  • public IServiceRegistry RegisterFallback(Func<Type, string, bool> predicate, Func<ServiceRequest, object> factory)
  • public IServiceRegistry RegisterFallback(Func<Type, string, bool> predicate, Func<ServiceRequest, object> factory, ILifetime lifetime)
  • public IServiceRegistry RegisterFrom<TCompositionRoot>() where TCompositionRoot : ICompositionRoot
  • public IServiceRegistry RegisterInstance<TService>(TService instance, string serviceName)
  • public IServiceRegistry RegisterInstance<TService>(TService instance)
  • public IServiceRegistry RegisterInstance(Type serviceType, object instance)
  • public IServiceRegistry RegisterInstance(Type serviceType, object instance, string serviceName)
  • public IServiceRegistry RegisterOrdered(Type serviceType, Type[] implementingTypes, Func<Type, ILifetime> lifeTimeFactory)
  • public IServiceRegistry RegisterOrdered(Type serviceType, Type[] implementingTypes, Func<Type, ILifetime> lifeTimeFactory, Func<int, string> serviceNameFormatter)
  • public IServiceRegistry RegisterPropertyDependency<TDependency>(Func<IServiceFactory, PropertyInfo, TDependency> factory)
  • public IServiceRegistry SetDefaultLifetime<T>() where T : ILifetime
  • public object TryGetInstance(Type serviceType)
  • public object TryGetInstance(Type serviceType, string serviceName)
• public static class ServiceFactoryExtensions
  • public static TService Create<TService>(this IServiceFactory factory)
  • public static IEnumerable<TService> GetAllInstances<TService>(this IServiceFactory factory)
  • public static TService GetInstance<TService>(this IServiceFactory factory)
  • public static TService GetInstance<TService>(this IServiceFactory factory, string serviceName)
  • public static TService GetInstance<T, TService>(this IServiceFactory factory, T value)
  • public static TService GetInstance<T, TService>(this IServiceFactory factory, T value, string serviceName)
  • public static TService GetInstance<T1, T2, TService>(this IServiceFactory factory, T1 arg1, T2 arg2)
  • public static TService GetInstance<T1, T2, TService>(this IServiceFactory factory, T1 arg1, T2 arg2, string serviceName)
  • public static TService GetInstance<T1, T2, T3, TService>(this IServiceFactory factory, T1 arg1, T2 arg2, T3 arg3)
  • public static TService GetInstance<T1, T2, T3, TService>(this IServiceFactory factory, T1 arg1, T2 arg2, T3 arg3, string serviceName)
  • public static TService GetInstance<T1, T2, T3, T4, TService>(this IServiceFactory factory, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
  • public static TService GetInstance<T1, T2, T3, T4, TService>(this IServiceFactory factory, T1 arg1, T2 arg2, T3 arg3, T4 arg4, string serviceName)
  • public static TService TryGetInstance<TService>(this IServiceFactory factory)
  • public static TService TryGetInstance<TService>(this IServiceFactory factory, string serviceName)
• public class ServiceNameProvider : IServiceNameProvider
  • public ServiceNameProvider()
  • public string GetServiceName(Type serviceType, Type implementingType)
• public class ServiceRegistration : Registration
  • public ILifetime Lifetime { get; set; }
  • public string ServiceName { get; set; }
  • public object Value { get; set; }
  • public ServiceRegistration()
• public class ServiceRequest
  • public IServiceFactory ServiceFactory { get; }
  • public string ServiceName { get; }
  • public Type ServiceType { get; }
  • public ServiceRequest(Type serviceType, string serviceName, IServiceFactory serviceFactory)
• public class ThreadSafeDictionary<TKey, TValue> : ConcurrentDictionary<TKey, TValue>
  • public ThreadSafeDictionary()
  • public ThreadSafeDictionary(IEqualityComparer<TKey> comparer)
• public class TypeConstructionInfoBuilder : IConstructionInfoBuilder
  • public TypeConstructionInfoBuilder(IConstructorSelector constructorSelector, IConstructorDependencySelector constructorDependencySelector, IPropertyDependencySelector propertyDependencySelector, Func<Type, string, Delegate> getConstructorDependencyExpression, Func<Type, string, Delegate> getPropertyDependencyExpression)
  • public ConstructionInfo Execute(Registration registration)

EasyNetQ.Loggers

• public class ConsoleLogger : IEasyNetQLogger
• public class DelegateLogger : IEasyNetQLogger
• public class NullLogger : IEasyNetQLogger

EasyNetQ.Logging

• public class ConsoleLogProvider : ILogProvider
  • public static ConsoleLogProvider Instance
  • public Logger GetLogger(string name)
  • public IDisposable OpenMappedContext(string key, object value, bool destructure = false)
  • public IDisposable OpenNestedContext(string message)
• public interface ILog
  • bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception = null, object[] formatParameters)
• public interface ILogProvider
  • Logger GetLogger(string name)
  • IDisposable OpenMappedContext(string key, object value, bool destructure = false)
  • IDisposable OpenNestedContext(string message)
• public static class LogExtensions
  • public static void Debug(this ILog logger, Func<string> messageFunc)
  • public static void Debug(this ILog logger, string message)
  • public static void Debug(this ILog logger, string message, object[] args)
  • public static void Debug(this ILog logger, string message, object arg0)
  • public static void Debug(this ILog logger, string message, object arg0, object arg1)
  • public static void Debug(this ILog logger, string message, object arg0, object arg1, object arg2)
  • public static void Debug(this ILog logger, Exception exception, string message, object[] args)
  • public static void Debug(this ILog logger, Exception exception, string message, object arg0)
  • public static void DebugException(this ILog logger, string message, Exception exception)
  • public static void DebugException(this ILog logger, string message, Exception exception, object formatParam0)
  • public static void DebugException(this ILog logger, string message, Exception exception, object formatParam0, object formatParam1)
  • public static void DebugException(this ILog logger, string message, Exception exception, object formatParam0, object formatParam1, object formatParam2)
  • public static void DebugException(this ILog logger, string message, Exception exception, object[] formatParams)
  • public static void DebugFormat(this ILog logger, string message, object[] args)
  • public static void DebugFormat(this ILog logger, string message, object arg0)
  • public static void DebugFormat(this ILog logger, string message, object arg0, object arg1)
  • public static void DebugFormat(this ILog logger, string message, object arg0, object arg1, object arg2)
  • public static void Error(this ILog logger, Func<string> messageFunc)
  • public static void Error(this ILog logger, string message)
  • public static void Error(this ILog logger, string message, object[] args)
  • public static void Error(this ILog logger, Exception exception, string message, object[] args)
  • public static void ErrorException(this ILog logger, string message, Exception exception, object[] formatParams)
  • public static void ErrorFormat(this ILog logger, string message, object[] args)
  • public static void Fatal(this ILog logger, Func<string> messageFunc)
  • public static void Fatal(this ILog logger, string message)
  • public static void Fatal(this ILog logger, string message, object[] args)
  • public static void Fatal(this ILog logger, Exception exception, string message, object[] args)
  • public static void FatalException(this ILog logger, string message, Exception exception, object[] formatParams)
  • public static void FatalFormat(this ILog logger, string message, object[] args)
  • public static void Info(this ILog logger, Func<string> messageFunc)
  • public static void Info(this ILog logger, string message)
  • public static void Info(this ILog logger, string message, object[] args)
  • public static void Info(this ILog logger, string message, object arg0)
  • public static void Info(this ILog logger, string message, object arg0, object arg1)
  • public static void Info(this ILog logger, string message, object arg0, object arg1, object arg2)
  • public static void Info(this ILog logger, Exception exception, string message, object[] args)
  • public static void Info(this ILog logger, Exception exception, string message, object arg0)
  • public static void Info(this ILog logger, Exception exception, string message, object arg0, object arg1)
  • public static void Info(this ILog logger, Exception exception, string message, object arg0, object arg1, object arg2)
  • public static void InfoException(this ILog logger, string message, Exception exception, object[] formatParams)
  • public static void InfoFormat(this ILog logger, string message, object[] args)
  • public static void InfoFormat(this ILog logger, string message, object arg0)
  • public static void InfoFormat(this ILog logger, string message, object arg0, object arg1)
  • public static void InfoFormat(this ILog logger, string message, object arg0, object arg1, object arg2)
  • public static bool IsDebugEnabled(this ILog logger)
  • public static bool IsErrorEnabled(this ILog logger)
  • public static bool IsFatalEnabled(this ILog logger)
  • public static bool IsInfoEnabled(this ILog logger)
  • public static bool IsTraceEnabled(this ILog logger)
  • public static bool IsWarnEnabled(this ILog logger)
  • public static void Trace(this ILog logger, Func<string> messageFunc)
  • public static void Trace(this ILog logger, string message)
  • public static void Trace(this ILog logger, string message, object[] args)
  • public static void Trace(this ILog logger, string message, object arg0)
  • public static void Trace(this ILog logger, string message, object arg0, object arg1)
  • public static void Trace(this ILog logger, string message, object arg0, object arg1, object arg2)
  • public static void Trace(this ILog logger, Exception exception, string message, object[] args)
  • public static void Trace(this ILog logger, Exception exception, string message, object arg0)
  • public static void Trace(this ILog logger, Exception exception, string message, object arg0, object arg1)
  • public static void Trace(this ILog logger, Exception exception, string message, object arg0, object arg1, object arg2)
  • public static void TraceException(this ILog logger, string message, Exception exception, object[] formatParams)
  • public static void TraceException(this ILog logger, string message, Exception exception, object formatParam0)
  • public static void TraceException(this ILog logger, string message, Exception exception, object formatParam0, object formatParam1)
  • public static void TraceException(this ILog logger, string message, Exception exception, object formatParam0, object formatParam1, object formatParam2)
  • public static void TraceFormat(this ILog logger, string message, object[] args)
  • public static void TraceFormat(this ILog logger, string message, object arg0)
  • public static void TraceFormat(this ILog logger, string message, object arg0, object arg1)
  • public static void TraceFormat(this ILog logger, string message, object arg0, object arg1, object arg2)
  • public static void Warn(this ILog logger, Func<string> messageFunc)
  • public static void Warn(this ILog logger, string message)
  • public static void Warn(this ILog logger, string message, object[] args)
  • public static void Warn(this ILog logger, Exception exception, string message, object[] args)
  • public static void WarnException(this ILog logger, string message, Exception exception, object[] formatParams)
  • public static void WarnFormat(this ILog logger, string message, object[] args)
• public sealed delegate Logger : MulticastDelegate
  • public Logger(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(LogLevel logLevel, Func<string> messageFunc, Exception exception, object[] formatParameters, AsyncCallback callback, object object)
  • public virtual bool EndInvoke(IAsyncResult result)
  • public virtual bool Invoke(LogLevel logLevel, Func<string> messageFunc, Exception exception = null, object[] formatParameters)
• public enum LogLevel
  • Debug = 1
  • Error = 4
  • Fatal = 5
  • Info = 2
  • Trace = 0
  • Warn = 3
• public static class LogProvider
  • public static bool IsDisabled { get; set; }
  • public static ILog For<T>()
  • public static ILog GetCurrentClassLogger()
  • public static ILog GetLogger(Type type, string fallbackTypeName = "System.Object")
  • public static ILog GetLogger(string name)
  • public static IDisposable OpenMappedContext(string key, object value, bool destructure = false)
  • public static IDisposable OpenNestedContext(string message)
  • public static void SetCurrentLogProvider(ILogProvider logProvider)

EasyNetQ.Logging.LogProviders

• public class LibLogException : Exception
  • public LibLogException(string message)
  • public LibLogException(string message, Exception inner)
• public abstract class LogProviderBase : ILogProvider
  • protected sealed delegate OpenMdc : MulticastDelegate
  • protected sealed delegate OpenNdc : MulticastDelegate
  • protected const string ErrorInitializingProvider = "Unable to log due to problem initializing the log provider. See inner exception for details."
  • protected LogProviderBase()
  • public abstract Logger GetLogger(string name)
  • protected virtual OpenMdc GetOpenMdcMethod()
  • protected virtual OpenNdc GetOpenNdcMethod()
  • public IDisposable OpenMappedContext(string key, object value, bool destructure = false)
  • public IDisposable OpenNestedContext(string message)

EasyNetQ.MessageVersioning

• public class MessageType
• public class MessageTypeProperty
  • public MessageType GetMessageType()
  • public Type GetMessageType()
• public static class MessageVersioningExtensions
  • public static IServiceRegister EnableMessageVersioning(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableMessageVersioning(this IServiceRegister serviceRegister)
• public class VersionedMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage<T> DeserializeMessage<T>(MessageProperties properties, byte[] body)
• public class VersionedPublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
  • public VersionedPublishExchangeDeclareStrategy()
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)
  • public Task<IExchange> DeclareExchangeAsync(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public Task<IExchange> DeclareExchangeAsync(IAdvancedBus advancedBus, Type messageType, string exchangeType)
  • public VersionedPublishExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
  • public Task<IExchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken)
  • public Task<IExchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken)

EasyNetQ.MultipleExchange

• public static class MultipleExchangeExtension
  • public static IServiceRegister EnableAdvancedMessagePolymorphism(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableAdvancedMessagePolymorphism(this IServiceRegister serviceRegister)
• public class MultipleExchangePublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
  • public MultipleExchangePublishExchangeDeclareStrategy()
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public Task<IExchange> DeclareExchangeAsync(IAdvancedBus advancedBus, Type messageType, string exchangeType)
  • public Task<IExchange> DeclareExchangeAsync(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public MultipleExchangePublishExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
  • public Task<IExchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken)
  • public Task<IExchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken)

EasyNetQ.NonGeneric

• public static class NonGenericExtensions

EasyNetQ.Producer

• public class ClientCommandDispatcher : IClientCommandDispatcher, IDisposable
  • public T Invoke<T>(Func<IModel, T> channelAction)
  • public void Invoke(Action<IModel> channelAction)
  • public Task<T> InvokeAsync<T>(Func<IModel, T> channelAction)
  • public Task InvokeAsync(Action<IModel> channelAction)
  • public Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, CancellationToken cancellationToken)
  • public Task InvokeAsync(Action<IModel> channelAction, CancellationToken cancellationToken)
• public class ClientCommandDispatcherSingleton : IClientCommandDispatcher, IDisposable
  • public T Invoke<T>(Func<IModel, T> channelAction)
  • public void Invoke(Action<IModel> channelAction)
  • public Task<T> InvokeAsync<T>(Func<IModel, T> channelAction)
  • public Task InvokeAsync(Action<IModel> channelAction)
  • public Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, CancellationToken cancellationToken)
  • public Task InvokeAsync(Action<IModel> channelAction, CancellationToken cancellationToken)
• public class DefaultPubSub : IPubSub
  • public DefaultPubSub(ConnectionConfiguration connectionConfiguration, IConventions conventions, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, IAdvancedBus advancedBus)
  • public virtual Task PublishAsync<T>(T message, Action<IPublishConfiguration> configure, CancellationToken cancellationToken)
  • public virtual AwaitableDisposable<ISubscriptionResult> SubscribeAsync<T>(string subscriptionId, Func<T, CancellationToken, Task> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken)
• public class DefaultRpc : IRpc
  • protected class ResponseAction
  • protected struct RpcKey
  • protected const string exceptionMessageKey = "ExceptionMessage"
  • protected const string isFaultedKey = "IsFaulted"
  • protected readonly IAdvancedBus advancedBus
  • protected readonly IConventions conventions
  • protected readonly TimeSpan disablePeriodicSignaling
  • protected readonly IMessageDeliveryModeStrategy messageDeliveryModeStrategy
  • protected readonly IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy
  • public DefaultRpc(ConnectionConfiguration connectionConfiguration, IAdvancedBus advancedBus, IEventBus eventBus, IConventions conventions, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, ITimeoutStrategy timeoutStrategy, ITypeNameSerializer typeNameSerializer)
  • protected Task ExecuteResponder<TRequest, TResponse>(Func<TRequest, CancellationToken, Task<TResponse>> responder, IMessage<TRequest> requestMessage)
  • protected virtual void OnResponderFailure<TRequest, TResponse>(IMessage<TRequest> requestMessage, string exceptionMessage, Exception exception)
  • protected virtual void OnResponderSuccess<TRequest, TResponse>(IMessage<TRequest> requestMessage, TResponse response)
  • protected void RegisterErrorHandling<TResponse>(Guid correlationId, Timer timer, TaskCompletionSource<TResponse> tcs)
  • public virtual Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure, CancellationToken cancellationToken)
  • protected virtual void RequestPublish<TRequest>(TRequest request, string routingKey, string returnQueueName, Guid correlationId)
  • public virtual AwaitableDisposable<IDisposable> RespondAsync<TRequest, TResponse>(Func<TRequest, CancellationToken, Task<TResponse>> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken)
  • protected virtual string SubscribeToResponse<TRequest, TResponse>()
• public class DefaultSendReceive : ISendReceive
  • public DefaultSendReceive(IAdvancedBus advancedBus, IMessageDeliveryModeStrategy messageDeliveryModeStrategy)
  • public AwaitableDisposable<IDisposable> ReceiveAsync<T>(string queue, Func<T, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure, CancellationToken cancellationToken)
  • public AwaitableDisposable<IDisposable> ReceiveAsync(string queue, Action<IReceiveRegistration> addHandlers, Action<IConsumerConfiguration> configure, CancellationToken cancellationToken)
  • public Task SendAsync<T>(string queue, T message, CancellationToken cancellationToken)
• public interface IClientCommandDispatcher : IDisposable
  • T Invoke<T>(Func<IModel, T> channelAction)
  • void Invoke(Action<IModel> channelAction)
  • Task<T> InvokeAsync<T>(Func<IModel, T> channelAction)
  • Task InvokeAsync(Action<IModel> channelAction)
  • Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, CancellationToken cancellationToken = default)
  • Task InvokeAsync(Action<IModel> channelAction, CancellationToken cancellationToken = default)
• public interface IPublishConfirmationWaiter
  • void Wait(TimeSpan timeout)
• public interface IPublishExchangeDeclareStrategy
  • IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)
  • Task<IExchange> DeclareExchangeAsync(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • Task<IExchange> DeclareExchangeAsync(IAdvancedBus advancedBus, Type messageType, string exchangeType)
  • Task<IExchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken = default)
  • Task<IExchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken = default)
• public interface IPubSub
  • Task PublishAsync<T>(T message, Action<IPublishConfiguration> configure, CancellationToken cancellationToken = default)
  • AwaitableDisposable<ISubscriptionResult> SubscribeAsync<T>(string subscriptionId, Func<T, CancellationToken, Task> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
• public interface IReceiveRegistration
  • IReceiveRegistration Add<T>(Func<T, CancellationToken, Task> onMessage)
• public interface IRpc
  • Task<TResponse> Request<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, Action<IResponderConfiguration> configure)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure, CancellationToken cancellationToken = default)
  • AwaitableDisposable<IDisposable> RespondAsync<TRequest, TResponse>(Func<TRequest, CancellationToken, Task<TResponse>> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken = default)
• public interface ISendReceive
  • IDisposable Receive<T>(string queue, Action<T> onMessage)
  • IDisposable Receive<T>(string queue, Action<T> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers, Action<IConsumerConfiguration> configure)
  • void Send<T>(string queue, T message)
  • Task SendAsync<T>(string queue, T message)
  • AwaitableDisposable<IDisposable> ReceiveAsync<T>(string queue, Func<T, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure, CancellationToken cancellationToken = default)
  • AwaitableDisposable<IDisposable> ReceiveAsync(string queue, Action<IReceiveRegistration> addHandlers, Action<IConsumerConfiguration> configure, CancellationToken cancellationToken = default)
  • Task SendAsync<T>(string queue, T message, CancellationToken cancellationToken = default)
• public class PersistentChannel : IPersistentChannel, IDisposable
  • public PersistentChannel(IPersistentConnection connection, IEasyNetQLogger logger, ConnectionConfiguration configuration, IEventBus eventBus)
  • public PersistentChannel(IPersistentConnection connection, ConnectionConfiguration configuration, IEventBus eventBus)
• public class PersistentChannelFactory : IPersistentChannelFactory
  • public PersistentChannelFactory(IEasyNetQLogger logger, ConnectionConfiguration configuration, IEventBus eventBus)
  • public PersistentChannelFactory(ConnectionConfiguration configuration, IEventBus eventBus)
• public class PublishConfirmationWaiter : IPublishConfirmationWaiter
  • public void Wait(TimeSpan timeout)
• public class PublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
  • public PublishExchangeDeclareStrategy()
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)
  • public Task<IExchange> DeclareExchangeAsync(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public Task<IExchange> DeclareExchangeAsync(IAdvancedBus advancedBus, Type messageType, string exchangeType)
  • public PublishExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
  • public Task<IExchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken)
  • public Task<IExchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken)
• public static class PublishExchangeDeclareStrategyExtensions
  • public static IExchange DeclareExchange(this IPublishExchangeDeclareStrategy strategy, string exchangeName, string exchangeType, CancellationToken cancellationToken = default)
  • public static IExchange DeclareExchange(this IPublishExchangeDeclareStrategy strategy, Type messageType, string exchangeType, CancellationToken cancellationToken = default)
• public static class PubSubExtensions
  • public static void Publish<T>(this IPubSub pubSub, T message, CancellationToken cancellationToken = default)
  • public static void Publish<T>(this IPubSub pubSub, T message, Action<IPublishConfiguration> configure, CancellationToken cancellationToken = default)
  • public static void Publish<T>(this IPubSub pubSub, T message, string topic, CancellationToken cancellationToken = default)
  • public static Task PublishAsync<T>(this IPubSub pubSub, T message, CancellationToken cancellationToken = default)
  • public static Task PublishAsync<T>(this IPubSub pubSub, T message, string topic, CancellationToken cancellationToken = default)
  • public static ISubscriptionResult Subscribe<T>(this IPubSub pubSub, string subscriptionId, Action<T> onMessage, CancellationToken cancellationToken = default)
  • public static ISubscriptionResult Subscribe<T>(this IPubSub pubSub, string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
  • public static ISubscriptionResult Subscribe<T>(IPubSub pubSub, string subscriptionId, Func<T, Task> onMessage, CancellationToken cancellationToken = default)
  • public static ISubscriptionResult Subscribe<T>(this IPubSub pubSub, string subscriptionId, Func<T, CancellationToken, Task> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<ISubscriptionResult> SubscribeAsync<T>(this IPubSub pubSub, string subscriptionId, Action<T> onMessage, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<ISubscriptionResult> SubscribeAsync<T>(this IPubSub pubSub, string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<ISubscriptionResult> SubscribeAsync<T>(IPubSub pubSub, string subscriptionId, Func<T, Task> onMessage, CancellationToken cancellationToken = default)
• public static class ReceiveRegistrationExtensions
  • public static IReceiveRegistration Add<T>(this IReceiveRegistration receiveRegistration, Func<T, Task> onMessage)
  • public static IReceiveRegistration Add<T>(this IReceiveRegistration receiveRegistration, Action<T> onMessage)
• public class Rpc : IRpc
• public class SendReceive : ISendReceive
• public static class RpcExtensions
  • public static TResponse Request<TRequest, TResponse>(this IRpc rpc, TRequest request, CancellationToken cancellationToken = default)
  • public static TResponse Request<TRequest, TResponse>(this IRpc rpc, TRequest request, Action<IRequestConfiguration> configure, CancellationToken cancellationToken = default)
  • public static Task<TResponse> RequestAsync<TRequest, TResponse>(this IRpc rpc, TRequest request, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, Task<TResponse>> responder, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, TResponse> responder, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, Task<TResponse>> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, CancellationToken, Task<TResponse>> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> RespondAsync<TRequest, TResponse>(this IRpc rpc, Func<TRequest, Task<TResponse>> responder, CancellationToken cancellationToken = default)
• public static class SendReceiveExtensions
  • public static IDisposable Receive<T>(this ISendReceive sendReceive, string queue, Action<T> onMessage, CancellationToken cancellationToken = default)
  • public static IDisposable Receive<T>(this ISendReceive sendReceive, string queue, Action<T> onMessage, Action<IConsumerConfiguration> configure, CancellationToken cancellationToken = default)
  • public static IDisposable Receive<T>(this ISendReceive sendReceive, string queue, Func<T, Task> onMessage, CancellationToken cancellationToken = default)
  • public static IDisposable Receive<T>(this ISendReceive sendReceive, string queue, Func<T, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure, CancellationToken cancellationToken = default)
  • public static IDisposable Receive(this ISendReceive sendReceive, string queue, Action<IReceiveRegistration> addHandlers, CancellationToken cancellationToken = default)
  • public static IDisposable Receive(this ISendReceive sendReceive, string queue, Action<IReceiveRegistration> addHandlers, Action<IConsumerConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Action<T> onMessage, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Action<T> onMessage, Action<IConsumerConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Func<T, Task> onMessage, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync(this ISendReceive sendReceive, string queue, Action<IReceiveRegistration> addHandlers, CancellationToken cancellationToken = default)
  • public static void Send<T>(this ISendReceive sendReceive, string queue, T message, CancellationToken cancellationToken = default)

EasyNetQ.Scheduling

• public static class BusExtensions
• public class DeadLetterExchangeAndMessageTtlScheduler : IScheduler
  • public void CancelFuturePublish(string cancellationKey)
  • public Task CancelFuturePublishAsync(string cancellationKey)
  • public void FuturePublish<T>(DateTime futurePublishDate, T message, string cancellationKey = null)
  • public void FuturePublish<T>(DateTime futurePublishDate, T message, string topic, string cancellationKey = null)
  • public void FuturePublish<T>(TimeSpan messageDelay, T message, string cancellationKey = null)
  • public void FuturePublish<T>(TimeSpan messageDelay, T message, string topic, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(DateTime futurePublishDate, T message, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(DateTime futurePublishDate, T message, string topic, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(TimeSpan messageDelay, T message, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(TimeSpan messageDelay, T message, string topic, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(T message, TimeSpan delay, string topic = null, CancellationToken cancellationToken = default)
• public class DelayedExchangeScheduler : IScheduler
  • public void CancelFuturePublish(string cancellationKey)
  • public Task CancelFuturePublishAsync(string cancellationKey)
  • public void FuturePublish<T>(DateTime futurePublishDate, T message, string cancellationKey = null)
  • public void FuturePublish<T>(DateTime futurePublishDate, T message, string topic, string cancellationKey = null)
  • public void FuturePublish<T>(TimeSpan messageDelay, T message, string cancellationKey = null)
  • public void FuturePublish<T>(TimeSpan messageDelay, T message, string topic, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(DateTime futurePublishDate, T message, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(DateTime futurePublishDate, T message, string topic, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(TimeSpan messageDelay, T message, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(TimeSpan messageDelay, T message, string topic, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(T message, TimeSpan delay, string topic = null, CancellationToken cancellationToken = default)
• public class ExternalScheduler : IScheduler
  • public void CancelFuturePublish(string cancellationKey)
  • public Task CancelFuturePublishAsync(string cancellationKey)
  • public void FuturePublish<T>(DateTime futurePublishDate, T message, string cancellationKey = null)
  • public void FuturePublish<T>(DateTime futurePublishDate, T message, string topic, string cancellationKey = null)
  • public void FuturePublish<T>(TimeSpan messageDelay, T message, string cancellationKey = null)
  • public void FuturePublish<T>(TimeSpan messageDelay, T message, string topic, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(DateTime futurePublishDate, T message, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(DateTime futurePublishDate, T message, string topic, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(TimeSpan messageDelay, T message, string cancellationKey = null)
  • public Task FuturePublishAsync<T>(TimeSpan messageDelay, T message, string topic, string cancellationKey = null)
  • public Task CancelFuturePublishAsync(string cancellationKey, CancellationToken cancellationToken = default)
  • public Task FuturePublishAsync<T>(T message, TimeSpan delay, string topic = null, CancellationToken cancellationToken = default)
• public interface IScheduler
  • void CancelFuturePublish(string cancellationKey)
  • Task CancelFuturePublishAsync(string cancellationKey)
  • void FuturePublish<T>(DateTime futurePublishDate, T message, string cancellationKey = null)
  • void FuturePublish<T>(DateTime futurePublishDate, T message, string topic, string cancellationKey = null)
  • void FuturePublish<T>(TimeSpan messageDelay, T message, string cancellationKey = null)
  • void FuturePublish<T>(TimeSpan messageDelay, T message, string topic, string cancellationKey = null)
  • Task FuturePublishAsync<T>(DateTime futurePublishDate, T message, string cancellationKey = null)
  • Task FuturePublishAsync<T>(DateTime futurePublishDate, T message, string topic, string cancellationKey = null)
  • Task FuturePublishAsync<T>(TimeSpan messageDelay, T message, string cancellationKey = null)
  • Task FuturePublishAsync<T>(TimeSpan messageDelay, T message, string topic, string cancellationKey = null)
  • Task FuturePublishAsync<T>(T message, TimeSpan delay, string topic = null, CancellationToken cancellationToken = default)
• public static class SchedulerExtensions
  • public static void FuturePublish<T>(this IScheduler scheduler, T message, TimeSpan delay, string topic = null, CancellationToken cancellationToken = default)
• public static class SchedulingExtensions
  • public static IServiceRegister EnableDeadLetterExchangeAndMessageTtlScheduler(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableDelayedExchangeScheduler(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableDeadLetterExchangeAndMessageTtlScheduler(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableDelayedExchangeScheduler(this IServiceRegister serviceRegister)