EasyNetQ by Mike Hadlow, Chris Edwards, A Hazelwood

<PackageReference Include="EasyNetQ" Version="0.33.2.277" />

---

API Diff between 0.33.2.277 and 3.4.0-alpha0011

404 Additions 406 Removals

EasyNetQ

• public class AdvancedBusEventHandlers
• public static class AdvancedBusExtensions
• public class BasicGetResult : IBasicGetResult
• public class BasicGetResult<T> : IBasicGetResult<T>
• public static class BusExtensions
  • public static void CancelFuturePublish(this IBus bus, string cancellationKey)
  • public static Task CancelFuturePublishAsync(this IBus bus, string cancellationKey)
  • public static void FuturePublish<T>(this IBus bus, DateTime futurePublishDate, T message)
  • public static void FuturePublish<T>(this IBus bus, DateTime futurePublishDate, string cancellationKey, T message)
  • public static Task FuturePublishAsync<T>(this IBus bus, DateTime futurePublishDate, T message)
  • public static Task FuturePublishAsync<T>(this IBus bus, DateTime futurePublishDate, string cancellationKey, T message)
• public sealed delegate CancelSubscription : MulticastDelegate
  • public CancelSubscription(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke()
• public class ComponentRegistration
  • public ComponentRegistration()
  • public static void RegisterServices(IContainer container)
• public class ConnectionConfiguration : IConnectionConfiguration
  • public IList<AuthMechanismFactory> AuthMechanisms { get; set; }
  • public bool CancelOnHaFailover { get; set; }
  • public TimeSpan ConnectIntervalAttempt { get; set; }
  • public IEnumerable<HostConfiguration> Hosts { get; set; }
  • public string Name { get; set; }
  • public IEnumerable<IHostConfiguration> Hosts { get; set; }
  • public bool UseBackgroundThreads { get; set; }
• public class ConnectionFactoryInfo
  • public HostConfiguration HostConfiguration { get; }
  • public ConnectionFactoryInfo(ConnectionFactory connectionFactory, HostConfiguration hostConfiguration)
  • public IHostConfiguration HostConfiguration { get; }
  • public ConnectionFactoryInfo(ConnectionFactory connectionFactory, IHostConfiguration hostConfiguration)
• public class ConnectionFactoryWrapper : IConnectionFactory
  • public virtual ConnectionConfiguration Configuration { get; }
  • public virtual HostConfiguration CurrentHost { get; }
  • public virtual IConnectionConfiguration Configuration { get; }
  • public virtual IHostConfiguration CurrentHost { get; }
  • public ConnectionFactoryWrapper(ConnectionConfiguration connectionConfiguration, IClusterHostSelectionStrategy<ConnectionFactoryInfo> clusterHostSelectionStrategy)
  • public ConnectionFactoryWrapper(IConnectionConfiguration connectionConfiguration, IClusterHostSelectionStrategy<ConnectionFactoryInfo> clusterHostSelectionStrategy)
• public class Conventions : IConventions
  • public RpcExchangeNameConvention RpcRequestExchangeNamingConvention { get; set; }
  • public RpcExchangeNameConvention RpcResponseExchangeNamingConvention { get; set; }
  • public RpcExchangeNameConvention RpcExchangeNamingConvention { get; set; }
• public class DefaultClusterHostSelectionStrategy<T> : IClusterHostSelectionStrategy<T>, IEnumerable<T>, IEnumerable
  • public virtual bool Succeeded { get; }
  • public DefaultClusterHostSelectionStrategy()
  • public virtual void Add(T item)
  • public virtual T Current()
  • public virtual IEnumerator<T> GetEnumerator()
  • public virtual bool Next()
  • public virtual void Reset()
  • public virtual void Success()
• public class DefaultMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • public SerializedMessage SerializeMessage(IMessage message)
  • public DeserializedMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • public SerializedMessage SerializeMessage<T>(IMessage<T> message)
• public class DefaultTypeNameSerializer : ITypeNameSerializer
• public class DeliveryModeAttribute : Attribute
• public class DefaultServiceProvider : IContainer, IServiceProvider, IServiceRegister
  • public DefaultServiceProvider()
  • public virtual IServiceRegister Register<TService>(Func<IServiceProvider, TService> serviceCreator)
  • public IServiceRegister Register<TService, TImplementation>() where TImplementation : TService
  • public virtual TService Resolve<TService>()
  • public object Resolve(Type serviceType)
• public class DeserializedMessage
  • public object Message { get; }
  • public Type MessageType { get; }
  • public DeserializedMessage(Type messageType, object message)
• public class EasyNetQException : Exception
  • protected EasyNetQException(SerializationInfo info, StreamingContext context)
• public class EasyNetQInvalidMessageTypeException : EasyNetQException
  • public EasyNetQInvalidMessageTypeException()
  • public EasyNetQInvalidMessageTypeException(string message)
  • public EasyNetQInvalidMessageTypeException(string format, string[] args)
  • public EasyNetQInvalidMessageTypeException(string message, Exception inner)
  • protected EasyNetQInvalidMessageTypeException(SerializationInfo info, StreamingContext context)
• public class EasyNetQResponderException : EasyNetQException
  • protected EasyNetQResponderException(SerializationInfo info, StreamingContext context)
• public sealed delegate ErrorQueueNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(MessageReceivedInfo info, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual string Invoke(MessageReceivedInfo info)
  • public virtual string Invoke()
• public class EventBus : IEventBus
  • public IDisposable Subscribe<TEvent>(Action<TEvent> eventHandler)
  • public CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
• public static class Extensions
• public class HostConfiguration : IHostConfiguration
  • public SslOption Ssl { get; }
• public interface IAdvancedBus : IDisposable
  • IServiceResolver Container { get; }
  • IConventions Conventions { get; }
  • IContainer Container { get; }
  • event EventHandler<ConnectionBlockedEventArgs> Blocked
  • event EventHandler Connected
  • event EventHandler Disconnected
  • event EventHandler<MessageReturnedEventArgs> MessageReturned
  • event EventHandler Unblocked
  • 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(IEnumerable<QueueConsumerPair> queueConsumerPairs, Action<IConsumerConfiguration> configure)
  • IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure)
  • event Action Connected
  • event Action Disconnected
  • event Action<byte[], MessageProperties, MessageReturnedInfo> MessageReturned
  • IBinding Bind(IExchange exchange, IQueue queue, string routingKey)
  • IBinding Bind(IExchange source, IExchange destination, string routingKey)
  • void BindingDelete(IBinding binding)
  • 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(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)
  • 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)
  • void ExchangeDelete(IExchange exchange, bool ifUnused = false)
  • void Publish(IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body)
  • void Publish<T>(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage<T> message)
  • Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body)
  • Task PublishAsync<T>(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage<T> message)
  • IQueue QueueDeclare(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int perQueueTtl = 2147483647, int expires = 2147483647, string deadLetterExchange = null)
  • IQueue QueueDeclare()
  • void QueueDelete(IQueue queue, bool ifUnused = false, bool ifEmpty = false)
  • void QueuePurge(IQueue queue)
