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

<PackageReference Include="EasyNetQ" Version="7.0.0-alpha3" />

---

API Diff between 7.0.0-alpha3 and 7.0.0

254 Additions 188 Removals

EasyNetQ

• public class AdvancedBusEventHandlers
  • public EventHandler<UnblockedEventArgs> Unblocked { get; }
  • public AdvancedBusEventHandlers(EventHandler<ConnectedEventArgs> connected = null, EventHandler<DisconnectedEventArgs> disconnected = null, EventHandler<BlockedEventArgs> blocked = null, EventHandler<UnblockedEventArgs> unblocked = null, EventHandler<MessageReturnedEventArgs> messageReturned = null)
  • public EventHandler Unblocked { get; }
  • public AdvancedBusEventHandlers(EventHandler<ConnectedEventArgs> connected = null, EventHandler<DisconnectedEventArgs> disconnected = null, EventHandler<BlockedEventArgs> blocked = null, EventHandler unblocked = null, EventHandler<MessageReturnedEventArgs> messageReturned = null)
• public static class AdvancedBusExtensions
  • public static void ExchangeUnbindAsync(this IAdvancedBus bus, string destinationExchange, string sourceExchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken = default)
  • public static QueueStats GetQueueStats(this IAdvancedBus bus, string name, CancellationToken cancellationToken = default)
  • public static QueueStats GetQueueStats(this IAdvancedBus bus, Queue queue, CancellationToken cancellationToken = default)
  • public static void QueueDelete(this IAdvancedBus bus, string name, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • public static void QueuePurge(this IAdvancedBus bus, string name, CancellationToken cancellationToken = default)
  • public static void QueueUnbindAsync(this IAdvancedBus bus, string queue, string exchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken = default)
  • public static void QueueDelete(this IAdvancedBus bus, Queue queue, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • public static void QueuePurge(this IAdvancedBus bus, Queue queue, CancellationToken cancellationToken = default)
  • public static Task UnbindAsync(this IAdvancedBus bus, Binding<Queue> binding, CancellationToken cancellationToken = default)
  • public static Task UnbindAsync(this IAdvancedBus bus, Binding<Exchange> binding, CancellationToken cancellationToken = default)
• public class BlockedEventArgs : EventArgs
  • public PersistentConnectionType Type { get; }
  • public BlockedEventArgs(PersistentConnectionType type, string reason)
  • public BlockedEventArgs(string reason)
• public class ConnectedEventArgs : EventArgs
  • public PersistentConnectionType Type { get; }
  • public ConnectedEventArgs(PersistentConnectionType type, string hostname, int port)
  • public ConnectedEventArgs(string hostname, int port)
• public class ConnectionConfiguration
  • public ushort RequestedChannelMax { get; set; }
• public static class ConsumeConfigurationExtensions
  • public static IConsumeConfiguration ForQueue(this IConsumeConfiguration configuration, ref Queue queue, MessageHandler handler)
  • public static IConsumeConfiguration ForQueue(this IConsumeConfiguration configuration, ref Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, CancellationToken, Task> handler)
  • public static IConsumeConfiguration ForQueue(this IConsumeConfiguration configuration, ref Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, CancellationToken, Task> handler, Action<IPerQueueConsumeConfiguration> configure)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, ref Queue queue, IMessageHandler<T> handler)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, ref Queue queue, IMessageHandler<T> handler, Action<IPerQueueConsumeConfiguration> configure)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, ref Queue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, ref Queue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler, Action<IPerQueueConsumeConfiguration> configure)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, ref Queue queue, Action<IMessage<T>, MessageReceivedInfo> handler)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, ref Queue queue, Action<IMessage<T>, MessageReceivedInfo> handler, Action<IPerQueueConsumeConfiguration> configure)
  • public static IConsumeConfiguration ForQueue(this IConsumeConfiguration configuration, Queue queue, MessageHandler handler)
  • public static IConsumeConfiguration ForQueue(this IConsumeConfiguration configuration, Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, CancellationToken, Task> handler)
  • public static IConsumeConfiguration ForQueue(this IConsumeConfiguration configuration, Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, CancellationToken, Task> handler, Action<IPerQueueConsumeConfiguration> configure)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, Queue queue, IMessageHandler<T> handler)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, Queue queue, IMessageHandler<T> handler, Action<IPerQueueConsumeConfiguration> configure)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, Queue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, Queue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler, Action<IPerQueueConsumeConfiguration> configure)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, Queue queue, Action<IMessage<T>, MessageReceivedInfo> handler)
  • public static IConsumeConfiguration ForQueue<T>(this IConsumeConfiguration configuration, Queue queue, Action<IMessage<T>, MessageReceivedInfo> handler, Action<IPerQueueConsumeConfiguration> configure)