• public interface IBasicGetResult
• public interface IBasicGetResult<T>
• public interface IBus : IDisposable
  • IPubSub PubSub { get; }
  • IRpc Rpc { get; }
  • IScheduler Scheduler { get; }
  • ISendReceive SendReceive { get; }
  • bool IsConnected { get; }
  • event Action Connected
  • event Action Disconnected
  • void Publish<T>(T message)
  • void Publish<T>(T message, string topic)
  • Task PublishAsync<T>(T message)
  • Task PublishAsync<T>(T message, string topic)
  • IDisposable Receive<T>(string queue, Action<T> onMessage)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • TResponse Request<TRequest, TResponse>(TRequest request)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • void Send<T>(string queue, T message)
  • IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
• public interface IConnectionConfiguration
  • Uri AMQPConnectionString { get; }
  • bool CancelOnHaFailover { get; }
  • IDictionary<string, object> ClientProperties { get; }
  • IEnumerable<IHostConfiguration> Hosts { get; }
  • string Password { get; }
  • bool PersistentMessages { get; set; }
  • ushort Port { get; }
  • ushort PrefetchCount { get; }
  • bool PublisherConfirms { get; }
  • ushort RequestedHeartbeat { get; }
  • SslOption Ssl { get; }
  • ushort Timeout { get; }
  • string UserName { get; }
  • string VirtualHost { get; }
• public interface IConnectionFactory
  • ConnectionConfiguration Configuration { get; }
  • HostConfiguration CurrentHost { get; }
  • IConnectionConfiguration Configuration { get; }
  • IHostConfiguration CurrentHost { get; }
• public interface IContainer : IServiceProvider, IServiceRegister
• public interface IConventions
  • RpcExchangeNameConvention RpcRequestExchangeNamingConvention { get; set; }
  • RpcExchangeNameConvention RpcResponseExchangeNamingConvention { get; set; }
  • RpcExchangeNameConvention RpcExchangeNamingConvention { get; set; }
• public interface IEasyNetQLogger
  • void DebugWrite(string format, object[] args)
  • void ErrorWrite(string format, object[] args)
  • void ErrorWrite(Exception exception)
  • void InfoWrite(string format, object[] args)
• public interface IEventBus
  • IDisposable Subscribe<TEvent>(Action<TEvent> eventHandler)
  • CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
• public interface IMessage
• public interface IHostConfiguration
  • string Host { get; }
  • ushort Port { get; }
• public interface IMessage<T>
  • MessageProperties Properties { get; }
• public interface IMessageDeliveryModeStrategy
• public interface IMessageSerializationStrategy
  • IMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • SerializedMessage SerializeMessage(IMessage message)
  • DeserializedMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • SerializedMessage SerializeMessage<T>(IMessage<T> message)
• public interface IPersistentConnection : IDisposable
  • void Initialize()
• public interface IPersistentConnectionFactory
• public interface ISaga
  • void Initialize(IBus bus)
• public interface ISerializer
  • object BytesToMessage(Type type, byte[] bytes)
  • object BytesToMessage(string typeName, byte[] bytes)
• public interface ISubscriptionResult : IDisposable
• public interface ITimeoutStrategy
• public interface IServiceProvider
  • TService Resolve<TService>()
• public interface IServiceRegister
  • IServiceRegister Register<TService>(Func<IServiceProvider, TService> serviceCreator)
  • IServiceRegister Register<TService, TImplementation>() where TImplementation : TService
• public class JsonSerializer : ISerializer
  • public JsonSerializer()
  • public JsonSerializer(JsonSerializerSettings serializerSettings)
  • public JsonSerializer(ITypeNameSerializer typeNameSerializer)
  • public object BytesToMessage(Type type, byte[] bytes)
  • public object BytesToMessage(string typeName, byte[] bytes)
• public class LegacyTypeNameSerializer : ITypeNameSerializer
• public static class LegacyTypeNamingExtensions
• public static class LinqExtensions
  • public static IEnumerable<T> AtLeastOneWithDefault<T>(this IEnumerable<T> items, T default)
  • public static IEnumerable<KeyValuePair<string, string>> EnumerateDictionary(this IDictionary<string, object> dictionary)
• public static class Message
  • public static object CreateInstance(Type messageType, object body)
• public class Message<T> : IMessage<T>
  • public Type MessageType { get; }
  • public Message(T body, MessageProperties properties)
  • public object GetBody()
  • public void SetProperties(MessageProperties properties)
• public static class MessageDeliveryMode
• public class MessageDeliveryModeStrategy : IMessageDeliveryModeStrategy
• public static class MessageFactory
• public class MessageNotAvailableException : Exception
• public class MessageProperties
  • public object Clone()
  • public void AppendPropertyDebugStringTo(StringBuilder stringBuilder)
• public class MessageReturnedEventArgs : EventArgs
• public class OrderedClusterHostSelectionStrategy<T> : IClusterHostSelectionStrategy<T>, IEnumerable<T>, IEnumerable
• public class PersistentConnection : IPersistentConnection, IDisposable
  • public PersistentConnection(IConnectionFactory connectionFactory, IEventBus eventBus)
  • public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger, IEventBus eventBus)
  • public void Initialize()
  • public void OnConnected()
  • public void OnDisconnected()
• public class PersistentConnectionFactory : IPersistentConnectionFactory
• public class QueueConsumerPair
• public class RabbitAdvancedBus : IAdvancedBus, IDisposable
  • public IServiceResolver Container { get; }
  • public IConventions Conventions { get; }
  • public IContainer Container { get; }
  • public event EventHandler<ConnectionBlockedEventArgs> Blocked
  • public event EventHandler Connected
  • public event EventHandler Disconnected
  • public event EventHandler<MessageReturnedEventArgs> MessageReturned
  • public event EventHandler Unblocked
  • 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(IEnumerable<QueueConsumerPair> queueConsumerPairs, Action<IConsumerConfiguration> configure)
  • public IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public event Action Connected
  • public event Action Disconnected
  • public event Action<byte[], MessageProperties, MessageReturnedInfo> MessageReturned
  • public RabbitAdvancedBus(IConnectionFactory connectionFactory, IConsumerFactory consumerFactory, IEasyNetQLogger logger, IClientCommandDispatcherFactory clientCommandDispatcherFactory, IPublisher publisher, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, IContainer container, IConnectionConfiguration connectionConfiguration, IMessageSerializationStrategy messageSerializationStrategy)
  • public virtual IBinding Bind(IExchange exchange, IQueue queue, string routingKey)
  • public virtual IBinding Bind(IExchange source, IExchange destination, string routingKey)
  • public virtual void BindingDelete(IBinding binding)
  • 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 virtual IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> 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 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)
  • protected void OnBlocked(ConnectionBlockedEvent args)
  • public virtual IExchange ExchangeDeclare(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null)
  • public virtual void ExchangeDelete(IExchange exchange, bool ifUnused = false)
  • protected void OnUnblocked()
  • 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 void Publish(IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body)
  • public void Publish<T>(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage<T> message)
  • public virtual Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body)
  • public virtual Task PublishAsync<T>(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage<T> message)
  • public virtual IQueue QueueDeclare(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int perQueueTtl = 2147483647, int expires = 2147483647, string deadLetterExchange = null)
  • public virtual IQueue QueueDeclare()
  • public virtual void QueueDelete(IQueue queue, bool ifUnused = false, bool ifEmpty = false)
  • public virtual void QueuePurge(IQueue queue)
• public class RabbitBus : IBus, IDisposable
  • 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 IConventions Conventions { get; }
  • public virtual bool IsConnected { get; }
  • public IEasyNetQLogger Logger { get; }
  • public event Action Connected
  • public event Action Disconnected
  • public RabbitBus(IEasyNetQLogger logger, IConventions conventions, IAdvancedBus advancedBus, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IRpc rpc, ISendReceive sendReceive, IConnectionConfiguration connectionConfiguration)
  • protected void OnConnected()
  • protected void OnDisconnected()
  • public virtual void Publish<T>(T message)
  • public virtual void Publish<T>(T message, string topic)
  • public virtual Task PublishAsync<T>(T message)
  • public virtual Task PublishAsync<T>(T message, string topic)
  • public virtual IDisposable Receive<T>(string queue, Action<T> onMessage)
  • public virtual IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • public virtual IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • public virtual TResponse Request<TRequest, TResponse>(TRequest request)
  • public virtual Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • public virtual IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • public virtual IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • public virtual void Send<T>(string queue, T message)
  • public virtual IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • public virtual IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • public virtual IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • public virtual IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
• public static class RabbitBusExtensions
  • public static void FuturePublish<T>(this IBus bus, TimeSpan messageDelay, T message)
  • public static Task FuturePublishAsync<T>(this IBus bus, TimeSpan messageDelay, T message)