• public struct ConsumedMessage
  • public ConsumedMessage(MessageReceivedInfo receivedInfo, MessageProperties properties, ref ReadOnlyMemory body)
  • public ConsumedMessage(MessageReceivedInfo receivedInfo, MessageProperties properties, ReadOnlyMemory<byte> body)
• public class Conventions : IConventions
  • public QueueTypeConvention QueueTypeConvention { get; set; }
• public static class DeadLetterStrategy
• public class DefaultMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage DeserializeMessage(MessageProperties properties, ref ReadOnlyMemory body)
  • public IMessage DeserializeMessage(MessageProperties properties, ReadOnlyMemory<byte> body)
• public class DefaultRpc : IRpc, IDisposable
  • public DefaultRpc(ILogger<DefaultRpc> logger, ConnectionConfiguration configuration, IAdvancedBus advancedBus, IEventBus eventBus, IConventions conventions, IExchangeDeclareStrategy exchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, ITypeNameSerializer typeNameSerializer, ICorrelationIdGenerationStrategy correlationIdGenerationStrategy)
  • public DefaultRpc(ConnectionConfiguration configuration, IAdvancedBus advancedBus, IEventBus eventBus, IConventions conventions, IExchangeDeclareStrategy exchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, ITypeNameSerializer typeNameSerializer, ICorrelationIdGenerationStrategy correlationIdGenerationStrategy)
  • protected virtual Task RequestPublishAsync<TRequest>(TRequest request, string routingKey, string returnQueueName, string correlationId, TimeSpan expiration, byte? priority, bool mandatory, IDictionary<string, object> headers, CancellationToken cancellationToken)
  • protected virtual Task RequestPublishAsync<TRequest>(TRequest request, string routingKey, string returnQueueName, string correlationId, TimeSpan expiration, byte? priority, bool mandatory, CancellationToken cancellationToken)
• public class DisconnectedEventArgs : EventArgs
  • public PersistentConnectionType Type { get; }
  • public DisconnectedEventArgs(PersistentConnectionType type, string hostname, int port, string reason)
  • public DisconnectedEventArgs(string hostname, int port, string reason)
• public sealed class EventBus : IEventBus
  • public EventBus(ILogger<EventBus> logger)
  • public void Publish<TEvent>(ref TEvent event) where TEvent : struct
  • public IDisposable Subscribe<TEvent>(TEventHandler<TEvent> eventHandler) where TEvent : struct
  • public EventBus()
  • public void Publish<TEvent>(TEvent event)
  • public IDisposable Subscribe<TEvent>(Action<TEvent> handler)