• public static class RabbitHutch
  • 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 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(IConnectionConfiguration connectionConfiguration, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus()
  • public static void SetContainerFactory(Func<IContainer> createContainer)
• public static class ReflectionHelpers
• public sealed delegate RpcExchangeNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(Type messageType, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual string Invoke(Type messageType)
  • public virtual string Invoke()
• public sealed class SubscriptionResult : ISubscriptionResult, IDisposable
• public sealed delegate SubsriberNameFromDelegate : MulticastDelegate
  • public SubsriberNameFromDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Delegate delegate, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(Delegate delegate)
• public sealed class TimeBudget
• public class TimeoutSecondsAttribute : Attribute
• public class TimeoutStrategy : ITimeoutStrategy
• public static class TaskHelpers
  • public static Task ExecuteSynchronously(Action action)
  • public static Task FromException(Exception ex)
• public class TypeNameSerializer : ITypeNameSerializer
  • public TypeNameSerializer()
  • public Type DeSerialize(string typeName)
  • public string Serialize(Type type)

EasyNetQ.AutoSubscribe

• public class AutoSubscriber
  • protected readonly IBus Bus
  • protected const string ConsumeMethodName = "Consume"
  • protected const string DispatchAsyncMethodName = "DispatchAsync"
  • protected const string DispatchMethodName = "Dispatch"
  • protected readonly IBus bus
  • protected Action<ISubscriptionConfiguration> ConfigureSubscriptionConfiguration { get; set; }
  • protected virtual IEnumerable<AutoSubscriberConsumerInfo> GetSubscriberConsumerInfos(IEnumerable<Type> types, Type interfaceType)
  • protected virtual MethodInfo GetSubscribeMethodOfBus(string methodName, Type parmType)
  • public virtual Task<IDisposable> SubscribeAsync(Type[] consumerTypes, CancellationToken cancellationToken = default)
  • protected virtual IEnumerable<KeyValuePair<Type, AutoSubscriberConsumerInfo[]>> GetSubscriptionInfos(IEnumerable<Type> types, Type interfaceType)
  • protected 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 SubscribeAsync(Assembly[] assemblies)
• public class AutoSubscriberConsumerInfo
  • public Type ConcreteType { get; }
  • public MethodInfo ConsumeMethod { get; }
  • public Type MessageType { get; }
  • public readonly Type ConcreteType
  • public readonly Type InterfaceType
  • public readonly Type MessageType
• public static class AutoSubscriberExtensions
• public class DefaultAutoSubscriberMessageDispatcher : IAutoSubscriberMessageDispatcher
  • public DefaultAutoSubscriberMessageDispatcher(IServiceResolver resolver)
  • 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 void Dispatch<TMessage, TConsumer>(TMessage message) where TConsumer : IConsume<TMessage>
  • public Task DispatchAsync<TMessage, TConsumer>(TMessage message) where TConsumer : IConsumeAsync<TMessage>
• public interface IAutoSubscriberMessageDispatcher
  • 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>
  • void Dispatch<TMessage, TConsumer>(TMessage message) where TConsumer : IConsume<TMessage>
  • Task DispatchAsync<TMessage, TConsumer>(TMessage message) where TConsumer : IConsumeAsync<TMessage>
• public interface IConsume<T>
  • void Consume(T message, CancellationToken cancellationToken = default)
  • void Consume(T message)
• public interface IConsumeAsync<T>
  • Task ConsumeAsync(T message, CancellationToken cancellationToken = default)
  • Task Consume(T message)
• public class SubscriptionConfigurationAttribute : Attribute

EasyNetQ.ConnectionString

• public static class ConnectionStringGrammar
  • public static Parser<HostConfiguration> Host
  • public static Parser<IEnumerable<HostConfiguration>> Hosts
  • public static Parser<IHostConfiguration> Host
  • public static Parser<IEnumerable<IHostConfiguration>> Hosts
• public class ConnectionStringParser : IConnectionStringParser
  • public ConnectionConfiguration Parse(string connectionString)
  • public IConnectionConfiguration Parse(string connectionString)
• public interface IConnectionStringParser
  • ConnectionConfiguration Parse(string connectionString)
  • IConnectionConfiguration Parse(string connectionString)

EasyNetQ.Consumer

• public static class AckStrategies
  • public static AckStrategy Nothing
• public class Base64ErrorMessageSerializer : IErrorMessageSerializer
• public class BasicConsumer : IBasicConsumer, IDisposable
• public class ConsumerConfiguration : IConsumerConfiguration
  • public bool IsExclusive { get; }
  • public bool CancelOnHaFailover { get; }
  • public IConsumerConfiguration WithExclusive(bool isExclusive)
  • public IConsumerConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
• public class ConsumerDispatcher : IConsumerDispatcher, IDisposable
  • public ConsumerDispatcher(ConnectionConfiguration configuration)
  • public ConsumerDispatcher(IEasyNetQLogger logger)
• public class ConsumerDispatcherFactory : IConsumerDispatcherFactory, IDisposable
  • public ConsumerDispatcherFactory(ConnectionConfiguration configuration)
  • public ConsumerDispatcherFactory(IEasyNetQLogger logger)
• public class ConsumerExecutionContext
  • public IBasicConsumer Consumer { get; }
  • 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 Func<byte[], MessageProperties, MessageReceivedInfo, Task> UserHandler { get; }
  • public ConsumerExecutionContext(Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler, MessageReceivedInfo info, MessageProperties properties, byte[] body, IBasicConsumer consumer)
• public class ConsumerFactory : IConsumerFactory, IDisposable
  • 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 IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
• public class DefaultConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable
  • protected IConnection Connection { get; }
  • public DefaultConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer, IConventions conventions, ITypeNameSerializer typeNameSerializer, IErrorMessageSerializer errorMessageSerializer)
  • protected void Connect()
  • public DefaultConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer, IEasyNetQLogger logger, IConventions conventions, ITypeNameSerializer typeNameSerializer)
• public class DefaultErrorMessageSerializer : IErrorMessageSerializer
• public class ExclusiveConsumer : IConsumer, IDisposable
• public class HandlerCollection : IHandlerCollection, IHandlerRegistration
  • 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 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 object GetHandler(Type messageType)
• public class HandlerCollectionFactory : IHandlerCollectionFactory
  • public HandlerCollectionFactory()
  • public IHandlerCollection CreateHandlerCollection(IQueue queue)
  • public HandlerCollectionFactory(IEasyNetQLogger logger)
  • public IHandlerCollection CreateHandlerCollection()
• public class HandlerCollectionPerQueueFactory : IHandlerCollectionFactory
• public static class HandlerRegistrationExtensions
• public class HandlerRunner : IHandlerRunner, IDisposable
  • public HandlerRunner(IConsumerErrorStrategy consumerErrorStrategy)
  • public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus)
  • public virtual Task<AckStrategy> InvokeUserMessageHandlerAsync(ConsumerExecutionContext context, CancellationToken cancellationToken)
  • public void InvokeUserMessageHandler(ConsumerExecutionContext context)
• public interface IConsumerConfiguration
  • bool IsExclusive { get; }
  • bool CancelOnHaFailover { get; }
  • IConsumerConfiguration WithExclusive(bool isExclusive)
  • IConsumerConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
• public interface IConsumerFactory : IDisposable
  • 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)
  • IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
• public interface IErrorMessageSerializer
• public interface IHandlerCollection : IHandlerRegistration
  • Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> GetHandler<T>()
  • Func<IMessage, MessageReceivedInfo, CancellationToken, Task> GetHandler(Type messageType)
  • Func<IMessage<T>, MessageReceivedInfo, Task> GetHandler<T>()
  • object GetHandler(Type messageType)
• public interface IHandlerCollectionFactory
  • IHandlerCollection CreateHandlerCollection(IQueue queue)
  • IHandlerCollection CreateHandlerCollection()
• public interface IHandlerRegistration
  • IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler)
  • IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • IHandlerRegistration Add<T>(Action<IMessage<T>, MessageReceivedInfo> handler)
• public interface IHandlerRunner : IDisposable
  • Task<AckStrategy> InvokeUserMessageHandlerAsync(ConsumerExecutionContext context, CancellationToken cancellationToken = default)
  • void InvokeUserMessageHandler(ConsumerExecutionContext context)
• public interface IInternalConsumer : IDisposable
  • 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)
  • void StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
• public class InternalConsumer : IBasicConsumer, IInternalConsumer, IDisposable
  • public string ConsumerTag { get; }
  • public InternalConsumer(IHandlerRunner handlerRunner, IConsumerDispatcher consumerDispatcher, IConventions conventions, IEventBus eventBus)
  • public event ConsumerCancelledEventHandler ConsumerCancelled
  • public InternalConsumer(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConsumerDispatcher consumerDispatcher, IConventions conventions, IConnectionConfiguration connectionConfiguration, IEventBus eventBus)
  • 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 void HandleBasicCancel(string consumerTag)
  • public void HandleBasicCancelOk(string consumerTag)
  • public void HandleBasicConsumeOk(string consumerTag)
  • public void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
  • public void HandleModelShutdown(IModel model, ShutdownEventArgs reason)
  • public void StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
• public class InternalConsumerFactory : IInternalConsumerFactory, IDisposable
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IConventions conventions, IConsumerDispatcherFactory consumerDispatcherFactory, IEventBus eventBus)
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConventions conventions, IConnectionConfiguration connectionConfiguration, IConsumerDispatcherFactory consumerDispatcherFactory, IEventBus eventBus)
• public interface IReceiveRegistration
  • IReceiveRegistration Add<T>(Func<T, Task> onMessage)
  • IReceiveRegistration Add<T>(Action<T> onMessage)
• public class PersistentConsumer : IConsumer, IDisposable
  • public PersistentConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public PersistentConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
• public class PersistentMultipleConsumer : IConsumer, IDisposable
• public enum StartConsumingStatus
• public class TransientConsumer : IConsumer, IDisposable
  • public TransientConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, CancellationToken, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public TransientConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)

EasyNetQ.DI

• public class DefaultServiceContainer : IServiceRegister
• public static class DefaultServicesRegistration
• public interface IServiceRegister
• public interface IServiceResolver
• public interface IServiceResolverScope : IServiceResolver, IDisposable
• public enum Lifetime
• public class ServiceResolverScope : IServiceResolverScope, IServiceResolver, IDisposable

EasyNetQ.Events

• public class AckEvent
  • public byte[] Body { get; }
  • public MessageProperties Properties { get; }
  • public MessageReceivedInfo ReceivedInfo { get; }
  • public AckEvent(MessageReceivedInfo info, MessageProperties properties, byte[] body, AckResult ackResult)
  • public ConsumerExecutionContext ConsumerExecutionContext { get; }
  • public AckEvent(ConsumerExecutionContext consumerExecutionContext, AckResult ackResult)
• public enum AckResult
  • Nothing = 3
• public class ConnectionBlockedEvent
• public class ConnectionUnblockedEvent
• public class DeliveredMessageEvent
• public class MessageConfirmationEvent
• public class PublishedMessageEvent
• public class StartConsumingFailedEvent
• public class StartConsumingSucceededEvent

EasyNetQ.FluentConfiguration

• public interface IPublishConfiguration
• public interface IRequestConfiguration
• public interface ISubscriptionConfiguration
  • ISubscriptionConfiguration AsExclusive(bool isExclusive = true)
  • ISubscriptionConfiguration WithDurable(bool durable = true)
  • ISubscriptionConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • ISubscriptionConfiguration WithMaxLength(int maxLength)
  • ISubscriptionConfiguration WithMaxLengthBytes(int maxLengthBytes)
  • ISubscriptionConfiguration WithMaxPriority(byte priority)
  • ISubscriptionConfiguration WithQueueName(string queueName)