• public interface IAdvancedBus : IDisposable
  • event EventHandler<UnblockedEventArgs> Unblocked
  • event EventHandler Unblocked
  • Task ConnectAsync(CancellationToken cancellationToken = default)
  • IPullingConsumer<PullResult> CreatePullingConsumer(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue, bool autoAck = true)
  • IPullingConsumer<PullResult<T>> CreatePullingConsumer<T>(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue, bool autoAck = true)
  • IPullingConsumer<PullResult> CreatePullingConsumer(Queue queue, bool autoAck = true)
  • IPullingConsumer<PullResult<T>> CreatePullingConsumer<T>(Queue queue, bool autoAck = true)
  • Task ExchangeUnbindAsync(string destinationExchange, string sourceExchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • Task<QueueStats> GetQueueStatsAsync(string name, CancellationToken cancellationToken = default)
  • Task<QueueStats> GetQueueStatsAsync(Queue queue, CancellationToken cancellationToken = default)
  • Task QueueDeleteAsync(string name, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • Task QueuePurgeAsync(string name, CancellationToken cancellationToken = default)
  • Task QueueUnbindAsync(string queue, string exchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • Task QueueDeleteAsync(Queue queue, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • Task QueuePurgeAsync(Queue queue, CancellationToken cancellationToken = default)
  • Task UnbindAsync(Binding<Queue> binding, CancellationToken cancellationToken = default)
  • Task UnbindAsync(Binding<Exchange> binding, CancellationToken cancellationToken = default)
• public interface IConsumeConfiguration
  • IConsumeConfiguration ForQueue(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue, MessageHandler handler, Action<IPerQueueConsumeConfiguration> configure)
  • IConsumeConfiguration ForQueue(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue, Action<IHandlerRegistration> register, Action<IPerQueueConsumeConfiguration> configure)
  • IConsumeConfiguration ForQueue(Queue queue, MessageHandler handler, Action<IPerQueueConsumeConfiguration> configure)
  • IConsumeConfiguration ForQueue(Queue queue, Action<IHandlerRegistration> register, Action<IPerQueueConsumeConfiguration> configure)
• public interface IConventions
  • QueueTypeConvention QueueTypeConvention { get; }
• public interface IEventBus
  • void Publish<TEvent>(TEvent& modreq(System.Runtime.InteropServices.InAttribute) event) where TEvent : struct
  • IDisposable Subscribe<TEvent>(TEventHandler<TEvent> eventHandler) where TEvent : struct
  • void Publish<TEvent>(TEvent event)
  • IDisposable Subscribe<TEvent>(Action<TEvent> handler)
• public interface IFuturePublishConfiguration
  • IFuturePublishConfiguration WithHeaders(IDictionary<string, object> headers)
• public interface IMessageSerializationStrategy
  • IMessage DeserializeMessage(MessageProperties properties, ReadOnlyMemory body)
  • IMessage DeserializeMessage(MessageProperties properties, ReadOnlyMemory<byte> body)
• public interface IPerQueueConsumeConfiguration
  • IPerQueueConsumeConfiguration WithAutoAck()
• public interface IPersistentConnection : IDisposable
  • bool IsConnected { get; }
  • IModel CreateModel()
• public interface IPublishConfiguration
  • IPublishConfiguration WithExpires(TimeSpan expires)
  • IPublishConfiguration WithHeaders(IDictionary<string, object> headers)
  • IPublishConfiguration WithExpires(int expires)
• public interface IPullingConsumerFactory
  • IPullingConsumer<PullResult> CreateConsumer(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue, PullingConsumerOptions& modreq(System.Runtime.InteropServices.InAttribute) options)
  • IPullingConsumer<PullResult<T>> CreateConsumer<T>(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue, PullingConsumerOptions& modreq(System.Runtime.InteropServices.InAttribute) options)
  • IPullingConsumer<PullResult> CreateConsumer(Queue queue, PullingConsumerOptions options)
  • IPullingConsumer<PullResult<T>> CreateConsumer<T>(Queue queue, PullingConsumerOptions options)
• public interface IReceiveConfiguration
  • IReceiveConfiguration WithQueueType(string queueType = "classic")
  • IReceiveConfiguration WithSingleActiveConsumer(bool singleActiveConsumer = true)
• public interface IRequestConfiguration
  • IRequestConfiguration WithHeaders(IDictionary<string, object> headers)
• public interface ISendConfiguration
  • ISendConfiguration WithHeaders(IDictionary<string, object> headers)
• public interface ISimpleConsumeConfiguration
  • ISimpleConsumeConfiguration WithAutoAck()
• public interface ISubscriptionConfiguration
  • ISubscriptionConfiguration WithAlternateExchange(string alternateExchange)
  • ISubscriptionConfiguration WithExchangeType(string exchangeType)
  • ISubscriptionConfiguration WithQueueType(string queueType = "classic")
  • ISubscriptionConfiguration WithSingleActiveConsumer(bool singleActiveConsumer = true)
• public class JsonSerializer : ISerializer
  • public JsonSerializer(object serializerSettings = null)
  • public JsonSerializer()
  • public JsonSerializer(JsonSerializerSettings serializerSettings)
• public class MessageProperties : ICloneable
  • public TimeSpan? Expiration { get; set; }
  • public string Expiration { get; set; }
  • public MessageProperties(IBasicProperties basicProperties)
  • public void CopyFrom(IBasicProperties basicProperties)
  • public void CopyTo(IBasicProperties basicProperties)
• public class MessageReturnedEventArgs : EventArgs
  • public MessageReturnedEventArgs(ref ReadOnlyMemory messageBody, MessageProperties messageProperties, ref MessageReturnedInfo messageReturnedInfo)
  • public MessageReturnedEventArgs(ReadOnlyMemory<byte> messageBody, MessageProperties messageProperties, MessageReturnedInfo messageReturnedInfo)
• public static class NonGenericPubSubExtensions
  • public static SubscriptionResult Subscribe(this IPubSub pubSub, string subscriptionId, Type messageType, Func<object, Type, CancellationToken, Task> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<SubscriptionResult> SubscribeAsync(this IPubSub pubSub, string subscriptionId, Type messageType, Func<object, Type, CancellationToken, Task> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
• public static class OverflowType
• public class PersistentConnection : IPersistentConnection, IDisposable
  • public bool IsConnected { get; }
  • public PersistentConnection(ConnectionConfiguration configuration, IConnectionFactory connectionFactory, IEventBus eventBus)
  • public IModel CreateModel()
  • public void Dispose()
• public struct ProducedMessage
  • public ProducedMessage(MessageProperties properties, ref ReadOnlyMemory body)
  • public ProducedMessage(MessageProperties properties, ReadOnlyMemory<byte> body)
• public class PullingConsumer : IPullingConsumer<PullResult>, IDisposable
  • public PullingConsumer(ref PullingConsumerOptions options, ref Queue queue, IPersistentChannel channel, IProduceConsumeInterceptor[] produceConsumeInterceptors)
  • public PullingConsumer(PullingConsumerOptions options, Queue queue, IPersistentChannel channel, IProduceConsumeInterceptor interceptor)
• public class PullingConsumerFactory : IPullingConsumerFactory
  • public PullingConsumerFactory(IConsumerConnection connection, IPersistentChannelFactory channelFactory, IEnumerable<IProduceConsumeInterceptor> produceConsumeInterceptors, IMessageSerializationStrategy messageSerializationStrategy)
  • public IPullingConsumer<PullResult> CreateConsumer(ref Queue queue, ref PullingConsumerOptions options)
  • public IPullingConsumer<PullResult<T>> CreateConsumer<T>(ref Queue queue, ref PullingConsumerOptions options)
  • public PullingConsumerFactory(IPersistentChannelFactory channelFactory, IProduceConsumeInterceptor produceConsumeInterceptor, IMessageSerializationStrategy messageSerializationStrategy)
  • public IPullingConsumer<PullResult> CreateConsumer(Queue queue, PullingConsumerOptions options)
  • public IPullingConsumer<PullResult<T>> CreateConsumer<T>(Queue queue, PullingConsumerOptions options)
• public struct PullResult : IPullResult, IDisposable
  • public static PullResult Available(ulong messagesCount, MessageReceivedInfo receivedInfo, MessageProperties properties, ref ReadOnlyMemory body, IDisposable disposable)
  • public static PullResult Available(ulong messagesCount, MessageReceivedInfo receivedInfo, MessageProperties properties, ReadOnlyMemory<byte> body, IDisposable disposable)
• public class QueueAttribute : Attribute
  • public string QueueType { get; set; }
• public static class QueueDeclareConfigurationExtensions
  • public static IQueueDeclareConfiguration WithDeadLetterStrategy(this IQueueDeclareConfiguration configuration, string deadLetterStrategy = "at-most-once")
  • public static IQueueDeclareConfiguration WithOverflowType(this IQueueDeclareConfiguration configuration, string overflowType = "drop-head")
  • public static IQueueDeclareConfiguration WithQueueMasterLocator(this IQueueDeclareConfiguration configuration, string queueMasterLocator = "min-masters")
  • public static IQueueDeclareConfiguration WithSingleActiveConsumer(this IQueueDeclareConfiguration configuration, bool singleActiveConsumer = true)
  • public static IQueueDeclareConfiguration WithSingleActiveConsumer(this IQueueDeclareConfiguration configuration)
• public static class QueueMasterLocator
• public sealed delegate QueueTypeConvention : MulticastDelegate
• public class RabbitAdvancedBus : IAdvancedBus, IDisposable
  • public event EventHandler<UnblockedEventArgs> Unblocked
  • public RabbitAdvancedBus(ILogger<RabbitAdvancedBus> logger, IProducerConnection producerConnection, IConsumerConnection consumerConnection, IConsumerFactory consumerFactory, IPersistentChannelDispatcher persistentChannelDispatcher, IPublishConfirmationListener confirmationListener, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, IServiceResolver container, ConnectionConfiguration configuration, IEnumerable<IProduceConsumeInterceptor> produceConsumeInterceptors, IMessageSerializationStrategy messageSerializationStrategy, IConventions conventions, IPullingConsumerFactory pullingConsumerFactory, AdvancedBusEventHandlers advancedBusEventHandlers, IConsumeScopeProvider consumeScopeProvider)
  • public event EventHandler Unblocked
  • public RabbitAdvancedBus(IPersistentConnection connection, IConsumerFactory consumerFactory, IClientCommandDispatcher clientCommandDispatcher, IPublishConfirmationListener confirmationListener, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, IServiceResolver container, ConnectionConfiguration configuration, IProduceConsumeInterceptor produceConsumeInterceptor, IMessageSerializationStrategy messageSerializationStrategy, IConventions conventions, IPullingConsumerFactory pullingConsumerFactory, AdvancedBusEventHandlers advancedBusEventHandlers)
  • public Task ConnectAsync(CancellationToken cancellationToken = default)
  • public IPullingConsumer<PullResult> CreatePullingConsumer(ref Queue queue, bool autoAck = true)
  • public IPullingConsumer<PullResult<T>> CreatePullingConsumer<T>(ref Queue queue, bool autoAck = true)
  • public IPullingConsumer<PullResult> CreatePullingConsumer(Queue queue, bool autoAck = true)
  • public IPullingConsumer<PullResult<T>> CreatePullingConsumer<T>(Queue queue, bool autoAck = true)
  • public virtual Task ExchangeUnbindAsync(string destinationExchange, string sourceExchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public Task<QueueStats> GetQueueStatsAsync(string name, CancellationToken cancellationToken)
  • public Task<QueueStats> GetQueueStatsAsync(Queue queue, CancellationToken cancellationToken)
  • public virtual Task QueueDeleteAsync(string name, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • public virtual Task QueuePurgeAsync(string name, CancellationToken cancellationToken)
  • public virtual Task QueueUnbindAsync(string queue, string exchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public virtual Task QueueDeleteAsync(Queue queue, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • public virtual Task QueuePurgeAsync(Queue queue, CancellationToken cancellationToken)
  • public virtual Task UnbindAsync(Binding<Queue> binding, CancellationToken cancellationToken)
  • public virtual Task UnbindAsync(Binding<Exchange> binding, CancellationToken cancellationToken)
• public static class ServiceRegisterExtensions
  • public static IServiceRegister EnableAlwaysAckConsumerErrorStrategy(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableAlwaysNackWithoutRequeueConsumerErrorStrategy(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableAlwaysNackWithRequeueConsumerErrorStrategy(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableConsoleLogger(this IServiceRegister serviceRegister)
  • public static IInterceptorRegistrator EnableGZipCompression(this IInterceptorRegistrator registrator)
  • public static IServiceRegister EnableInterception(this IServiceRegister serviceRegister, Action<IInterceptorRegistrator> configure)
  • public static void RegisterDefaultServices(this IServiceRegister serviceRegister, Func<IServiceResolver, ConnectionConfiguration> connectionConfigurationFactory)
  • public static IInterceptorRegistrator EnableTripleDESEncryption(this IInterceptorRegistrator registrator, byte[] key, byte[] iv)
  • public static void RegisterDefaultServices(this IServiceRegister serviceRegister)
• public struct SubscriptionResult : IDisposable
  • public SubscriptionResult(ref Exchange exchange, ref Queue queue, IDisposable consumerCancellation)
  • public SubscriptionResult(Exchange exchange, Queue queue, IDisposable consumerCancellation)
• public sealed delegate TEventHandler<TEvent> : MulticastDelegate where TEvent : struct
• public class UnblockedEventArgs : EventArgs

EasyNetQ.AutoSubscribe

• public class AutoSubscriber
  • public static string DefaultTopicName { get; set; }

EasyNetQ.ChannelDispatcher

• public interface IPersistentChannelDispatcher : IDisposable
• public sealed class MultiPersistentChannelDispatcher : IPersistentChannelDispatcher, IDisposable
• public class PersistentChannelDispatchOptions
• public sealed class SinglePersistentChannelDispatcher : IPersistentChannelDispatcher, IDisposable

EasyNetQ.Consumer

• public class Consumer : IConsumer, IDisposable
  • public Consumer(ILogger<Consumer> logger, ConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public Consumer(ConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
• public sealed class ConsumerConnection : PersistentConnection, IConsumerConnection, IPersistentConnection, IDisposable
• public struct ConsumerExecutionContext
  • public ConsumerExecutionContext(MessageHandler handler, MessageReceivedInfo receivedInfo, MessageProperties properties, ref ReadOnlyMemory body)
  • public ConsumerExecutionContext(MessageHandler handler, MessageReceivedInfo receivedInfo, MessageProperties properties, ReadOnlyMemory<byte> body)
• public class ConsumerFactory : IConsumerFactory, IDisposable
  • public ConsumerFactory(ILogger<Consumer> logger, IEventBus eventBus, IInternalConsumerFactory internalConsumerFactory)
  • public ConsumerFactory(IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
• public class DefaultConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable
  • public DefaultConsumerErrorStrategy(ILogger<DefaultConsumerErrorStrategy> logger, IConsumerConnection connection, ISerializer serializer, IConventions conventions, ITypeNameSerializer typeNameSerializer, IErrorMessageSerializer errorMessageSerializer, ConnectionConfiguration configuration)
  • public DefaultConsumerErrorStrategy(IPersistentConnection connection, ISerializer serializer, IConventions conventions, ITypeNameSerializer typeNameSerializer, IErrorMessageSerializer errorMessageSerializer, ConnectionConfiguration configuration)
  • public virtual Task<AckStrategy> HandleConsumerCancelledAsync(ConsumerExecutionContext context, CancellationToken cancellationToken)
  • public virtual Task<AckStrategy> HandleConsumerErrorAsync(ConsumerExecutionContext context, Exception exception, CancellationToken cancellationToken)
  • public virtual AckStrategy HandleConsumerCancelled(ConsumerExecutionContext context)
  • public virtual AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception)
• public class HandlerCollectionFactory : IHandlerCollectionFactory
  • public IHandlerCollection CreateHandlerCollection(ref Queue queue)
  • public IHandlerCollection CreateHandlerCollection(Queue queue)
• public class HandlerCollectionPerQueueFactory : IHandlerCollectionFactory
  • public IHandlerCollection CreateHandlerCollection(ref Queue queue)
  • public IHandlerCollection CreateHandlerCollection(Queue queue)
• public class HandlerRunner : IHandlerRunner, IDisposable
  • public HandlerRunner(ILogger<IHandlerRunner> logger, IConsumerErrorStrategy consumerErrorStrategy)
  • public HandlerRunner(IConsumerErrorStrategy consumerErrorStrategy)
• public interface IConsumerConnection : IPersistentConnection, IDisposable
• public interface IConsumerErrorStrategy : IDisposable
  • Task<AckStrategy> HandleConsumerCancelledAsync(ConsumerExecutionContext context, CancellationToken cancellationToken = default)
  • Task<AckStrategy> HandleConsumerErrorAsync(ConsumerExecutionContext context, Exception exception, CancellationToken cancellationToken = default)
  • AckStrategy HandleConsumerCancelled(ConsumerExecutionContext context)
  • AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception)
• public interface IHandlerCollectionFactory
  • IHandlerCollection CreateHandlerCollection(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue)
  • IHandlerCollection CreateHandlerCollection(Queue queue)
• public class InternalConsumer : IInternalConsumer, IDisposable
  • public InternalConsumer(ILogger<InternalConsumer> logger, ConsumerConfiguration configuration, IConsumerConnection connection, IHandlerRunner handlerRunner, IEventBus eventBus)
  • public InternalConsumer(ConsumerConfiguration configuration, IPersistentConnection connection, IHandlerRunner handlerRunner, IEventBus eventBus)
• public class InternalConsumerCancelledEventArgs : EventArgs
  • public InternalConsumerCancelledEventArgs(ref Queue cancelled, IReadOnlyCollection<Queue> active)
  • public InternalConsumerCancelledEventArgs(Queue cancelled, IReadOnlyCollection<Queue> active)
• public class InternalConsumerFactory : IInternalConsumerFactory, IDisposable
  • public InternalConsumerFactory(ILogger<InternalConsumer> logger, IConsumerConnection connection, IHandlerRunner handlerRunner, IEventBus eventBus)
  • public InternalConsumerFactory(IPersistentConnection connection, IHandlerRunner handlerRunner, IEventBus eventBus)
• public struct InternalConsumerStatus
  • public IReadOnlyCollection<Queue> Active { get; }
  • public IReadOnlyCollection<Queue> Started { get; }
  • public InternalConsumerStatus(IReadOnlyCollection<Queue> started, IReadOnlyCollection<Queue> active, IReadOnlyCollection<Queue> failed)
  • public IReadOnlyCollection<Queue> Succeed { get; }
  • public InternalConsumerStatus(IReadOnlyCollection<Queue> succeed, IReadOnlyCollection<Queue> failed)
• public class PerQueueConsumerConfiguration
  • public bool AutoAck { get; }
  • public PerQueueConsumerConfiguration(bool autoAck, string consumerTag, bool isExclusive, IDictionary<string, object> arguments, MessageHandler handler)
  • public PerQueueConsumerConfiguration(string consumerTag, bool isExclusive, IDictionary<string, object> arguments, MessageHandler handler)
• public class SimpleConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable

EasyNetQ.DI

• public class DefaultConsumeScopeProvider : IConsumeScopeProvider
• public interface IConsumeScopeProvider
• public class DefaultServiceContainer : IServiceRegister, IDisposable
  • public DefaultServiceContainer()
  • public void Dispose()
  • 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 interface IServiceRegister
  • IServiceRegister Register(Type serviceType, Type implementationType, Lifetime lifetime = 1)
  • IServiceRegister Register(Type serviceType, Func<IServiceResolver, object> implementationFactory, Lifetime lifetime = 1)
  • IServiceRegister Register(Type serviceType, object implementationInstance)
  • IServiceRegister TryRegister(Type serviceType, Type implementationType, Lifetime lifetime = 1)
  • IServiceRegister TryRegister(Type serviceType, Func<IServiceResolver, object> implementationFactory, Lifetime lifetime = 1)
  • IServiceRegister TryRegister(Type serviceType, object implementationInstance)
  • 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 class NoopConsumeScopeProvider : IConsumeScopeProvider
• public static class ServiceRegisterExtensions

EasyNetQ.Events

• public class AckEvent
  • public AckEvent(MessageReceivedInfo info, MessageProperties properties, ref ReadOnlyMemory body, AckResult ackResult)
  • public AckEvent(MessageReceivedInfo info, MessageProperties properties, ReadOnlyMemory<byte> body, AckResult ackResult)
• public class ConnectionBlockedEvent
  • public PersistentConnectionType Type { get; }
  • public ConnectionBlockedEvent(PersistentConnectionType type, string reason)
  • public ConnectionBlockedEvent(string reason)
• public class ConnectionCreatedEvent
  • public PersistentConnectionType Type { get; }
  • public ConnectionCreatedEvent(PersistentConnectionType type, AmqpTcpEndpoint endpoint)
  • public ConnectionCreatedEvent(AmqpTcpEndpoint endpoint)
• public class ConnectionDisconnectedEvent
  • public PersistentConnectionType Type { get; }
  • public ConnectionDisconnectedEvent(PersistentConnectionType type, AmqpTcpEndpoint endpoint, string reason)
  • public ConnectionDisconnectedEvent(AmqpTcpEndpoint endpoint, string reason)
• public class ConnectionRecoveredEvent
  • public PersistentConnectionType Type { get; }
  • public ConnectionRecoveredEvent(PersistentConnectionType type, AmqpTcpEndpoint endpoint)
  • public ConnectionRecoveredEvent(AmqpTcpEndpoint endpoint)
• public class ConnectionUnblockedEvent
  • public PersistentConnectionType Type { get; }
  • public ConnectionUnblockedEvent(PersistentConnectionType type)
  • public ConnectionUnblockedEvent()
• public class DeliveredMessageEvent
  • public DeliveredMessageEvent(MessageReceivedInfo info, MessageProperties properties, ref ReadOnlyMemory body)
  • public DeliveredMessageEvent(MessageReceivedInfo info, MessageProperties properties, ReadOnlyMemory<byte> body)
• public class MessageConfirmationEvent
  • public MessageConfirmationEvent()
• public class PublishedMessageEvent
  • public Exchange Exchange { get; }
  • public string ExchangeName { get; }
  • public PublishedMessageEvent(ref Exchange exchange, string routingKey, MessageProperties properties, ref ReadOnlyMemory body)
  • public PublishedMessageEvent(string exchangeName, string routingKey, MessageProperties properties, ReadOnlyMemory<byte> body)
• public class ReturnedMessageEvent
  • public ReturnedMessageEvent(IModel channel, ref ReadOnlyMemory body, MessageProperties properties, ref MessageReturnedInfo info)
  • public ReturnedMessageEvent(IModel channel, ReadOnlyMemory<byte> body, MessageProperties properties, MessageReturnedInfo info)
• public class StartConsumingFailedEvent
  • public StartConsumingFailedEvent(IConsumer consumer, ref Queue queue)
  • public StartConsumingFailedEvent(IConsumer consumer, Queue queue)
• public class StartConsumingSucceededEvent
  • public StartConsumingSucceededEvent(IConsumer consumer, ref Queue queue)
  • public StartConsumingSucceededEvent(IConsumer consumer, Queue queue)

EasyNetQ.Interception

• public class CompositeProduceConsumerInterceptor : IProduceConsumeInterceptor
• public class CompositeInterceptor : IProduceConsumeInterceptor
  • public CompositeInterceptor()
  • public void Add(IProduceConsumeInterceptor interceptor)
  • public ConsumedMessage OnConsume(ref ConsumedMessage message)
  • public ProducedMessage OnProduce(ref ProducedMessage message)
• public class DefaultInterceptor : IProduceConsumeInterceptor
  • public DefaultInterceptor()
  • public ConsumedMessage OnConsume(ref ConsumedMessage message)
  • public ProducedMessage OnProduce(ref ProducedMessage message)
• public interface IInterceptorRegistrator
  • void Add(IProduceConsumeInterceptor interceptor)
• public class InterceptorRegistrator : IInterceptorRegistrator
  • public InterceptorRegistrator(IServiceRegister serviceRegister)
  • public void Add(IProduceConsumeInterceptor interceptor)
  • public IServiceRegister Register()

EasyNetQ.Internals

• public sealed class AsyncLock : IDisposable
  • public struct Releaser : IDisposable
  • public Releaser Acquire(CancellationToken cancellationToken = default)
  • public Task<Releaser> AcquireAsync(CancellationToken cancellationToken = default)
  • public IDisposable Acquire(CancellationToken cancellationToken = default)
  • public Task<IDisposable> AcquireAsync(CancellationToken cancellationToken = default)
• public static class CancellationTokenExtensions
  • public struct ValueCancellationTokenSource : IDisposable
  • public static ValueCancellationTokenSource WithTimeout(this CancellationToken cancellationToken, TimeSpan timeout)
  • public static CancellationTokenSource WithTimeout(this CancellationToken cancellationToken, TimeSpan timeout)
• public static class DictionaryExtensions
  • public static void UnionWith(this IDictionary<string, object> source, IDictionary<string, object> addendum)
• public class NoResult : IEquatable<NoResult>
• public sealed class ReadOnlyMemoryStream : Stream
  • public ReadOnlyMemoryStream(ref ReadOnlyMemory content)
  • public ReadOnlyMemoryStream(ReadOnlyMemory<byte> content)
• public static class Timers
  • public static IDisposable Start(Action callback, TimeSpan dueTime, TimeSpan period, ILogger logger)
  • public static IDisposable Start(Action callback, TimeSpan dueTime, TimeSpan period)

EasyNetQ.Logging

• public class ConsoleLogger : ILogger
• public class ConsoleLogger<TCategoryName> : ConsoleLogger, ILogger<TCategoryName>, ILogger
• public interface ILogger
• public interface ILogger<TCategoryName> : ILogger
• public static class LoggerExtensions
• 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, Exception exception, string message, object[] args)
  • public static void DebugException(this ILog logger, string message, Exception exception)
  • public static void DebugException(this ILog logger, string message, Exception exception, object[] args)
  • public static void DebugFormat(this ILog logger, string message, object[] args)
  • 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[] args)
  • 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[] args)
  • 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, Exception exception, string message, object[] args)
  • public static void InfoException(this ILog logger, string message, Exception exception, object[] args)
  • public static void InfoFormat(this ILog logger, string message, object[] args)
  • 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, Exception exception, string message, object[] args)
  • public static void TraceException(this ILog logger, string message, Exception exception, object[] args)
  • public static void TraceFormat(this ILog logger, string message, object[] args)
  • 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[] args)
  • 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 class NoopLogger : ILogger
• public class NoopLogger<TCategoryName> : ILogger<TCategoryName>, ILogger
• 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()
  • protected static Type FindType(string typeName, string assemblyName)
  • protected static Type FindType(string typeName, IReadOnlyList<string> assemblyNames)
  • 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 VersionedMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage DeserializeMessage(MessageProperties properties, ref ReadOnlyMemory body)
  • public IMessage DeserializeMessage(MessageProperties properties, ReadOnlyMemory<byte> body)

EasyNetQ.Persistent

• public struct ActionBasedPersistentChannelAction : IPersistentChannelAction<NoResult>
• public struct FuncBasedPersistentChannelAction<TResult> : IPersistentChannelAction<TResult>
• public interface IPersistentChannel : IDisposable
• public interface IPersistentChannelAction<TResult>
• public interface IPersistentChannelFactory
• public interface IPersistentConnection : IDisposable
• public class PersistentChannel : IPersistentChannel, IDisposable
• public class PersistentChannelFactory : IPersistentChannelFactory
• public struct PersistentChannelOptions
• public class PersistentConnection : IPersistentConnection, IDisposable
• public enum PersistentConnectionType

EasyNetQ.Producer

• public struct ChannelDispatchOptions
  • public static readonly ChannelDispatchOptions Default
  • public static readonly ChannelDispatchOptions Publish
  • public static readonly ChannelDispatchOptions PublishWithConfirms
  • public string Name { get; }
  • public bool PublisherConfirms { get; }
  • public ChannelDispatchOptions(string name, bool publisherConfirms = false)
• public interface IClientCommandDispatcher : IDisposable
  • Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, ChannelDispatchOptions channelOptions, CancellationToken cancellationToken = default)
• public interface IProducerConnection : IPersistentConnection, IDisposable
• public interface IPersistentChannel : IDisposable
  • Task<T> InvokeChannelActionAsync<T>(Func<IModel, T> channelAction, CancellationToken cancellationToken = default)
• public interface IPersistentChannelFactory
  • IPersistentChannel CreatePersistentChannel(PersistentChannelOptions options)
• public class ProducerConnection : PersistentConnection, IProducerConnection, IPersistentConnection, IDisposable
• public sealed class MultiChannelClientCommandDispatcher : IClientCommandDispatcher, IDisposable
  • public MultiChannelClientCommandDispatcher(int channelsCount, IPersistentChannelFactory channelFactory)
  • public void Dispose()
  • public Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, ChannelDispatchOptions options, CancellationToken cancellationToken)
• public class PersistentChannel : IPersistentChannel, IDisposable
  • public PersistentChannel(PersistentChannelOptions options, IPersistentConnection connection, IEventBus eventBus)
  • public void Dispose()
  • public Task<T> InvokeChannelActionAsync<T>(Func<IModel, T> channelAction, CancellationToken cancellationToken)
• public class PersistentChannelFactory : IPersistentChannelFactory
  • public PersistentChannelFactory(IPersistentConnection connection, IEventBus eventBus)
  • public IPersistentChannel CreatePersistentChannel(PersistentChannelOptions options)
• public struct PersistentChannelOptions
  • public bool PublisherConfirms { get; }
  • public PersistentChannelOptions(bool publisherConfirms)
• public sealed class SingleChannelClientCommandDispatcher : IClientCommandDispatcher, IDisposable
  • public SingleChannelClientCommandDispatcher(IPersistentChannelFactory channelFactory)
  • public void Dispose()
  • public Task<T> InvokeAsync<T>(Func<IModel, T> channelAction, ChannelDispatchOptions channelOptions, CancellationToken cancellationToken)

EasyNetQ.Topology

• public struct Binding<TBindable> where TBindable : struct, IBindable
  • public Binding(ref Exchange source, ref TBindable destination, string routingKey, IDictionary<string, object> arguments = null)
  • public Binding(Exchange source, TBindable destination, string routingKey, IDictionary<string, object> arguments = null)