• public class PublishConfiguration : IPublishConfiguration
• public class RequestConfiguration : IRequestConfiguration
• public class SubscriptionConfiguration : ISubscriptionConfiguration
  • public bool Durable { get; }
  • public int? Expires { get; }
  • public bool IsExclusive { get; }
  • public int? MaxLength { get; }
  • public int? MaxLengthBytes { get; }
  • public byte? MaxPriority { get; }
  • public bool CancelOnHaFailover { get; }
  • public int Expires { get; }
  • public string QueueName { get; }
  • public ISubscriptionConfiguration AsExclusive(bool isExclusive = true)
  • public ISubscriptionConfiguration WithDurable(bool durable = true)
  • public ISubscriptionConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • public ISubscriptionConfiguration WithMaxLength(int maxLength)
  • public ISubscriptionConfiguration WithMaxLengthBytes(int maxLengthBytes)
  • public ISubscriptionConfiguration WithMaxPriority(byte priority)
  • public ISubscriptionConfiguration WithQueueName(string queueName)

EasyNetQ.Interception

• public class CompositeInterceptor : IProduceConsumeInterceptor
• public class DefaultInterceptor : IProduceConsumeInterceptor
• public class GZipInterceptor : IProduceConsumeInterceptor
• public interface IInterceptorRegistrator
• public static class InterceptionExtensions
• public class InterceptorRegistrator : IInterceptorRegistrator
• public interface IProduceConsumeInterceptor
• public struct RawMessage
• public class TripleDESInterceptor : IProduceConsumeInterceptor

EasyNetQ.Internals

• public sealed class AsyncLock
• public struct AwaitableDisposable<T> where T : IDisposable
• public static class AwaitableDisposableExtensions
• public static class TaskHelpers
• public static class Timers

EasyNetQ.LightInject

• public class AssemblyScanner : IAssemblyScanner
• public class CachedTypeExtractor : ITypeExtractor
• public class CompositionRootAttributeExtractor : ICompositionRootAttributeExtractor
• public class CompositionRootExecutor : ICompositionRootExecutor
• public class CompositionRootTypeAttribute : Attribute
• public class CompositionRootTypeExtractor : ITypeExtractor
• public class ConcreteTypeExtractor : ITypeExtractor
• public class ConstructionInfo
• public class ConstructionInfoProvider : IConstructionInfoProvider
• public class ConstructorDependency : Dependency
• public class ConstructorDependencySelector : IConstructorDependencySelector
• public class ContainerOptions
• public class DecoratorRegistration : Registration
• public abstract class Dependency
• public class DynamicMethod
• public class Emitter : IEmitter
• public static class EmitterExtensions
• public static class Ensure
• public class ExcludeFromCodeCoverageAttribute : Attribute
• public class GenericArgumentMapper : IGenericArgumentMapper
• public class GenericMappingResult
• public interface IAssemblyScanner
• public interface ICompositionRoot
• public interface ICompositionRootAttributeExtractor
• public interface ICompositionRootExecutor
• public interface IConstructionInfoBuilder
• public interface IConstructionInfoProvider
• public interface IConstructorDependencySelector
• public interface IConstructorSelector
• public interface IEmitter
• public interface IGenericArgumentMapper
• public class ILGenerator
• public interface ILifetime
• public interface IMethodSkeleton
• public sealed class ImmutableHashTable<TKey, TValue>
• public static class ImmutableHashTableExtensions
• public sealed class ImmutableHashTree<TKey, TValue>
• public static class ImmutableHashTreeExtensions
• public sealed class ImmutableList<T>
• public class Instruction
• public class Instruction<T> : Instruction
• public interface IPropertyDependencySelector
• public interface IPropertySelector
• public interface IScopeManager
• public interface IScopeManagerProvider
• public interface IServiceContainer : IServiceRegistry, IServiceFactory, IDisposable
• public interface IServiceFactory
• public interface IServiceNameProvider
• public interface IServiceRegistry
• public interface ITypeConstructionInfoBuilder
• public interface ITypeExtractor
• public sealed class KeyValue<TKey, TValue>
• public class LocalBuilder
• public class LogEntry
• public static class LogExtensions
• public class LogicalThreadStorage<T>
• public enum LogLevel
• public class MostResolvableConstructorSelector : IConstructorSelector
• public class PerContainerLifetime : ILifetime, IDisposable
• public class PerLogicalCallContextScopeManager : ScopeManager
• public class PerLogicalCallContextScopeManagerProvider : ScopeManagerProvider
• public class PerRequestLifeTime : ILifetime
• public class PerScopeLifetime : ILifetime
• public class PerThreadScopeManager : ScopeManager
• public class PerThreadScopeManagerProvider : ScopeManagerProvider
• public class PropertyDependency : Dependency
• public class PropertyDependencySelector : IPropertyDependencySelector
• public class PropertySelector : IPropertySelector
• public abstract class Registration
• public static class RuntimeArgumentsLoader
• public class Scope : IServiceFactory, IDisposable
• public abstract class ScopeManager : IScopeManager
• public abstract class ScopeManagerProvider : IScopeManagerProvider
• public class ServiceContainer : IServiceContainer, IServiceRegistry, IServiceFactory, IDisposable
• public static class ServiceFactoryExtensions
• public class ServiceNameProvider : IServiceNameProvider
• public class ServiceRegistration : Registration
• public class ServiceRequest
• public class ThreadSafeDictionary<TKey, TValue> : ConcurrentDictionary<TKey, TValue>
• public class TypeConstructionInfoBuilder : IConstructionInfoBuilder

EasyNetQ.Loggers

• public class ConsoleLogger : IEasyNetQLogger
  • public bool Debug { get; set; }
  • public bool Error { get; set; }
  • public bool Info { get; set; }
  • public ConsoleLogger()
  • public void DebugWrite(string format, object[] args)
  • public void ErrorWrite(string format, object[] args)
  • public void ErrorWrite(Exception exception)
  • public void InfoWrite(string format, object[] args)
  • public void SafeConsoleWrite(string format, object[] args)
• public class DelegateLogger : IEasyNetQLogger
  • public Action<string, object[]> DebugWriteDelegate { get; set; }
  • public Action<string, object[]> DefaultWrite { get; set; }
  • public Action<string, object[]> ErrorWriteDelegate { get; set; }
  • public Action<string, object[]> InfoWriteDelegate { get; set; }
  • public DelegateLogger()
  • public void DebugWrite(string format, object[] args)
  • public void ErrorWrite(string format, object[] args)
  • public void ErrorWrite(Exception exception)
  • public void InfoWrite(string format, object[] args)
• public class NullLogger : IEasyNetQLogger
  • public NullLogger()
  • public void DebugWrite(string format, object[] args)
  • public void ErrorWrite(string format, object[] args)
  • public void ErrorWrite(Exception exception)
  • public void InfoWrite(string format, object[] args)

EasyNetQ.Logging

• public class ConsoleLogProvider : ILogProvider
• public interface ILog
• public interface ILogProvider
• public static class LogExtensions
• public sealed delegate Logger : MulticastDelegate
• public enum LogLevel
• public static class LogProvider

EasyNetQ.MessageVersioning

• public class MessageType
  • public Type Type { get; set; }
  • public string TypeString { get; set; }
  • public MessageType()
• public class MessageTypeProperty
  • public Type GetMessageType()
  • public MessageType 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 DeserializeMessage(MessageProperties properties, byte[] body)
  • public SerializedMessage SerializeMessage(IMessage message)
  • public DeserializedMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • public SerializedMessage SerializeMessage<T>(IMessage<T> message)
• public class VersionedPublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
  • 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)
  • public VersionedPublishExchangeDeclareStrategy()
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)

EasyNetQ.MultipleExchange

• public static class MultipleExchangeExtension
• public class MultipleExchangePublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy

EasyNetQ.NonGeneric

• public static class NonGenericExtensions
  • public static void Publish(this IBus bus, Type messageType, object message)
  • public static void Publish(this IBus bus, Type messageType, object message, string topic)
  • public static Task PublishAsync(this IBus bus, Type messageType, object message)
  • public static Task PublishAsync(this IBus bus, Type messageType, object message, string topic)
  • public static IDisposable Subscribe(this IBus bus, Type messageType, string subscriptionId, Action<object> onMessage)
  • public static IDisposable Subscribe(this IBus bus, Type messageType, string subscriptionId, Action<object> onMessage, Action<ISubscriptionConfiguration> configure)
  • public static IDisposable SubscribeAsync(this IBus bus, Type messageType, string subscriptionId, Func<object, Task> onMessage)
  • public static IDisposable SubscribeAsync(this IBus bus, Type messageType, string subscriptionId, Func<object, Task> onMessage, Action<ISubscriptionConfiguration> configure)

EasyNetQ.Producer

• public class ClientCommandDispatcher : IClientCommandDispatcher, IDisposable
  • public ClientCommandDispatcher(ConnectionConfiguration configuration, IPersistentConnection connection, IPersistentChannelFactory persistentChannelFactory)
  • public ClientCommandDispatcher(IPersistentConnection connection, IPersistentChannelFactory persistentChannelFactory)
  • public Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, CancellationToken cancellationToken)
  • public Task InvokeAsync(Action<IModel> channelAction, CancellationToken cancellationToken)
  • public Task<T> Invoke<T>(Func<IModel, T> channelAction)
  • public Task Invoke(Action<IModel> channelAction)
• public class ClientCommandDispatcherFactory : IClientCommandDispatcherFactory
  • public ClientCommandDispatcherFactory(ConnectionConfiguration configuration, IPersistentChannelFactory persistentChannelFactory)
  • public ClientCommandDispatcherFactory(IPersistentChannelFactory persistentChannelFactory)
• public class ClientCommandDispatcherSingleton : IClientCommandDispatcher, IDisposable
  • public ClientCommandDispatcherSingleton(ConnectionConfiguration configuration, IPersistentConnection connection, IPersistentChannelFactory persistentChannelFactory)
  • public ClientCommandDispatcherSingleton(IPersistentConnection connection, IPersistentChannelFactory persistentChannelFactory)
  • public Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, CancellationToken cancellationToken)
  • public Task InvokeAsync(Action<IModel> channelAction, CancellationToken cancellationToken)
  • public Task<T> Invoke<T>(Func<IModel, T> channelAction)
  • public Task Invoke(Action<IModel> channelAction)
• public class DefaultPubSub : IPubSub
• public class DefaultRpc : IRpc
• public class DefaultSendReceive : ISendReceive
• public interface IClientCommandDispatcher : IDisposable
  • Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, CancellationToken cancellationToken = default)
  • Task InvokeAsync(Action<IModel> channelAction, CancellationToken cancellationToken = default)
  • Task<T> Invoke<T>(Func<IModel, T> channelAction)
  • Task Invoke(Action<IModel> channelAction)
• public interface IPublishConfirmationListener : IDisposable
• public interface IPublishConfirmationWaiter
• public interface IPublisher
  • Task Publish(IModel model, Action<IModel> publishAction)
• public interface IPublishExchangeDeclareStrategy
  • Task<IExchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken = default)
  • Task<IExchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken = default)
  • IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)
• public interface IPubSub
• public interface IReceiveRegistration
• public interface IResponderConfiguration
• public interface IRpc
  • 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)
  • Task<TResponse> Request<TRequest, TResponse>(TRequest request)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
• public interface ISendReceive
  • 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)
  • IDisposable Receive<T>(string queue, Action<T> onMessage)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • void Send<T>(string queue, T message)
• public class PersistentChannel : IPersistentChannel, IDisposable
  • public PersistentChannel(IPersistentConnection connection, ConnectionConfiguration configuration, IEventBus eventBus)
  • public IModel Channel { get; }
  • public PersistentChannel(IPersistentConnection connection, IEasyNetQLogger logger, IConnectionConfiguration configuration, IEventBus eventBus)
• public class PersistentChannelFactory : IPersistentChannelFactory
  • public PersistentChannelFactory(ConnectionConfiguration configuration, IEventBus eventBus)
  • public PersistentChannelFactory(IEasyNetQLogger logger, IConnectionConfiguration configuration, IEventBus eventBus)
• public class PublishConfirmationListener : IPublishConfirmationListener, IDisposable
• public class PublishConfirmationWaiter : IPublishConfirmationWaiter
• public abstract class PublisherBase : IPublisher
  • protected struct NullStruct
  • protected PublisherBase(IEventBus eventBus)
  • protected void ModelOnBasicReturn(IModel model, BasicReturnEventArgs args)
  • protected virtual void OnChannelClosed(IModel oldModel)
  • protected virtual void OnChannelOpened(IModel newModel)
  • public abstract Task Publish(IModel model, Action<IModel> publishAction)
  • protected void SetModel(IModel model)
• public class PublisherBasic : PublisherBase
  • public PublisherBasic(IEventBus eventBus)
• public class PublisherConfirms : PublisherBase
  • public PublisherConfirms(IConnectionConfiguration configuration, IEasyNetQLogger logger, IEventBus eventBus)
• public static class PublisherFactory
  • public static IPublisher CreatePublisher(IConnectionConfiguration configuration, IEasyNetQLogger logger, IEventBus eventBus)
• public class PublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
  • 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 PublishExchangeDeclareStrategy()
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)
• public static class PublishExchangeDeclareStrategyExtensions
• public class PublishInterruptedException : Exception
• public class PublishNackedException : Exception
  • protected PublishNackedException(SerializationInfo info, StreamingContext context)
• public static class PubSubExtensions
• public static class ReceiveRegistrationExtensions
• public class ResponderConfiguration : IResponderConfiguration
• public static class RpcExtensions
• public static class SendReceiveExtensions
• public class Rpc : IRpc
  • protected class ResponseAction
  • protected struct RpcKey
  • protected const string ExceptionMessageKey = "ExceptionMessage"
  • protected const string IsFaultedKey = "IsFaulted"
  • protected readonly IAdvancedBus advancedBus
  • protected readonly IConnectionConfiguration configuration
  • protected readonly IConventions conventions
  • protected readonly TimeSpan disablePeriodicSignaling
  • protected readonly IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy
  • public Rpc(IAdvancedBus advancedBus, IEventBus eventBus, IConventions conventions, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IConnectionConfiguration configuration)
  • protected Task ExecuteResponder<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, IMessage<TRequest> requestMessage)
  • protected void RegisterErrorHandling<TResponse>(Guid correlationId, Timer timer, TaskCompletionSource<TResponse> tcs)
  • public virtual Task<TResponse> Request<TRequest, TResponse>(TRequest request)
  • protected virtual void RequestPublish<TRequest>(TRequest request, string routingKey, string returnQueueName, Guid correlationId)
  • public virtual IDisposable Respond<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • protected virtual string SubscribeToResponse<TRequest, TResponse>()
• public class SendReceive : ISendReceive
  • public SendReceive(IAdvancedBus advancedBus, IConnectionConfiguration connectionConfiguration)
  • public IDisposable Receive<T>(string queue, Action<T> onMessage)
  • public IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • public IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • public void Send<T>(string queue, T message)

EasyNetQ.Scheduling

• public class DeadLetterExchangeAndMessageTtlScheduler : IScheduler
• public class DelayedExchangeScheduler : IScheduler
• public class ExternalScheduler : IScheduler
• public interface IScheduler
• public static class SchedulerExtensions
• public static class SchedulingExtensions

EasyNetQ.SystemMessages

• public class Error
  • public string Queue { get; set; }
• public class ScheduleMe
  • public string Exchange { get; set; }
  • public string ExchangeType { get; set; }
  • public MessageProperties MessageProperties { get; set; }
  • public string RoutingKey { get; set; }

EasyNetQ.Topology

• public class Binding : IBinding
  • public IDictionary<string, object> Headers { get; }
  • public Binding(IBindable bindable, IExchange exchange, string routingKey, IDictionary<string, object> headers)
  • public Binding(IBindable bindable, IExchange exchange, string routingKey)
• public class ExchangeType
  • public ExchangeType()
• public interface IBinding
  • IDictionary<string, object> Headers { get; }