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

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

---

API Diff between 7.8.0 and 0.47.10.383

1018 Additions 414 Removals

EasyNetQ

• public class AdvancedBusEventHandlers
  • public static readonly AdvancedBusEventHandlers Default
  • public EventHandler<ConnectionBlockedEventArgs> Blocked { get; }
  • public EventHandler Connected { get; }
  • public EventHandler Disconnected { get; }
  • public EventHandler<BlockedEventArgs> Blocked { get; }
  • public EventHandler<ConnectedEventArgs> Connected { get; }
  • public EventHandler<DisconnectedEventArgs> Disconnected { get; }
  • public EventHandler Unblocked { get; }
  • public AdvancedBusEventHandlers(EventHandler connected = null, EventHandler disconnected = null, EventHandler<ConnectionBlockedEventArgs> blocked = null, EventHandler unblocked = null, EventHandler<MessageReturnedEventArgs> messageReturned = null)
  • 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 static class AdvancedBusExtensions
  • public static Binding<Exchange> Bind(this IAdvancedBus bus, Exchange source, Exchange destination, string routingKey, CancellationToken cancellationToken = default)
  • public static Binding<Exchange> Bind(this IAdvancedBus bus, Exchange source, Exchange destination, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken = default)
  • public static Binding<Queue> Bind(this IAdvancedBus bus, Exchange exchange, Queue queue, string routingKey, CancellationToken cancellationToken = default)
  • public static Binding<Queue> Bind(this IAdvancedBus bus, Exchange exchange, Queue queue, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken = default)
  • public static Task<Binding<Queue>> BindAsync(this IAdvancedBus bus, Exchange source, Queue queue, string routingKey, CancellationToken cancellationToken = default)
  • public static Task<Binding<Exchange>> BindAsync(this IAdvancedBus bus, Exchange source, Exchange destination, string routingKey, CancellationToken cancellationToken = default)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, Queue queue, Action<IMessage<T>, MessageReceivedInfo> handler)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, Queue queue, Action<IMessage<T>, MessageReceivedInfo> handler, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, Queue queue, Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, Queue queue, Func<IMessage<T>, MessageReceivedInfo, Task> handler, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, Queue queue, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume<T>(this IAdvancedBus bus, Queue queue, IMessageHandler<T> handler, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Action<IHandlerRegistration> addHandlers)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Action<IHandlerRegistration> addHandlers, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Action<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo> handler)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Action<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo> handler, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, Task> handler)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, Task<AckStrategy>> handler)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, Task> handler, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, Task<AckStrategy>> handler, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, Func<ReadOnlyMemory<byte>, MessageProperties, MessageReceivedInfo, CancellationToken, Task> handler, Action<ISimpleConsumeConfiguration> configure)
  • public static IDisposable Consume(this IAdvancedBus bus, Queue queue, MessageHandler handler, Action<ISimpleConsumeConfiguration> configure)
  • public static Exchange ExchangeDeclare(this IAdvancedBus bus, string name, string type, bool durable = true, bool autoDelete = false, CancellationToken cancellationToken = default)
  • public static Exchange ExchangeDeclare(this IAdvancedBus bus, string name, Action<IExchangeDeclareConfiguration> configure, CancellationToken cancellationToken = default)
  • public static Task<Exchange> ExchangeDeclareAsync(this IAdvancedBus bus, string name, string type, bool durable = true, bool autoDelete = false, CancellationToken cancellationToken = default)
  • public static void ExchangeDeclarePassive(this IAdvancedBus bus, string name, CancellationToken cancellationToken = default)
  • public static void ExchangeDelete(this IAdvancedBus bus, Exchange exchange, bool ifUnused = false, CancellationToken cancellationToken = default)
  • 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 void Publish(this IAdvancedBus bus, Exchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, ReadOnlyMemory<byte> body, CancellationToken cancellationToken = default)
  • public static void Publish<T>(this IAdvancedBus bus, Exchange exchange, string routingKey, bool mandatory, IMessage<T> message, CancellationToken cancellationToken = default)
  • public static Queue QueueDeclare(this IAdvancedBus bus, CancellationToken cancellationToken = default)
  • public static Queue QueueDeclare(this IAdvancedBus bus, string name, Action<IQueueDeclareConfiguration> configure, CancellationToken cancellationToken = default)
  • public static Queue QueueDeclare(this IAdvancedBus bus, string name, bool durable, bool exclusive, bool autoDelete, CancellationToken cancellationToken = default)
  • public static Queue QueueDeclare(this IAdvancedBus bus, string name, CancellationToken cancellationToken = default)
  • public static Task<Queue> QueueDeclareAsync(this IAdvancedBus bus, string name, CancellationToken cancellationToken = default)
  • public static Task<Queue> QueueDeclareAsync(this IAdvancedBus bus, string name, bool durable, bool exclusive, bool autoDelete, CancellationToken cancellationToken = default)
  • public static void QueueDeclarePassive(this IAdvancedBus bus, string name, 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 Unbind(this IAdvancedBus bus, Binding<Queue> binding, CancellationToken cancellationToken = default)
  • public static void Unbind(this IAdvancedBus bus, Binding<Exchange> binding, 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 BasicGetResult : IBasicGetResult
• public class BasicGetResult<T> : IBasicGetResult<T>
• public sealed delegate CancelSubscription : MulticastDelegate
• public class ComponentRegistration
• public class BlockedEventArgs : EventArgs
  • public string Reason { get; }
  • public PersistentConnectionType Type { get; }
  • public BlockedEventArgs(PersistentConnectionType type, string reason)
• public class ConnectedEventArgs : EventArgs
  • public string Hostname { get; }
  • public int Port { get; }
  • public PersistentConnectionType Type { get; }
  • public ConnectedEventArgs(PersistentConnectionType type, string hostname, int port)
• public class ConnectionConfiguration
  • public Uri AMQPConnectionString { get; set; }
  • public bool CancelOnHaFailover { get; set; }
  • public const int DefaultAmqpsPort = 5671
  • public const int DefaultPort = 5672
  • public IList<IAuthMechanismFactory> AuthMechanisms { get; set; }
  • public IEnumerable<HostConfiguration> Hosts { get; set; }
  • public TimeSpan ConnectIntervalAttempt { get; set; }
  • public int? ConsumerDispatcherConcurrency { get; set; }
  • public IList<HostConfiguration> Hosts { get; set; }
  • public bool MandatoryPublish { get; set; }
  • public string Name { get; set; }
  • public ushort RequestedHeartbeat { get; set; }
  • public ushort RequestedChannelMax { get; set; }
  • public TimeSpan RequestedHeartbeat { get; set; }
  • public ushort Timeout { get; set; }
  • public TimeSpan Timeout { get; set; }
  • public void Validate()
• public class ConnectionFactoryInfo
• public class ConnectionFactoryWrapper : IConnectionFactory
• 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 struct ConsumedMessage
  • public ReadOnlyMemory<byte> Body { get; }
  • public MessageProperties Properties { get; }
  • public MessageReceivedInfo ReceivedInfo { get; }
  • public ConsumedMessage(MessageReceivedInfo receivedInfo, MessageProperties properties, ref ReadOnlyMemory body)
• public class Conventions : IConventions
  • public RpcExchangeNameConvention RpcExchangeNamingConvention { get; set; }
  • public QueueTypeConvention QueueTypeConvention { get; set; }
  • public RpcExchangeNameConvention RpcRequestExchangeNamingConvention { get; set; }
  • public RpcExchangeNameConvention RpcResponseExchangeNamingConvention { get; set; }
• public class DeadLetterExchangeAndMessageTtlScheduler : IScheduler
  • public DeadLetterExchangeAndMessageTtlScheduler(ConnectionConfiguration configuration, IAdvancedBus advancedBus, IConventions conventions, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, IExchangeDeclareStrategy exchangeDeclareStrategy)
  • public Task FuturePublishAsync<T>(T message, TimeSpan delay, Action<IFuturePublishConfiguration> configure, CancellationToken cancellationToken = default)
• public static class DeadLetterStrategy
  • public const string AtLeastOnce = "at-least-once"
  • public const string AtMostOnce = "at-most-once"
• public class DefaultMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage<T> DeserializeMessage<T>(MessageProperties properties, byte[] body)
  • public IMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • public IMessage DeserializeMessage(MessageProperties properties, ref ReadOnlyMemory body)
• public class DefaultServiceProvider : IContainer, IServiceProvider, IServiceRegister
• public class DefaultPubSub : IPubSub
  • public DefaultPubSub(ConnectionConfiguration configuration, IConventions conventions, IExchangeDeclareStrategy exchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, IAdvancedBus advancedBus)
  • public virtual Task PublishAsync<T>(T message, Action<IPublishConfiguration> configure, CancellationToken cancellationToken)
  • public virtual AwaitableDisposable<SubscriptionResult> SubscribeAsync<T>(string subscriptionId, Func<T, CancellationToken, Task> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken)
• public class DefaultRpc : IRpc, IDisposable
  • protected struct ResponseAction
  • protected struct ResponseSubscription
  • protected struct RpcKey : IEquatable<RpcKey>
  • protected const string ExceptionMessageKey = "ExceptionMessage"
  • protected const string IsFaultedKey = "IsFaulted"
  • protected readonly IAdvancedBus advancedBus
  • protected readonly IConventions conventions
  • protected readonly IExchangeDeclareStrategy exchangeDeclareStrategy
  • protected readonly IMessageDeliveryModeStrategy messageDeliveryModeStrategy
  • public DefaultRpc(ILogger<DefaultRpc> logger, ConnectionConfiguration configuration, IAdvancedBus advancedBus, IEventBus eventBus, IConventions conventions, IExchangeDeclareStrategy exchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, ITypeNameSerializer typeNameSerializer, ICorrelationIdGenerationStrategy correlationIdGenerationStrategy)
  • protected void DeRegisterResponseActions(string correlationId)
  • public void Dispose()
  • protected void RegisterResponseActions<TResponse>(string correlationId, TaskCompletionSource<TResponse> tcs)
  • public virtual Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure, CancellationToken cancellationToken = default)
  • 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)
  • public virtual AwaitableDisposable<IDisposable> RespondAsync<TRequest, TResponse>(Func<TRequest, CancellationToken, Task<TResponse>> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken = default)
  • protected virtual Task<string> SubscribeToResponseAsync<TRequest, TResponse>(CancellationToken cancellationToken)
• public class DefaultSendReceive : ISendReceive
  • public DefaultSendReceive(ConnectionConfiguration configuration, IConventions conventions, IAdvancedBus advancedBus, IMessageDeliveryModeStrategy messageDeliveryModeStrategy)
  • public AwaitableDisposable<IDisposable> ReceiveAsync(string queue, Action<IReceiveRegistration> addHandlers, Action<IReceiveConfiguration> configure, CancellationToken cancellationToken)
  • public Task SendAsync<T>(string queue, T message, Action<ISendConfiguration> configure, CancellationToken cancellationToken)
• public class DefaultTypeNameSerializer : ITypeNameSerializer
  • public DefaultTypeNameSerializer()
  • public Type DeSerialize(string typeName)
  • public string Serialize(Type type)
• public static class DelayedExchangeExtensions
  • public static IExchangeDeclareConfiguration AsDelayedExchange(this IExchangeDeclareConfiguration configuration, string exchangeType = "fanout")
  • public static IMessage<T> WithDelay<T>(this IMessage<T> message, TimeSpan delay)
• public class DelayedExchangeScheduler : IScheduler
  • public DelayedExchangeScheduler(IAdvancedBus advancedBus, IConventions conventions, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, ISerializer serializer, ITypeNameSerializer typeNameSerializer)
  • public void CancelFuturePublish(string cancellationKey)
  • public Task CancelFuturePublishAsync(string cancellationKey)
  • public void FuturePublish<T>(DateTime futurePublishDate, T message)
  • public void FuturePublish<T>(DateTime futurePublishDate, string cancellationKey, T message)
  • public void FuturePublish<T>(TimeSpan messageDelay, T message)
  • public Task FuturePublishAsync<T>(DateTime futurePublishDate, T message)
  • public Task FuturePublishAsync<T>(DateTime futurePublishDate, string cancellationKey, T message)
  • public Task FuturePublishAsync<T>(TimeSpan messageDelay, T message)
  • public DelayedExchangeScheduler(ConnectionConfiguration configuration, IAdvancedBus advancedBus, IConventions conventions, IMessageDeliveryModeStrategy messageDeliveryModeStrategy)
  • public Task FuturePublishAsync<T>(T message, TimeSpan delay, Action<IFuturePublishConfiguration> configure, CancellationToken cancellationToken = default)
• public class DisconnectedEventArgs : EventArgs
  • public string Hostname { get; }
  • public int Port { get; }
  • public string Reason { get; }
  • public PersistentConnectionType Type { get; }
  • public DisconnectedEventArgs(PersistentConnectionType type, string hostname, int port, string reason)
• public class EasyNetQException : Exception
  • public EasyNetQException(string format, string[] args)
  • public EasyNetQException(string format, object[] args)
• public class EasyNetQInvalidMessageTypeException : EasyNetQException
• public class EasyNetQResponderException : EasyNetQException
  • public EasyNetQResponderException(string format, string[] args)
  • public EasyNetQResponderException(string format, object[] args)
• public sealed delegate ErrorQueueNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(MessageReceivedInfo receivedInfo, AsyncCallback callback, object object)
  • public virtual string Invoke()
  • public virtual string Invoke(MessageReceivedInfo receivedInfo)
• public sealed class EventBus : IEventBus
  • public EventBus()
  • public void Publish<TEvent>(TEvent event)
  • public CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
  • 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 static class ExchangeDeclareConfigurationExtensions
  • public static IExchangeDeclareConfiguration WithAlternateExchange(this IExchangeDeclareConfiguration configuration, Exchange alternateExchange)
• public interface IAdvancedBus : IDisposable
  • IContainer Container { get; }
  • IServiceResolver Container { get; }
  • event EventHandler<ConnectionBlockedEventArgs> Blocked
  • event EventHandler Connected
  • event EventHandler Disconnected
  • event EventHandler<BlockedEventArgs> Blocked
  • event EventHandler<ConnectedEventArgs> Connected
  • event EventHandler<DisconnectedEventArgs> Disconnected
  • event EventHandler Unblocked
  • IBinding Bind(IExchange exchange, IQueue queue, string routingKey)
  • IBinding Bind(IExchange source, IExchange destination, string routingKey)
  • Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey)
  • Task<IBinding> BindAsync(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, Action<IHandlerRegistration> addHandlers, Action<IConsumerConfiguration> configure)
  • IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
  • IDisposable Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • IExchange ExchangeDeclare(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null, bool delayed = false)
  • Task<IExchange> ExchangeDeclareAsync(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null, bool delayed = false)
  • void ExchangeDelete(IExchange exchange, bool ifUnused = false)
  • IBasicGetResult<T> Get<T>(IQueue queue)
  • IBasicGetResult Get(IQueue queue)
  • uint MessageCount(IQueue queue)
  • void Publish(IExchange exchange, string routingKey, bool mandatory, 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)
  • Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage 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, string deadLetterRoutingKey = null)
  • IQueue QueueDeclare()
  • Task<IQueue> QueueDeclareAsync(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int perQueueTtl = 2147483647, int expires = 2147483647, string deadLetterExchange = null, string deadLetterRoutingKey = null)
  • void QueueDelete(IQueue queue, bool ifUnused = false, bool ifEmpty = false)
  • void QueuePurge(IQueue queue)
  • event EventHandler<UnblockedEventArgs> Unblocked
  • Task<Binding<Queue>> BindAsync(Exchange exchange, Queue queue, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken = default)
  • Task<Binding<Exchange>> BindAsync(Exchange source, Exchange destination, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken = default)
  • Task ConnectAsync(CancellationToken cancellationToken = default)
  • IDisposable Consume(Action<IConsumeConfiguration> configure)
  • 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)
  • Task<Exchange> ExchangeDeclareAsync(string name, Action<IExchangeDeclareConfiguration> configure, CancellationToken cancellationToken = default)
  • Task ExchangeDeclarePassiveAsync(string name, CancellationToken cancellationToken = default)
  • Task ExchangeDeleteAsync(Exchange exchange, bool ifUnused = false, CancellationToken cancellationToken = default)
  • Task ExchangeUnbindAsync(string destinationExchange, string sourceExchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken = default)
  • Task<QueueStats> GetQueueStatsAsync(string name, CancellationToken cancellationToken = default)
  • Task PublishAsync(Exchange exchange, string routingKey, bool mandatory, IMessage message, CancellationToken cancellationToken = default)
  • Task PublishAsync<T>(Exchange exchange, string routingKey, bool mandatory, IMessage<T> message, CancellationToken cancellationToken = default)
  • Task PublishAsync(Exchange exchange, string routingKey, bool mandatory, MessageProperties properties, ReadOnlyMemory<byte> body, CancellationToken cancellationToken = default)
  • Task<Queue> QueueDeclareAsync(string name, Action<IQueueDeclareConfiguration> configure, CancellationToken cancellationToken = default)
  • Task<Queue> QueueDeclareAsync(CancellationToken cancellationToken = default)
  • Task QueueDeclarePassiveAsync(string name, 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 = default)
• public interface IBasicGetResult
• public interface IBasicGetResult<T>
• public interface IBus : IDisposable
  • bool IsConnected { get; }
  • 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, Action<T> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers, Action<IConsumerConfiguration> configure)
  • TResponse Request<TRequest, TResponse>(TRequest request)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder, Action<IResponderConfiguration> configure)
  • IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, Action<IResponderConfiguration> configure)
  • void Send<T>(string queue, T message)
  • Task SendAsync<T>(string queue, T message)
  • ISubscriptionResult Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • ISubscriptionResult Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • ISubscriptionResult SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • ISubscriptionResult SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
  • IPubSub PubSub { get; }
  • IRpc Rpc { get; }
  • IScheduler Scheduler { get; }
  • ISendReceive SendReceive { get; }
• public interface IClusterHostSelectionStrategy<T>
• public interface IConnectionFactory
• public interface IContainer : IServiceProvider, IServiceRegister
• 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 WithPrefetchCount(ushort prefetchCount)
• public interface IConventions
  • RpcExchangeNameConvention RpcExchangeNamingConvention { get; set; }
  • QueueTypeConvention QueueTypeConvention { get; }
  • RpcExchangeNameConvention RpcRequestExchangeNamingConvention { get; }
  • RpcExchangeNameConvention RpcResponseExchangeNamingConvention { get; }
• public interface IEasyNetQLogger
• public interface IEventBus
  • void Publish<TEvent>(TEvent event)
  • CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
  • void Publish<TEvent>(TEvent& modreq(System.Runtime.InteropServices.InAttribute) event) where TEvent : struct
  • IDisposable Subscribe<TEvent>(TEventHandler<TEvent> eventHandler) where TEvent : struct
• public interface IExchangeDeclareConfiguration
  • IExchangeDeclareConfiguration AsAutoDelete(bool isAutoDelete)
  • IExchangeDeclareConfiguration AsDurable(bool isDurable)
  • IExchangeDeclareConfiguration WithArgument(string name, object value)
  • IExchangeDeclareConfiguration WithType(string type)
• public interface IFuturePublishConfiguration
  • IFuturePublishConfiguration WithHeaders(IDictionary<string, object> headers)
  • IFuturePublishConfiguration WithPriority(byte priority)
  • IFuturePublishConfiguration WithTopic(string topic)
• public interface IMessageSerializationStrategy
  • IMessage<T> DeserializeMessage<T>(MessageProperties properties, byte[] body)
  • IMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • IMessage DeserializeMessage(MessageProperties properties, ReadOnlyMemory body)
• public interface IPersistentConnection : IDisposable
• public interface IPerQueueConsumeConfiguration
  • IPerQueueConsumeConfiguration WithArgument(string name, object value)
  • IPerQueueConsumeConfiguration WithAutoAck()
  • IPerQueueConsumeConfiguration WithConsumerTag(string consumerTag)
  • IPerQueueConsumeConfiguration WithExclusive(bool isExclusive = true)
• public interface IPublishConfiguration
  • IPublishConfiguration WithExpires(TimeSpan expires)
  • IPublishConfiguration WithHeaders(IDictionary<string, object> headers)
  • IPublishConfiguration WithPriority(byte priority)
  • IPublishConfiguration WithTopic(string topic)
• public interface IPubSub
  • Task PublishAsync<T>(T message, Action<IPublishConfiguration> configure, CancellationToken cancellationToken = default)
  • AwaitableDisposable<SubscriptionResult> SubscribeAsync<T>(string subscriptionId, Func<T, CancellationToken, Task> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
• public interface IPullingConsumer<TPullResult> : IDisposable where TPullResult : IPullResult
  • Task AckAsync(ulong deliveryTag, bool multiple, CancellationToken cancellationToken = default)
  • Task<TPullResult> PullAsync(CancellationToken cancellationToken = default)
  • Task RejectAsync(ulong deliveryTag, bool multiple, bool requeue, CancellationToken cancellationToken = default)
• 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)
• public interface IPullResult : IDisposable
  • bool IsAvailable { get; }
  • ulong MessagesCount { get; }
  • MessageReceivedInfo ReceivedInfo { get; }
• public interface IQueueDeclareConfiguration
  • IQueueDeclareConfiguration AsAutoDelete(bool isAutoDelete)
  • IQueueDeclareConfiguration AsDurable(bool isDurable)
  • IQueueDeclareConfiguration AsExclusive(bool isExclusive)
  • IQueueDeclareConfiguration WithArgument(string name, object value)
• public interface IReceiveConfiguration
  • IReceiveConfiguration AsExclusive(bool isExclusive = true)
  • IReceiveConfiguration WithAutoDelete(bool autoDelete = true)
  • IReceiveConfiguration WithDurable(bool durable = true)
  • IReceiveConfiguration WithExpires(int expires)
  • IReceiveConfiguration WithMaxLength(int maxLength)
  • IReceiveConfiguration WithMaxLengthBytes(int maxLengthBytes)
  • IReceiveConfiguration WithMaxPriority(byte priority)
  • IReceiveConfiguration WithPrefetchCount(ushort prefetchCount)
  • IReceiveConfiguration WithPriority(int priority)
  • IReceiveConfiguration WithQueueMode(string queueMode = "default")
  • IReceiveConfiguration WithQueueType(string queueType = "classic")
  • IReceiveConfiguration WithSingleActiveConsumer(bool singleActiveConsumer = true)
• public interface IReceiveRegistration
  • IReceiveRegistration Add<T>(Func<T, CancellationToken, Task> onMessage)
• public interface IRequestConfiguration
  • IRequestConfiguration WithExpiration(TimeSpan expiration)
  • IRequestConfiguration WithHeaders(IDictionary<string, object> headers)
  • IRequestConfiguration WithPriority(byte priority)
  • IRequestConfiguration WithQueueName(string queueName)
• public interface IResponderConfiguration
  • IResponderConfiguration WithDurable(bool durable = true)
  • IResponderConfiguration WithExpires(TimeSpan expires)
  • IResponderConfiguration WithMaxPriority(byte priority)
  • IResponderConfiguration WithPrefetchCount(ushort prefetchCount)
  • IResponderConfiguration WithQueueName(string queueName)
• public interface IRpc : IDisposable
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request, Action<IRequestConfiguration> configure, CancellationToken cancellationToken = default)
  • AwaitableDisposable<IDisposable> RespondAsync<TRequest, TResponse>(Func<TRequest, CancellationToken, Task<TResponse>> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken = default)
• public interface IScheduler
  • void CancelFuturePublish(string cancellationKey)
  • Task CancelFuturePublishAsync(string cancellationKey)
  • void FuturePublish<T>(DateTime futurePublishDate, T message)
  • void FuturePublish<T>(DateTime futurePublishDate, string cancellationKey, T message)
  • void FuturePublish<T>(TimeSpan messageDelay, T message)
  • Task FuturePublishAsync<T>(DateTime futurePublishDate, T message)
  • Task FuturePublishAsync<T>(DateTime futurePublishDate, string cancellationKey, T message)
  • Task FuturePublishAsync<T>(TimeSpan messageDelay, T message)
  • Task FuturePublishAsync<T>(T message, TimeSpan delay, Action<IFuturePublishConfiguration> configure, CancellationToken cancellationToken = default)
• public interface ISendConfiguration
  • ISendConfiguration WithHeaders(IDictionary<string, object> headers)
  • ISendConfiguration WithPriority(byte priority)
• public interface ISendReceive
  • AwaitableDisposable<IDisposable> ReceiveAsync(string queue, Action<IReceiveRegistration> addHandlers, Action<IReceiveConfiguration> configure, CancellationToken cancellationToken = default)
  • Task SendAsync<T>(string queue, T message, Action<ISendConfiguration> configure, CancellationToken cancellationToken = default)
• public interface ISerializer
  • T BytesToMessage<T>(byte[] bytes)
  • object BytesToMessage(string typeName, byte[] bytes)
  • byte[] MessageToBytes<T>(T message)
  • object BytesToMessage(Type messageType, ReadOnlyMemory bytes)
  • IMemoryOwner<byte> MessageToBytes(Type messageType, object message)
• public interface IServiceProvider
• public interface IServiceRegister
• public interface ISubscriptionResult : IDisposable
• public interface ITimeoutStrategy
• public interface ISimpleConsumeConfiguration
  • ISimpleConsumeConfiguration WithArgument(string name, object value)
  • ISimpleConsumeConfiguration WithAutoAck()
  • ISimpleConsumeConfiguration WithConsumerTag(string consumerTag)
  • ISimpleConsumeConfiguration WithExclusive(bool isExclusive = true)
  • ISimpleConsumeConfiguration WithPrefetchCount(ushort prefetchCount)
• public interface ISubscriptionConfiguration
  • ISubscriptionConfiguration AsExclusive(bool isExclusive = true)
  • ISubscriptionConfiguration WithAlternateExchange(string alternateExchange)
  • ISubscriptionConfiguration WithAutoDelete(bool autoDelete = true)
  • ISubscriptionConfiguration WithDurable(bool durable = true)
  • ISubscriptionConfiguration WithExchangeType(string exchangeType)
  • ISubscriptionConfiguration WithExpires(int expires)
  • ISubscriptionConfiguration WithMaxLength(int maxLength)
  • ISubscriptionConfiguration WithMaxLengthBytes(int maxLengthBytes)
  • ISubscriptionConfiguration WithMaxPriority(byte priority)
  • ISubscriptionConfiguration WithPrefetchCount(ushort prefetchCount)
  • ISubscriptionConfiguration WithPriority(int priority)
  • ISubscriptionConfiguration WithQueueMode(string queueMode = "default")
  • ISubscriptionConfiguration WithQueueName(string queueName)
  • ISubscriptionConfiguration WithQueueType(string queueType = "classic")
  • ISubscriptionConfiguration WithSingleActiveConsumer(bool singleActiveConsumer = true)
  • ISubscriptionConfiguration WithTopic(string topic)
• public class JsonSerializer : ISerializer
  • public JsonSerializer(ITypeNameSerializer typeNameSerializer)
  • public T BytesToMessage<T>(byte[] bytes)
  • public object BytesToMessage(string typeName, byte[] bytes)
  • public byte[] MessageToBytes<T>(T message)
  • public JsonSerializer(object serializerSettings = null)
  • public object BytesToMessage(Type messageType, ref ReadOnlyMemory bytes)
  • public IMemoryOwner<byte> MessageToBytes(Type messageType, object message)
• public static class LinqExtensions
• public class LegacyRpcConventions : Conventions
  • public LegacyRpcConventions(ITypeNameSerializer typeNameSerializer)
• public class LegacyTypeNameSerializer : ITypeNameSerializer
  • public LegacyTypeNameSerializer()
  • public Type DeSerialize(string typeName)
  • public string Serialize(Type type)
• public class Message<T> : IMessage<T>, IMessage
  • public Message()
  • public void SetProperties(MessageProperties properties)
• public class MessageNotAvailableException : Exception
• public class MessageProperties : ICloneable
  • public string Expiration { get; set; }
  • public TimeSpan? Expiration { get; set; }
  • public MessageProperties(IBasicProperties basicProperties)
  • public void AppendPropertyDebugStringTo(StringBuilder stringBuilder)
  • public void CopyFrom(IBasicProperties basicProperties)
  • public void CopyTo(IBasicProperties basicProperties)
  • public object Clone()
• public static class MessagePropertiesExtensions
  • public static void CopyFrom(this MessageProperties source, IBasicProperties basicProperties)
  • public static void CopyTo(this MessageProperties source, IBasicProperties basicProperties)
• public class MessageReceivedInfo
  • public ulong DeliverTag { get; set; }
  • public ulong DeliveryTag { get; }
  • public MessageReceivedInfo()
• public class MessageReturnedEventArgs : EventArgs
  • public byte[] MessageBody { get; }
  • public ReadOnlyMemory<byte> MessageBody { get; }
  • public MessageReturnedEventArgs(byte[] messageBody, MessageProperties messageProperties, MessageReturnedInfo messageReturnedInfo)
  • public MessageReturnedEventArgs(ref ReadOnlyMemory messageBody, MessageProperties messageProperties, ref MessageReturnedInfo messageReturnedInfo)
• public class OrderedClusterHostSelectionStrategy<T> : IClusterHostSelectionStrategy<T>, IEnumerable<T>, IEnumerable
• public class PersistentConnection : IPersistentConnection, IDisposable
• public static class NonGenericPubSubExtensions
  • public static void Publish(this IPubSub pubSub, object message, Type messageType, CancellationToken cancellationToken = default)
  • public static void Publish(this IPubSub pubSub, object message, Type messageType, Action<IPublishConfiguration> configure, CancellationToken cancellationToken = default)
  • public static void Publish(this IPubSub pubSub, object message, Type messageType, string topic, CancellationToken cancellationToken = default)
  • public static Task PublishAsync(this IPubSub pubSub, object message, Type messageType, CancellationToken cancellationToken = default)
  • public static Task PublishAsync(this IPubSub pubSub, object message, Type messageType, string topic, CancellationToken cancellationToken = default)
  • public static Task PublishAsync(this IPubSub pubSub, object message, Type messageType, Action<IPublishConfiguration> configure, CancellationToken cancellationToken = default)
  • 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 NonGenericRpcExtensions
  • public static object Request(this IRpc rpc, object request, Type requestType, Type responseType, CancellationToken cancellationToken = default)
  • public static object Request(this IRpc rpc, object request, Type requestType, Type responseType, Action<IRequestConfiguration> configure, CancellationToken cancellationToken = default)
  • public static Task<object> RequestAsync(this IRpc rpc, object request, Type requestType, Type responseType, CancellationToken cancellationToken = default)
  • public static Task<object> RequestAsync(this IRpc rpc, object request, Type requestType, Type responseType, Action<IRequestConfiguration> configure, CancellationToken cancellationToken = default)
• public static class NonGenericSchedulerExtensions
  • public static void FuturePublish(this IScheduler scheduler, object message, Type messageType, TimeSpan delay, string topic, CancellationToken cancellationToken = default)
  • public static void FuturePublish(this IScheduler scheduler, object message, Type messageType, TimeSpan delay, CancellationToken cancellationToken = default)
  • public static void FuturePublish(this IScheduler scheduler, object message, Type messageType, TimeSpan delay, Action<IFuturePublishConfiguration> configure, CancellationToken cancellationToken = default)
  • public static Task FuturePublishAsync(this IScheduler scheduler, object message, Type messageType, TimeSpan delay, CancellationToken cancellationToken = default)
  • public static Task FuturePublishAsync(this IScheduler scheduler, object message, Type messageType, TimeSpan delay, Action<IFuturePublishConfiguration> configure, CancellationToken cancellationToken = default)
• public static class NonGenericSendReceiveExtensions
  • public static void Send(this ISendReceive sendReceive, string queue, object message, Type messageType, CancellationToken cancellationToken = default)
  • public static void Send(this ISendReceive sendReceive, string queue, object message, Type messageType, Action<ISendConfiguration> configure, CancellationToken cancellationToken = default)
  • public static Task SendAsync(this ISendReceive sendReceive, string queue, object message, Type messageType, CancellationToken cancellationToken = default)
  • public static Task SendAsync(this ISendReceive sendReceive, string queue, object message, Type messageType, Action<ISendConfiguration> configure, CancellationToken cancellationToken = default)
• public static class OverflowType
  • public const string DropHead = "drop-head"
  • public const string RejectPublish = "reject-publish"
  • public const string RejectPublishDlx = "reject-publish-dlx"
• public static class PerQueueConsumeConfigurationExtensions
  • public static IPerQueueConsumeConfiguration WithArguments(this IPerQueueConsumeConfiguration configuration, IDictionary<string, object> arguments)
  • public static IPerQueueConsumeConfiguration WithPriority(this IPerQueueConsumeConfiguration configuration, int priority)
• public struct ProducedMessage
  • public ReadOnlyMemory<byte> Body { get; }
  • public MessageProperties Properties { get; }
  • public ProducedMessage(MessageProperties properties, ref ReadOnlyMemory body)
• public static class PubSubExtensions
  • public static void Publish<T>(this IPubSub pubSub, T message, CancellationToken cancellationToken = default)
  • public static void Publish<T>(this IPubSub pubSub, T message, Action<IPublishConfiguration> configure, CancellationToken cancellationToken = default)
  • public static void Publish<T>(this IPubSub pubSub, T message, string topic, CancellationToken cancellationToken = default)
  • public static Task PublishAsync<T>(this IPubSub pubSub, T message, CancellationToken cancellationToken = default)
  • public static Task PublishAsync<T>(this IPubSub pubSub, T message, string topic, CancellationToken cancellationToken = default)
  • public static SubscriptionResult Subscribe<T>(this IPubSub pubSub, string subscriptionId, Action<T> onMessage, CancellationToken cancellationToken = default)
  • public static SubscriptionResult Subscribe<T>(this IPubSub pubSub, string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
  • public static SubscriptionResult Subscribe<T>(this IPubSub pubSub, string subscriptionId, Func<T, Task> onMessage, CancellationToken cancellationToken = default)
  • public static SubscriptionResult Subscribe<T>(this IPubSub pubSub, string subscriptionId, Func<T, CancellationToken, Task> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<SubscriptionResult> SubscribeAsync<T>(this IPubSub pubSub, string subscriptionId, Action<T> onMessage, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<SubscriptionResult> SubscribeAsync<T>(this IPubSub pubSub, string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<SubscriptionResult> SubscribeAsync<T>(this IPubSub pubSub, string subscriptionId, Func<T, Task> onMessage, CancellationToken cancellationToken = default)
• public struct PullBatchResult<TPullResult> : IDisposable where TPullResult : IPullResult
  • public ulong DeliveryTag { get; }
  • public IReadOnlyList<TPullResult> Messages { get; }
  • public PullBatchResult(IReadOnlyList<TPullResult> messages)
  • public void Dispose()
• public class PullingConsumer : IPullingConsumer<PullResult>, IDisposable
  • public PullingConsumer(ref PullingConsumerOptions options, ref Queue queue, IPersistentChannel channel, IProduceConsumeInterceptor[] produceConsumeInterceptors)
  • public Task AckAsync(ulong deliveryTag, bool multiple, CancellationToken cancellationToken = default)
  • public void Dispose()
  • public Task<PullResult> PullAsync(CancellationToken cancellationToken = default)
  • public Task RejectAsync(ulong deliveryTag, bool multiple, bool requeue, CancellationToken cancellationToken = default)
• public class PullingConsumer<T> : IPullingConsumer<PullResult<T>>, IDisposable
  • public PullingConsumer(IPullingConsumer<PullResult> consumer, IMessageSerializationStrategy messageSerializationStrategy)
  • public Task AckAsync(ulong deliveryTag, bool multiple, CancellationToken cancellationToken = default)
  • public void Dispose()
  • public Task<PullResult<T>> PullAsync(CancellationToken cancellationToken = default)
  • public Task RejectAsync(ulong deliveryTag, bool multiple, bool requeue, CancellationToken cancellationToken = default)
• public static class PullingConsumerExtensions
  • public static Task AckAsync<TPullResult>(this IPullingConsumer<TPullResult> consumer, ulong deliveryTag, CancellationToken cancellationToken = default) where TPullResult : IPullResult
  • public static Task AckBatchAsync<TPullResult>(this IPullingConsumer<TPullResult> consumer, ulong deliveryTag, CancellationToken cancellationToken = default) where TPullResult : IPullResult
  • public static Task<PullBatchResult<TPullResult>> PullBatchAsync<TPullResult>(this IPullingConsumer<TPullResult> consumer, int batchSize, CancellationToken cancellationToken = default) where TPullResult : IPullResult
  • public static Task RejectAsync<TPullResult>(this IPullingConsumer<TPullResult> consumer, ulong deliveryTag, bool requeue = false, CancellationToken cancellationToken = default) where TPullResult : IPullResult
  • public static Task RejectBatchAsync<TPullResult>(this IPullingConsumer<TPullResult> consumer, ulong deliveryTag, bool requeue = false, CancellationToken cancellationToken = default) where TPullResult : IPullResult
• 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 struct PullingConsumerOptions
  • public bool AutoAck { get; }
  • public TimeSpan Timeout { get; }
  • public PullingConsumerOptions(bool autoAck, TimeSpan timeout)
• public struct PullResult : IPullResult, IDisposable
  • public static PullResult NotAvailable { get; }
  • public ReadOnlyMemory<byte> Body { get; }
  • public bool IsAvailable { get; }
  • public ulong MessagesCount { get; }
  • public MessageProperties Properties { get; }
  • public MessageReceivedInfo ReceivedInfo { get; }
  • public static PullResult Available(ulong messagesCount, MessageReceivedInfo receivedInfo, MessageProperties properties, ref ReadOnlyMemory body, IDisposable disposable)
  • public void Dispose()
• public struct PullResult<T> : IPullResult, IDisposable
  • public static PullResult<T> NotAvailable { get; }
  • public bool IsAvailable { get; }
  • public IMessage<T> Message { get; }
  • public ulong MessagesCount { get; }
  • public MessageReceivedInfo ReceivedInfo { get; }
  • public static PullResult<T> Available(ulong messagesCount, MessageReceivedInfo receivedInfo, IMessage<T> message)
  • public void Dispose()
• public class QueueAttribute : Attribute
  • public string QueueType { get; set; }
• public static class QueueDeclareConfigurationExtensions
  • public static IQueueDeclareConfiguration WithDeadLetterExchange(this IQueueDeclareConfiguration configuration, Exchange deadLetterExchange)
  • public static IQueueDeclareConfiguration WithDeadLetterRoutingKey(this IQueueDeclareConfiguration configuration, string deadLetterRoutingKey)
  • public static IQueueDeclareConfiguration WithDeadLetterStrategy(this IQueueDeclareConfiguration configuration, string deadLetterStrategy = "at-most-once")
  • public static IQueueDeclareConfiguration WithExpires(this IQueueDeclareConfiguration configuration, TimeSpan expires)
  • public static IQueueDeclareConfiguration WithMaxLength(this IQueueDeclareConfiguration configuration, int maxLength)
  • public static IQueueDeclareConfiguration WithMaxLengthBytes(this IQueueDeclareConfiguration configuration, int maxLengthBytes)
  • public static IQueueDeclareConfiguration WithMaxPriority(this IQueueDeclareConfiguration configuration, int maxPriority)
  • public static IQueueDeclareConfiguration WithMessageTtl(this IQueueDeclareConfiguration configuration, TimeSpan messageTtl)
  • 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 WithQueueMode(this IQueueDeclareConfiguration configuration, string queueMode = "default")
  • public static IQueueDeclareConfiguration WithQueueType(this IQueueDeclareConfiguration configuration, string queueType = "classic")
  • public static IQueueDeclareConfiguration WithSingleActiveConsumer(this IQueueDeclareConfiguration configuration, bool singleActiveConsumer = true)
• public static class QueueMasterLocator
  • public const string ClientLocal = "client-local"
  • public const string MinMasters = "min-masters"
  • public const string Random = "random"
• public static class QueueMode
  • public const string Default = "default"
  • public const string Lazy = "lazy"
• public struct QueueStats
  • public ulong ConsumersCount { get; }
  • public ulong MessagesCount { get; }
  • public QueueStats(ulong messagesCount, ulong consumersCount)
• public static class QueueType
  • public const string Classic = "classic"
  • public const string Quorum = "quorum"
• public sealed delegate QueueTypeConvention : MulticastDelegate
  • public QueueTypeConvention(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Type messageType, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(Type messageType)
• public class RabbitAdvancedBus : IAdvancedBus, IDisposable
  • public IContainer Container { get; }
  • public IServiceResolver Container { get; }
  • public event EventHandler<ConnectionBlockedEventArgs> Blocked
  • public event EventHandler Connected
  • public event EventHandler Disconnected
  • public event EventHandler<BlockedEventArgs> Blocked
  • public event EventHandler<ConnectedEventArgs> Connected
  • public event EventHandler<DisconnectedEventArgs> Disconnected
  • public event EventHandler Unblocked
  • public RabbitAdvancedBus(IConnectionFactory connectionFactory, IConsumerFactory consumerFactory, IEasyNetQLogger logger, IClientCommandDispatcherFactory clientCommandDispatcherFactory, IPublisher publisher, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, IContainer container, ConnectionConfiguration connectionConfiguration, IProduceConsumeInterceptor produceConsumeInterceptor, IMessageSerializationStrategy messageSerializationStrategy, IConventions conventions, AdvancedBusEventHandlers advancedBusEventHandlers)
  • public virtual IBinding Bind(IExchange exchange, IQueue queue, string routingKey)
  • public virtual IBinding Bind(IExchange source, IExchange destination, string routingKey)
  • public Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey)
  • public Task<IBinding> BindAsync(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 IDisposable Consume(IQueue queue, Action<IHandlerRegistration> addHandlers, 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 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 Task<Binding<Queue>> BindAsync(Exchange exchange, Queue queue, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public Task<Binding<Exchange>> BindAsync(Exchange source, Exchange destination, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public Task ConnectAsync(CancellationToken cancellationToken = default)
  • public IDisposable Consume(Action<IConsumeConfiguration> configure)
  • public IPullingConsumer<PullResult> CreatePullingConsumer(ref Queue queue, bool autoAck = true)
  • public IPullingConsumer<PullResult<T>> CreatePullingConsumer<T>(ref Queue queue, bool autoAck = true)
  • public virtual IExchange ExchangeDeclare(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null, bool delayed = false)
  • public Task<IExchange> ExchangeDeclareAsync(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null, bool delayed = false)
  • public virtual void ExchangeDelete(IExchange exchange, bool ifUnused = false)
  • public IBasicGetResult<T> Get<T>(IQueue queue)
  • public IBasicGetResult Get(IQueue queue)
  • public uint MessageCount(IQueue queue)
  • protected void OnBlocked(ConnectionBlockedEvent args)
  • protected void OnConnected()
  • protected void OnDisconnected()
  • protected void OnMessageReturned(ReturnedMessageEvent args)
  • protected void OnUnblocked()
  • 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 Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage 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, string deadLetterRoutingKey = null)
  • public virtual IQueue QueueDeclare()
  • public Task<IQueue> QueueDeclareAsync(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int perQueueTtl = 2147483647, int expires = 2147483647, string deadLetterExchange = null, string deadLetterRoutingKey = null)
  • public virtual void QueueDelete(IQueue queue, bool ifUnused = false, bool ifEmpty = false)
  • public virtual void QueuePurge(IQueue queue)
  • public Task<Exchange> ExchangeDeclareAsync(string name, Action<IExchangeDeclareConfiguration> configure, CancellationToken cancellationToken = default)
  • public Task ExchangeDeclarePassiveAsync(string name, CancellationToken cancellationToken = default)
  • public virtual Task ExchangeDeleteAsync(Exchange exchange, bool ifUnused = false, CancellationToken cancellationToken = default)
  • 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 virtual Task PublishAsync(Exchange exchange, string routingKey, bool mandatory, IMessage message, CancellationToken cancellationToken)
  • public virtual Task PublishAsync<T>(Exchange exchange, string routingKey, bool mandatory, IMessage<T> message, CancellationToken cancellationToken)
  • public virtual Task PublishAsync(Exchange exchange, string routingKey, bool mandatory, MessageProperties properties, ReadOnlyMemory<byte> body, CancellationToken cancellationToken)
  • public Task<Queue> QueueDeclareAsync(CancellationToken cancellationToken)
  • public Task<Queue> QueueDeclareAsync(string name, Action<IQueueDeclareConfiguration> configure, CancellationToken cancellationToken = default)
  • public Task QueueDeclarePassiveAsync(string name, CancellationToken cancellationToken = default)
  • 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 class RabbitBus : IBus, IDisposable
  • public virtual bool IsConnected { get; }
  • public RabbitBus(IConventions conventions, IAdvancedBus advancedBus, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, IRpc rpc, ISendReceive sendReceive, ConnectionConfiguration connectionConfiguration)
  • public IPubSub PubSub { get; }
  • public IRpc Rpc { get; }
  • public IScheduler Scheduler { get; }
  • public ISendReceive SendReceive { get; }
  • public RabbitBus(IAdvancedBus advanced, IPubSub pubSub, IRpc rpc, ISendReceive sendReceive, IScheduler scheduler)
  • public virtual void Publish<T>(T message)
  • public virtual void Publish<T>(T message, string topic)
  • public virtual 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, Action<T> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • public virtual IDisposable Receive<T>(string queue, Func<T, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • public virtual IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers, Action<IConsumerConfiguration> configure)
  • public virtual TResponse Request<TRequest, TResponse>(TRequest request)
  • public virtual Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • public virtual IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • public IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder, Action<IResponderConfiguration> configure)
  • public virtual IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • public IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, Action<IResponderConfiguration> configure)
  • public virtual void Send<T>(string queue, T message)
  • public virtual Task SendAsync<T>(string queue, T message)
  • public virtual ISubscriptionResult Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • public virtual ISubscriptionResult Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • public virtual ISubscriptionResult SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • public virtual ISubscriptionResult SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
• public static class RabbitBusExtensions
• public static class RabbitHutch
  • public static IBus CreateBus()
  • public static IBus CreateBus(Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(AdvancedBusEventHandlers advancedBusEventHandlers, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(AdvancedBusEventHandlers advancedBusEventHandlers)
  • public static IBus CreateBus(string connectionString, AdvancedBusEventHandlers advancedBusEventHandlers)
  • public static IBus CreateBus(string connectionString, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string connectionString, AdvancedBusEventHandlers advancedBusEventHandlers, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string hostName, ushort hostPort, string virtualHost, string username, string password, ushort requestedHeartbeat, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string hostName, ushort hostPort, string virtualHost, string username, string password, ushort requestedHeartbeat, AdvancedBusEventHandlers advancedBusEventHandlers, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(ConnectionConfiguration connectionConfiguration, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(ConnectionConfiguration connectionConfiguration, AdvancedBusEventHandlers advancedBusEventHandlers, Action<IServiceRegister> registerServices)
  • public static void SetContainerFactory(Func<IContainer> createContainer)
  • public static IBus CreateBus(string connectionString, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string hostName, ushort hostPort, string virtualHost, string username, string password, TimeSpan 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 class RandomClusterHostSelectionStrategy<T> : IClusterHostSelectionStrategy<T>, IEnumerable<T>, IEnumerable
• public static class ReflectionHelpers
• public static class ReceiveRegistrationExtensions
  • public static IReceiveRegistration Add<T>(this IReceiveRegistration receiveRegistration, Func<T, Task> onMessage)
  • public static IReceiveRegistration Add<T>(this IReceiveRegistration receiveRegistration, Action<T> onMessage)
• public sealed delegate RpcExchangeNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(Type messageType, AsyncCallback callback, object object)
  • public virtual string Invoke()
  • public virtual string Invoke(Type messageType)
• public static class RpcExtensions
  • public static TResponse Request<TRequest, TResponse>(this IRpc rpc, TRequest request, CancellationToken cancellationToken = default)
  • public static TResponse Request<TRequest, TResponse>(this IRpc rpc, TRequest request, Action<IRequestConfiguration> configure, CancellationToken cancellationToken = default)
  • public static Task<TResponse> RequestAsync<TRequest, TResponse>(this IRpc rpc, TRequest request, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, Task<TResponse>> responder, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, TResponse> responder, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, TResponse> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, Task<TResponse>> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken = default)
  • public static IDisposable Respond<TRequest, TResponse>(this IRpc rpc, Func<TRequest, CancellationToken, Task<TResponse>> responder, Action<IResponderConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> RespondAsync<TRequest, TResponse>(this IRpc rpc, Func<TRequest, TResponse> responder, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> RespondAsync<TRequest, TResponse>(this IRpc rpc, Func<TRequest, Task<TResponse>> responder, CancellationToken cancellationToken = default)
• public sealed delegate RpcReturnQueueNamingConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(Type messageType, AsyncCallback callback, object object)
  • public virtual string Invoke()
  • public virtual string Invoke(Type messageType)
• public class Scheduler : IScheduler
• public static class SchedulerExtensions
  • public static void FuturePublish<T>(this IScheduler scheduler, T message, TimeSpan delay, string topic, CancellationToken cancellationToken = default)
  • public static void FuturePublish<T>(this IScheduler scheduler, T message, TimeSpan delay, CancellationToken cancellationToken = default)
  • public static Task FuturePublishAsync<T>(this IScheduler scheduler, T message, TimeSpan delay, CancellationToken cancellationToken = default)
• public static class SendReceiveExtensions
  • public static IDisposable Receive<T>(this ISendReceive sendReceive, string queue, Action<T> onMessage, CancellationToken cancellationToken = default)
  • public static IDisposable Receive<T>(this ISendReceive sendReceive, string queue, Action<T> onMessage, Action<IReceiveConfiguration> configure, CancellationToken cancellationToken = default)
  • public static IDisposable Receive<T>(this ISendReceive sendReceive, string queue, Func<T, Task> onMessage, CancellationToken cancellationToken = default)
  • public static IDisposable Receive<T>(this ISendReceive sendReceive, string queue, Func<T, CancellationToken, Task> onMessage, Action<IReceiveConfiguration> configure, CancellationToken cancellationToken = default)
  • public static IDisposable Receive(this ISendReceive sendReceive, string queue, Action<IReceiveRegistration> addHandlers, CancellationToken cancellationToken = default)
  • public static IDisposable Receive(this ISendReceive sendReceive, string queue, Action<IReceiveRegistration> addHandlers, Action<IReceiveConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Func<T, CancellationToken, Task> onMessage, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Func<T, CancellationToken, Task> onMessage, Action<IReceiveConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Action<T> onMessage, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Action<T> onMessage, Action<IReceiveConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Func<T, Task> onMessage, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync<T>(this ISendReceive sendReceive, string queue, Func<T, Task> onMessage, Action<IReceiveConfiguration> configure, CancellationToken cancellationToken = default)
  • public static AwaitableDisposable<IDisposable> ReceiveAsync(this ISendReceive sendReceive, string queue, Action<IReceiveRegistration> addHandlers, CancellationToken cancellationToken = default)
  • public static void Send<T>(this ISendReceive sendReceive, string queue, T message, CancellationToken cancellationToken = default)
  • public static void Send<T>(this ISendReceive sendReceive, string queue, T message, Action<ISendConfiguration> configure, CancellationToken cancellationToken = default)
  • public static Task SendAsync<T>(this ISendReceive sendReceive, string queue, T message, CancellationToken cancellationToken = default)
• public struct SerializedMessage : IDisposable
  • public byte[] Body { get; }
  • public ReadOnlyMemory<byte> Body { get; }
  • public SerializedMessage(MessageProperties properties, byte[] body)
  • public SerializedMessage(MessageProperties properties, IMemoryOwner<byte> body)
  • public void Dispose()
• public static class ServiceRegisterExtensions
  • public static IServiceRegister EnableAdvancedMessagePolymorphism(this IServiceRegister serviceRegister)
  • 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 IServiceRegister EnableDelayedExchangeScheduler(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableLegacyConventions(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableLegacyRpcConventions(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableLegacyTypeNaming(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableMessageVersioning(this IServiceRegister serviceRegister)
  • public static IServiceRegister EnableMultiChannelClientCommandDispatcher(this IServiceRegister serviceRegister, int channelsCount)
  • public static void RegisterDefaultServices(this IServiceRegister serviceRegister, Func<IServiceResolver, ConnectionConfiguration> connectionConfigurationFactory)
• public static class SimpleConsumeConfigurationExtensions
  • public static ISimpleConsumeConfiguration WithPriority(this ISimpleConsumeConfiguration configuration, int priority)
• public struct SubscriptionResult : IDisposable
  • public Exchange Exchange { get; }
  • public Queue Queue { get; }
  • public SubscriptionResult(ref Exchange exchange, ref Queue queue, IDisposable consumerCancellation)
  • public void Dispose()
• public static class TaskHelpers
• public class TimeoutSecondsAttribute : Attribute
• public class TimeoutStrategy : ITimeoutStrategy
• public sealed delegate TEventHandler<TEvent> : MulticastDelegate where TEvent : struct
  • public TEventHandler(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(TEvent& modreq(System.Runtime.InteropServices.InAttribute) event, AsyncCallback callback, object object)
  • public virtual void EndInvoke(TEvent& modreq(System.Runtime.InteropServices.InAttribute) event, IAsyncResult result)
  • public virtual void Invoke(TEvent& modreq(System.Runtime.InteropServices.InAttribute) event)
• public class TypeNameSerializer : ITypeNameSerializer
• public class UnblockedEventArgs : EventArgs
  • public PersistentConnectionType Type { get; }
  • public UnblockedEventArgs(PersistentConnectionType type)

EasyNetQ.AmqpExceptions

• public class AmapExceptionPreface
• public class AmqpException
• public class AmqpExceptionClassIdElement : AmqpExceptionIntegerValueElement
• public class AmqpExceptionCodeElement : AmqpExceptionIntegerValueElement
• public static class AmqpExceptionGrammar
• public abstract class AmqpExceptionIntegerValueElement : IAmqpExceptionElement
• public class AmqpExceptionKeyValueElement : IAmqpExceptionElement
• public class AmqpExceptionMethodIdElement : AmqpExceptionIntegerValueElement
• public interface IAmqpExceptionElement
• public class TextElement : IAmqpExceptionElement

EasyNetQ.AutoSubscribe

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

EasyNetQ.ChannelDispatcher

• public interface IPersistentChannelDispatcher : IDisposable
  • Task<TResult> InvokeAsync<TResult, TChannelAction>(TChannelAction channelAction, PersistentChannelDispatchOptions options, CancellationToken cancellationToken = default) where TChannelAction : struct, IPersistentChannelAction<TResult>
• public sealed class MultiPersistentChannelDispatcher : IPersistentChannelDispatcher, IDisposable
  • public MultiPersistentChannelDispatcher(int channelsCount, IProducerConnection producerConnection, IConsumerConnection consumerConnection, IPersistentChannelFactory channelFactory)
  • public void Dispose()
  • public Task<TResult> InvokeAsync<TResult, TChannelAction>(TChannelAction channelAction, PersistentChannelDispatchOptions options, CancellationToken cancellationToken = default) where TChannelAction : struct, IPersistentChannelAction<TResult>
• public class PersistentChannelDispatchOptions
  • public static readonly PersistentChannelDispatchOptions ConsumerTopology
  • public static readonly PersistentChannelDispatchOptions ProducerPublish
  • public static readonly PersistentChannelDispatchOptions ProducerPublishWithConfirms
  • public static readonly PersistentChannelDispatchOptions ProducerTopology
  • public PersistentConnectionType ConnectionType { get; }
  • public string Name { get; }
  • public bool PublisherConfirms { get; }
  • protected bool Equals(PersistentChannelDispatchOptions other)
• public sealed class SinglePersistentChannelDispatcher : IPersistentChannelDispatcher, IDisposable
  • public SinglePersistentChannelDispatcher(IProducerConnection producerConnection, IConsumerConnection consumerConnection, IPersistentChannelFactory channelFactory)
  • public void Dispose()
  • public Task<TResult> InvokeAsync<TResult, TChannelAction>(TChannelAction channelAction, PersistentChannelDispatchOptions options, CancellationToken cancellationToken = default) where TChannelAction : struct, IPersistentChannelAction<TResult>

EasyNetQ.ConnectionString

• public static class ConnectionStringGrammar
• public class AmqpConnectionStringParser : IConnectionStringParser
  • public AmqpConnectionStringParser()
  • public ConnectionConfiguration Parse(string connectionString)

EasyNetQ.Consumer

• public static class AckStrategies
  • public static AckStrategy Nothing
• public class ConsumerCancellation : IDisposable
• public class Base64ErrorMessageSerializer : IErrorMessageSerializer
  • public Base64ErrorMessageSerializer()
  • public byte[] Deserialize(string messageBody)
  • public string Serialize(byte[] messageBody)
• public class Consumer : IConsumer, IDisposable
  • public Guid Id { get; }
  • public Consumer(ILogger<Consumer> logger, ConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public void Dispose()
  • public void StartConsuming()
• public class ConsumerConfiguration
  • public bool CancelOnHaFailover { get; }
  • public bool IsExclusive { get; }
  • public IReadOnlyDictionary<Queue, PerQueueConsumerConfiguration> PerQueueConfigurations { get; }
  • public int Priority { get; }
  • public ConsumerConfiguration(ushort defaultPrefetchCount)
  • public IConsumerConfiguration AsExclusive()
  • public IConsumerConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • public IConsumerConfiguration WithPrefetchCount(ushort prefetchCount)
  • public IConsumerConfiguration WithPriority(int priority)
  • public ConsumerConfiguration(ushort prefetchCount, IReadOnlyDictionary<Queue, PerQueueConsumerConfiguration> perQueueConfigurations)
• public class ConsumerDispatcher : IConsumerDispatcher, IDisposable
• public class ConsumerDispatcherFactory : IConsumerDispatcherFactory, IDisposable
• public sealed class ConsumerConnection : PersistentConnection, IConsumerConnection, IPersistentConnection, IDisposable
  • public ConsumerConnection(ILogger<ConsumerConnection> logger, ConnectionConfiguration configuration, IConnectionFactory connectionFactory, IEventBus eventBus)
• public struct ConsumerExecutionContext
  • public byte[] Body { get; }
  • public IBasicConsumer Consumer { get; }
  • public MessageReceivedInfo Info { get; }
  • public ReadOnlyMemory<byte> Body { get; }
  • public MessageHandler Handler { get; }
  • public Func<byte[], MessageProperties, MessageReceivedInfo, Task> UserHandler { get; }
  • public ConsumerExecutionContext(Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler, MessageReceivedInfo info, MessageProperties properties, byte[] body, IBasicConsumer consumer)
  • public MessageReceivedInfo ReceivedInfo { get; }
  • public ConsumerExecutionContext(MessageHandler handler, MessageReceivedInfo receivedInfo, MessageProperties properties, ref ReadOnlyMemory body)
• public class ConsumerFactory : IConsumerFactory, IDisposable
  • public ConsumerFactory(IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
  • public ConsumerFactory(ILogger<Consumer> logger, IEventBus eventBus, IInternalConsumerFactory internalConsumerFactory)
  • public IConsumer CreateConsumer(ConsumerConfiguration configuration)
• public class DefaultConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable
  • public DefaultConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer, IEasyNetQLogger logger, IConventions conventions, ITypeNameSerializer typeNameSerializer)
  • public DefaultConsumerErrorStrategy(ILogger<DefaultConsumerErrorStrategy> logger, IConsumerConnection connection, ISerializer serializer, IConventions conventions, ITypeNameSerializer typeNameSerializer, IErrorMessageSerializer errorMessageSerializer, ConnectionConfiguration configuration)
  • public AckStrategy HandleConsumerCancelled(ConsumerExecutionContext context)
  • public virtual AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception)
  • public virtual Task<AckStrategy> HandleConsumerCancelledAsync(ConsumerExecutionContext context, CancellationToken cancellationToken)
  • public virtual Task<AckStrategy> HandleConsumerErrorAsync(ConsumerExecutionContext context, Exception exception, CancellationToken cancellationToken)
• public class ExclusiveConsumer : IConsumer, IDisposable
• public class DefaultErrorMessageSerializer : IErrorMessageSerializer
  • public DefaultErrorMessageSerializer()
  • public byte[] Deserialize(string messageBody)
  • public string Serialize(byte[] messageBody)
• public class HandlerCollection : IHandlerCollection, IHandlerRegistration
  • public HandlerCollection(IEasyNetQLogger logger)
  • public IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • public IHandlerRegistration Add<T>(Action<IMessage<T>, MessageReceivedInfo> handler)
  • public Func<IMessage<T>, MessageReceivedInfo, Task> GetHandler<T>()
  • public Func<IMessage, MessageReceivedInfo, Task> GetHandler(Type messageType)
  • public HandlerCollection()
  • public IHandlerRegistration Add<T>(IMessageHandler<T> handler)
  • public IMessageHandler<T> GetHandler<T>()
  • public IMessageHandler GetHandler(Type messageType)
• public class HandlerCollectionFactory : IHandlerCollectionFactory
  • public HandlerCollectionFactory(IEasyNetQLogger logger)
  • public IHandlerCollection CreateHandlerCollection()
  • public HandlerCollectionFactory()
  • public IHandlerCollection CreateHandlerCollection(ref Queue queue)
• public class HandlerCollectionPerQueueFactory : IHandlerCollectionFactory
  • public HandlerCollectionPerQueueFactory()
  • public IHandlerCollection CreateHandlerCollection(ref Queue queue)
• public static class HandlerRegistrationExtensions
  • public static IHandlerRegistration Add<T>(this IHandlerRegistration handlerRegistration, Action<IMessage<T>, MessageReceivedInfo> handler)
  • public static IHandlerRegistration Add<T>(this IHandlerRegistration handlerRegistration, Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • public static IHandlerRegistration Add<T>(this IHandlerRegistration handlerRegistration, Func<IMessage<T>, MessageReceivedInfo, Task<AckStrategy>> handler)
  • public static IHandlerRegistration Add<T>(this IHandlerRegistration handlerRegistration, Func<IMessage<T>, MessageReceivedInfo, CancellationToken, Task> handler)
• public class HandlerRunner : IHandlerRunner, IDisposable
  • public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus)
  • public HandlerRunner(ILogger<IHandlerRunner> logger, IConsumerErrorStrategy consumerErrorStrategy)
  • public void InvokeUserMessageHandler(ConsumerExecutionContext context)
  • public virtual Task<AckStrategy> InvokeUserMessageHandlerAsync(ConsumerExecutionContext context, CancellationToken cancellationToken)
• public interface IConsumer : IDisposable
  • IDisposable StartConsuming()
  • Guid Id { get; }
  • void StartConsuming()
• public interface IConsumerConfiguration
• public interface IConsumerDispatcher : IDisposable
• public interface IConsumerDispatcherFactory : IDisposable
• public interface IConsumerConnection : IPersistentConnection, IDisposable
• public interface IConsumerErrorStrategy : IDisposable
  • AckStrategy HandleConsumerCancelled(ConsumerExecutionContext context)
  • AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception)
  • Task<AckStrategy> HandleConsumerCancelledAsync(ConsumerExecutionContext context, CancellationToken cancellationToken = default)
  • Task<AckStrategy> HandleConsumerErrorAsync(ConsumerExecutionContext context, Exception exception, CancellationToken cancellationToken = default)
• public interface IConsumerFactory : IDisposable
  • IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
  • IConsumer CreateConsumer(ConsumerConfiguration configuration)
• public interface IErrorMessageSerializer
  • byte[] Deserialize(string messageBody)
  • string Serialize(byte[] messageBody)
• public interface IHandlerCollection : IHandlerRegistration
  • Func<IMessage<T>, MessageReceivedInfo, Task> GetHandler<T>()
  • Func<IMessage, MessageReceivedInfo, Task> GetHandler(Type messageType)
  • IMessageHandler<T> GetHandler<T>()
  • IMessageHandler GetHandler(Type messageType)
• public interface IHandlerCollectionFactory
  • IHandlerCollection CreateHandlerCollection()
  • IHandlerCollection CreateHandlerCollection(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue)
• public interface IHandlerRegistration
  • bool ThrowOnNoMatchingHandler { get; set; }
  • IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • IHandlerRegistration Add<T>(Action<IMessage<T>, MessageReceivedInfo> handler)
  • IHandlerRegistration Add<T>(IMessageHandler<T> handler)
• public interface IHandlerRunner : IDisposable
  • void InvokeUserMessageHandler(ConsumerExecutionContext context)
  • Task<AckStrategy> InvokeUserMessageHandlerAsync(ConsumerExecutionContext context, CancellationToken cancellationToken = default)
• public interface IInternalConsumer : IDisposable
  • event Action<IInternalConsumer> Cancelled
  • StartConsumingStatus StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
  • event EventHandler<InternalConsumerCancelledEventArgs> Cancelled
  • InternalConsumerStatus StartConsuming(bool firstStart = true)
  • void StopConsuming()
• public interface IInternalConsumerFactory : IDisposable
  • IInternalConsumer CreateConsumer()
  • void OnDisconnected()
  • IInternalConsumer CreateConsumer(ConsumerConfiguration configuration)
• public sealed delegate IMessageHandler : MulticastDelegate
  • public IMessageHandler(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(IMessage message, MessageReceivedInfo receivedInfo, CancellationToken cancellationToken, AsyncCallback callback, object object)
  • public virtual Task<AckStrategy> EndInvoke(IAsyncResult result)
  • public virtual Task<AckStrategy> Invoke(IMessage message, MessageReceivedInfo receivedInfo, CancellationToken cancellationToken)
• public sealed delegate IMessageHandler<T> : MulticastDelegate
  • public IMessageHandler(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(IMessage<T> message, MessageReceivedInfo receivedInfo, CancellationToken cancellationToken, AsyncCallback callback, object object)
  • public virtual Task<AckStrategy> EndInvoke(IAsyncResult result)
  • public virtual Task<AckStrategy> Invoke(IMessage<T> message, MessageReceivedInfo receivedInfo, CancellationToken cancellationToken)
• public class InternalConsumer : IInternalConsumer, IDisposable
  • public string ConsumerTag { get; }
  • public IModel Model { get; }
  • public event Action<IInternalConsumer> Cancelled
  • public event ConsumerCancelledEventHandler ConsumerCancelled
  • public InternalConsumer(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConsumerDispatcher consumerDispatcher, IConventions conventions, ConnectionConfiguration connectionConfiguration, IEventBus eventBus)
  • public event EventHandler<InternalConsumerCancelledEventArgs> Cancelled
  • public InternalConsumer(ILogger<InternalConsumer> logger, ConsumerConfiguration configuration, IConsumerConnection connection, IHandlerRunner handlerRunner, IEventBus eventBus)
  • 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 StartConsumingStatus StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
  • public InternalConsumerStatus StartConsuming(bool firstStart)
  • public void StopConsuming()
• public class InternalConsumerCancelledEventArgs : EventArgs
  • public IReadOnlyCollection<Queue> Active { get; }
  • public Queue Cancelled { get; }
  • public InternalConsumerCancelledEventArgs(ref Queue cancelled, IReadOnlyCollection<Queue> active)
• public class InternalConsumerFactory : IInternalConsumerFactory, IDisposable
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConventions conventions, ConnectionConfiguration connectionConfiguration, IConsumerDispatcherFactory consumerDispatcherFactory, IEventBus eventBus)
  • public IInternalConsumer CreateConsumer()
  • public InternalConsumerFactory(ILogger<InternalConsumer> logger, IConsumerConnection connection, IHandlerRunner handlerRunner, IEventBus eventBus)
  • public IInternalConsumer CreateConsumer(ConsumerConfiguration configuration)
  • public void OnDisconnected()
• public interface IReceiveRegistration
• public class PersistentConsumer : IConsumer, IDisposable
• public enum StartConsumingStatus
• public class SubscriptionResult : ISubscriptionResult, IDisposable
• public class TransientConsumer : IConsumer, IDisposable
• public struct InternalConsumerStatus
  • public IReadOnlyCollection<Queue> Active { get; }
  • public IReadOnlyCollection<Queue> Failed { get; }
  • public IReadOnlyCollection<Queue> Started { get; }
  • public InternalConsumerStatus(IReadOnlyCollection<Queue> started, IReadOnlyCollection<Queue> active, IReadOnlyCollection<Queue> failed)
• public sealed delegate MessageHandler : MulticastDelegate
  • public MessageHandler(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ReadOnlyMemory<byte> body, MessageProperties properties, MessageReceivedInfo receivedInfo, CancellationToken cancellationToken, AsyncCallback callback, object object)
  • public virtual Task<AckStrategy> EndInvoke(IAsyncResult result)
  • public virtual Task<AckStrategy> Invoke(ReadOnlyMemory<byte> body, MessageProperties properties, MessageReceivedInfo receivedInfo, CancellationToken cancellationToken)
• public class PerQueueConsumerConfiguration
  • public IDictionary<string, object> Arguments { get; }
  • public bool AutoAck { get; }
  • public string ConsumerTag { get; }
  • public MessageHandler Handler { get; }
  • public bool IsExclusive { get; }
  • public PerQueueConsumerConfiguration(bool autoAck, string consumerTag, bool isExclusive, IDictionary<string, object> arguments, MessageHandler handler)
• public class SimpleConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable
  • public static readonly SimpleConsumerErrorStrategy Ack
  • public static readonly SimpleConsumerErrorStrategy NackWithoutRequeue
  • public static readonly SimpleConsumerErrorStrategy NackWithRequeue
  • public void Dispose()
  • public Task<AckStrategy> HandleConsumerCancelledAsync(ConsumerExecutionContext context, CancellationToken cancellationToken = default)
  • public Task<AckStrategy> HandleConsumerErrorAsync(ConsumerExecutionContext context, Exception exception, CancellationToken cancellationToken = default)

EasyNetQ.DI

• public class DefaultConsumeScopeProvider : IConsumeScopeProvider
  • public DefaultConsumeScopeProvider(IServiceResolver resolver)
  • public IServiceResolverScope CreateScope()
• public interface IConsumeScopeProvider
  • IServiceResolverScope CreateScope()
• 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)
• public interface IServiceResolver
  • IServiceResolverScope CreateScope()
  • TService Resolve<TService>()
• public interface IServiceResolverScope : IServiceResolver, IDisposable
• public enum Lifetime
  • Singleton = 1
  • Transient = 0
• public class NoopConsumeScopeProvider : IConsumeScopeProvider
  • public NoopConsumeScopeProvider()
  • public IServiceResolverScope CreateScope()
• public static class ServiceRegisterExtensions
  • public static IServiceRegister Register<TService>(this IServiceRegister services, Lifetime lifetime = 1)
  • public static IServiceRegister Register<TService, TImplementation>(this IServiceRegister services, Lifetime lifetime = 1) where TImplementation : TService
  • public static IServiceRegister Register<TService>(this IServiceRegister services, Func<IServiceResolver, TService> implementationFactory, Lifetime lifetime = 1)
  • public static IServiceRegister Register<TService, TImplementation>(this IServiceRegister services, Func<IServiceResolver, TImplementation> implementationFactory, Lifetime lifetime = 1) where TImplementation : TService
  • public static IServiceRegister Register<TService>(this IServiceRegister services, TService implementationInstance)
  • public static IServiceRegister TryRegister<TService, TImplementation>(this IServiceRegister services, Lifetime lifetime = 1)
  • public static IServiceRegister TryRegister<TService, TImplementation>(this IServiceRegister services, Func<IServiceResolver, TImplementation> implementationFactory, Lifetime lifetime = 1) where TImplementation : TService
  • public static IServiceRegister TryRegister<TService>(this IServiceRegister services, Func<IServiceResolver, TService> implementationFactory, Lifetime lifetime = 1)
  • public static IServiceRegister TryRegister<TService>(this IServiceRegister services, TService implementationInstance)
• public class ServiceResolverScope : IServiceResolverScope, IServiceResolver, IDisposable
  • public ServiceResolverScope(IServiceResolver resolver)
  • public IServiceResolverScope CreateScope()
  • public void Dispose()
  • public TService Resolve<TService>()

EasyNetQ.Events

• public struct AckEvent
  • public byte[] Body { get; }
  • public ReadOnlyMemory<byte> Body { get; }
  • public AckEvent(MessageReceivedInfo info, MessageProperties properties, byte[] body, AckResult ackResult)
  • public AckEvent(MessageReceivedInfo info, MessageProperties properties, ref ReadOnlyMemory body, AckResult ackResult)
• public enum AckResult
  • Nothing = 3
• public struct ChannelRecoveredEvent
  • public IModel Channel { get; }
  • public ChannelRecoveredEvent(IModel channel)
• public struct ChannelShutdownEvent
  • public IModel Channel { get; }
  • public ChannelShutdownEvent(IModel channel)
• public struct ConnectionBlockedEvent
  • public ConnectionBlockedEvent(string reason)
  • public PersistentConnectionType Type { get; }
  • public ConnectionBlockedEvent(PersistentConnectionType type, string reason)
• public struct ConnectionCreatedEvent
  • public ConnectionCreatedEvent()
  • public AmqpTcpEndpoint Endpoint { get; }
  • public PersistentConnectionType Type { get; }
  • public ConnectionCreatedEvent(PersistentConnectionType type, AmqpTcpEndpoint endpoint)
• public struct ConnectionDisconnectedEvent
  • public ConnectionDisconnectedEvent()
  • public AmqpTcpEndpoint Endpoint { get; }
  • public string Reason { get; }
  • public PersistentConnectionType Type { get; }
  • public ConnectionDisconnectedEvent(PersistentConnectionType type, AmqpTcpEndpoint endpoint, string reason)
• public struct ConnectionRecoveredEvent
  • public AmqpTcpEndpoint Endpoint { get; }
  • public PersistentConnectionType Type { get; }
  • public ConnectionRecoveredEvent(PersistentConnectionType type, AmqpTcpEndpoint endpoint)
• public struct ConnectionUnblockedEvent
  • public ConnectionUnblockedEvent()
  • public PersistentConnectionType Type { get; }
  • public ConnectionUnblockedEvent(PersistentConnectionType type)
• public struct ConsumerModelDisposedEvent
  • public string ConsumerTag { get; }
  • public ConsumerModelDisposedEvent(string consumerTag)
  • public IReadOnlyCollection<string> ConsumerTags { get; }
  • public ConsumerModelDisposedEvent(string[] consumerTags)
• public struct DeliveredMessageEvent
  • public byte[] Body { get; }
  • public ReadOnlyMemory<byte> Body { get; }
  • public DeliveredMessageEvent(MessageReceivedInfo info, MessageProperties properties, byte[] body)
  • public DeliveredMessageEvent(MessageReceivedInfo info, MessageProperties properties, ref ReadOnlyMemory body)
• public class PublishChannelCreatedEvent
• public struct MessageConfirmationEvent
  • public IModel Channel { get; }
  • public ulong DeliveryTag { get; }
  • public bool IsNack { get; }
  • public bool Multiple { get; }
  • public static MessageConfirmationEvent Ack(IModel channel, ulong deliveryTag, bool multiple)
  • public static MessageConfirmationEvent Nack(IModel channel, ulong deliveryTag, bool multiple)
• public struct PublishedMessageEvent
  • public byte[] Body { get; }
  • public string ExchangeName { get; }
  • public ReadOnlyMemory<byte> Body { get; }
  • public Exchange Exchange { get; }
  • public PublishedMessageEvent(string exchangeName, string routingKey, MessageProperties properties, byte[] body)
  • public PublishedMessageEvent(ref Exchange exchange, string routingKey, MessageProperties properties, ref ReadOnlyMemory body)
• public struct ReturnedMessageEvent
  • public byte[] Body { get; set; }
  • public ReadOnlyMemory<byte> Body { get; }
  • public IModel Channel { get; }
  • public ReturnedMessageEvent(byte[] body, MessageProperties properties, MessageReturnedInfo info)
  • public ReturnedMessageEvent(IModel channel, ref ReadOnlyMemory body, MessageProperties properties, ref MessageReturnedInfo info)
• public struct StartConsumingFailedEvent
  • public IConsumer Consumer { get; }
  • public Queue Queue { get; }
  • public StartConsumingFailedEvent(IConsumer consumer, ref Queue queue)
• public struct StartConsumingSucceededEvent
  • public IConsumer Consumer { get; }
  • public Queue Queue { get; }
  • public StartConsumingSucceededEvent(IConsumer consumer, ref Queue queue)

EasyNetQ.FluentConfiguration

• public interface ISubscriptionConfiguration
• public class SubscriptionConfiguration : ISubscriptionConfiguration

EasyNetQ.Interception

• public class CompositeInterceptor : IProduceConsumeInterceptor
• public class DefaultInterceptor : IProduceConsumeInterceptor
• public class CompositeProduceConsumerInterceptor : IProduceConsumeInterceptor
  • public CompositeProduceConsumerInterceptor(IEnumerable<IProduceConsumeInterceptor> interceptors)
  • public ConsumedMessage OnConsume(ref ConsumedMessage message)
  • public ProducedMessage OnProduce(ref ProducedMessage message)
• public class GZipInterceptor : IProduceConsumeInterceptor
  • public RawMessage OnConsume(RawMessage rawMessage)
  • public RawMessage OnProduce(RawMessage rawMessage)
  • public ConsumedMessage OnConsume(ref ConsumedMessage message)
  • public ProducedMessage OnProduce(ref ProducedMessage message)
• public interface IInterceptorRegistrator
• public static class InterceptionExtentions
• public class InterceptorRegistrator : IInterceptorRegistrator
• public interface IProduceConsumeInterceptor
  • RawMessage OnConsume(RawMessage rawMessage)
  • RawMessage OnProduce(RawMessage rawMessage)
  • ConsumedMessage OnConsume(ConsumedMessage& modreq(System.Runtime.InteropServices.InAttribute) message)
  • ProducedMessage OnProduce(ProducedMessage& modreq(System.Runtime.InteropServices.InAttribute) message)
• public class RawMessage
• public class TripleDESInterceptor : IProduceConsumeInterceptor
  • public RawMessage OnConsume(RawMessage rawMessage)
  • public RawMessage OnProduce(RawMessage rawMessage)
  • public ConsumedMessage OnConsume(ref ConsumedMessage message)
  • public ProducedMessage OnProduce(ref ProducedMessage message)

EasyNetQ.Internals

• public sealed class ArrayPooledMemoryStream : Stream, IMemoryOwner<byte>, IDisposable
  • public Memory<byte> Memory { get; }
  • public ArrayPooledMemoryStream()
• public sealed class AsyncCache<TKey, TValue> : IDisposable
  • public AsyncCache(Func<TKey, CancellationToken, Task<TValue>> valueFactory)
  • public void Dispose()
  • public Task<TValue> GetOrAddAsync(TKey key, CancellationToken cancellationToken = default)
• public sealed class AsyncCountdownEvent : IDisposable
  • public AsyncCountdownEvent()
  • public void Decrement()
  • public void Dispose()
  • public void Increment()
  • public void Wait()
• public struct AsyncLock : IDisposable
  • public struct Releaser : IDisposable
  • public AsyncLock()
  • public Releaser Acquire(CancellationToken cancellationToken = default)
  • public Task<Releaser> AcquireAsync(CancellationToken cancellationToken = default)
  • public void Dispose()
• public sealed class AsyncQueue<T> : IDisposable
  • public int Count { get; }
  • public AsyncQueue()
  • public AsyncQueue(IEnumerable<T> collection)
  • public Task<T> DequeueAsync(CancellationToken cancellationToken = default)
  • public void Dispose()
  • public void Enqueue(T element)
  • public bool TryDequeue(out T element)
• public struct AwaitableDisposable<T> where T : IDisposable
  • public AwaitableDisposable(Task<T> task)
  • public static Task<T> op_Implicit(AwaitableDisposable<T> source)
  • public Task<T> AsTask()
  • public ConfiguredTaskAwaitable<T> ConfigureAwait(bool continueOnCapturedContext)
  • public TaskAwaiter<T> GetAwaiter()
• public static class AwaitableDisposableExtensions
  • public static AwaitableDisposable<T> ToAwaitableDisposable<T>(this Task<T> source) where T : IDisposable
• public static class CancellationTokenExtensions
  • public struct ValueCancellationTokenSource : IDisposable
  • public static ValueCancellationTokenSource WithTimeout(this CancellationToken cancellationToken, TimeSpan timeout)
• public static class ConcurrentDictionaryExtensions
  • public static void ClearAndDispose<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> source) where TValue : IDisposable
  • public static void ClearAndDispose<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> source, Action<TValue> dispose)
  • public static void Remove<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> source, TKey key)
• public static class DictionaryExtensions
  • public static string Stringify(this IDictionary<string, object> source)
  • public static void UnionWith(this IDictionary<string, object> source, IDictionary<string, object> addendum)
• public static class DisposableAction
  • public static DisposableAction<TState> Create<TState>(Action<TState> action, TState state)
• public struct DisposableAction<TState> : IDisposable
  • public DisposableAction(Action<TState> action, TState state)
  • public void Dispose()
• public static class EnumerableExtensions
  • public static IEnumerable<T> Intersperse<T>(this IEnumerable<T> items, T separator)
  • public static IEnumerable<T> SurroundWith<T>(this IEnumerable<T> items, T first, T last)
• public class NoResult : IEquatable<NoResult>
  • public static readonly NoResult Instance
  • protected virtual Type EqualityContract { get; }
  • protected NoResult(NoResult original)
  • public static bool op_Equality(NoResult left, NoResult right)
  • public static bool op_Inequality(NoResult left, NoResult right)
  • public virtual NoResult <Clone>$()
  • public virtual bool Equals(NoResult other)
  • protected virtual bool PrintMembers(StringBuilder builder)
• public sealed class ReadOnlyMemoryStream : Stream
  • public ReadOnlyMemoryStream(ref ReadOnlyMemory content)
• public static class ReflectionHelpers
  • public static TAttribute GetAttribute<TAttribute>(this Type type) where TAttribute : Attribute
  • public static IEnumerable<TAttribute> GetAttributes<TAttribute>(this Type type) where TAttribute : Attribute
• public static class StringExtensions
  • public static string Trim(this string s, int start, int length)
• public static class TaskHelpers
  • public static void AttachCancellation<T>(this TaskCompletionSource<T> taskCompletionSource, CancellationToken cancellationToken)
  • public static Func<T1, T2, T3, CancellationToken, Task> FromAction<T1, T2, T3>(Action<T1, T2, T3, CancellationToken> action)
  • public static Func<T1, T2, CancellationToken, Task> FromAction<T1, T2>(Action<T1, T2, CancellationToken> action)
  • public static Func<T1, CancellationToken, Task> FromAction<T1>(Action<T1, CancellationToken> action)
  • public static Func<T1, CancellationToken, Task<T2>> FromFunc<T1, T2>(Func<T1, CancellationToken, T2> func)
• public static class Timers
  • public static IDisposable Start(Action callback, TimeSpan dueTime, TimeSpan period, ILogger logger)
• public static class UriExtensions
  • public static Dictionary<string, string> ParseQuery(this Uri uri)

EasyNetQ.Loggers

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

EasyNetQ.Logging

• public class ConsoleLogger : ILogger
  • public ConsoleLogger()
  • public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception = null, object[] formatParameters)
• public class ConsoleLogger<TCategoryName> : ConsoleLogger, ILogger<TCategoryName>, ILogger
  • public ConsoleLogger()
• public interface ILogger
  • bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception = null, object[] formatParameters)
• public interface ILogger<TCategoryName> : ILogger
• public static class LoggerExtensions
  • public static void Debug(this ILogger logger, Func<string> messageFunc)
  • public static void Debug(this ILogger logger, string message)
  • public static void Debug(this ILogger logger, string message, object[] args)
  • public static void Debug(this ILogger logger, Exception exception, string message, object[] args)
  • public static void DebugException(this ILogger logger, string message, Exception exception)
  • public static void DebugException(this ILogger logger, string message, Exception exception, object[] args)
  • public static void DebugFormat(this ILogger logger, string message, object[] args)
  • public static void Error(this ILogger logger, Func<string> messageFunc)
  • public static void Error(this ILogger logger, string message)
  • public static void Error(this ILogger logger, string message, object[] args)
  • public static void Error(this ILogger logger, Exception exception, string message, object[] args)
  • public static void ErrorException(this ILogger logger, string message, Exception exception, object[] args)
  • public static void ErrorFormat(this ILogger logger, string message, object[] args)
  • public static void Fatal(this ILogger logger, Func<string> messageFunc)
  • public static void Fatal(this ILogger logger, string message)
  • public static void Fatal(this ILogger logger, string message, object[] args)
  • public static void Fatal(this ILogger logger, Exception exception, string message, object[] args)
  • public static void FatalException(this ILogger logger, string message, Exception exception, object[] args)
  • public static void FatalFormat(this ILogger logger, string message, object[] args)
  • public static void Info(this ILogger logger, Func<string> messageFunc)
  • public static void Info(this ILogger logger, string message)
  • public static void Info(this ILogger logger, string message, object[] args)
  • public static void Info(this ILogger logger, Exception exception, string message, object[] args)
  • public static void InfoException(this ILogger logger, string message, Exception exception, object[] args)
  • public static void InfoFormat(this ILogger logger, string message, object[] args)
  • public static bool IsDebugEnabled(this ILogger logger)
  • public static bool IsErrorEnabled(this ILogger logger)
  • public static bool IsFatalEnabled(this ILogger logger)
  • public static bool IsInfoEnabled(this ILogger logger)
  • public static bool IsTraceEnabled(this ILogger logger)
  • public static bool IsWarnEnabled(this ILogger logger)
  • public static void Trace(this ILogger logger, Func<string> messageFunc)
  • public static void Trace(this ILogger logger, string message)
  • public static void Trace(this ILogger logger, string message, object[] args)
  • public static void Trace(this ILogger logger, Exception exception, string message, object[] args)
  • public static void TraceException(this ILogger logger, string message, Exception exception, object[] args)
  • public static void TraceFormat(this ILogger logger, string message, object[] args)
  • public static void Warn(this ILogger logger, Func<string> messageFunc)
  • public static void Warn(this ILogger logger, string message)
  • public static void Warn(this ILogger logger, string message, object[] args)
  • public static void Warn(this ILogger logger, Exception exception, string message, object[] args)
  • public static void WarnException(this ILogger logger, string message, Exception exception, object[] args)
  • public static void WarnFormat(this ILogger logger, string message, object[] args)
• public enum LogLevel
  • Debug = 1
  • Error = 4
  • Fatal = 5
  • Info = 2
  • Trace = 0
  • Warn = 3
• public class NoopLogger : ILogger
  • public NoopLogger()
  • public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception = null, object[] formatParameters)
• public class NoopLogger<TCategoryName> : ILogger<TCategoryName>, ILogger
  • public NoopLogger()
  • public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception = null, object[] formatParameters)

EasyNetQ.MessageVersioning

• public class MessageType
• public class MessageTypeProperty
  • public MessageType GetMessageType()
  • public Type GetMessageType()
• public static class MessageVersioningExtensions
• public class VersionedExchangeDeclareStrategy : IExchangeDeclareStrategy
  • public VersionedExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
  • public Task<Exchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken)
  • public Task<Exchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken)
• public class VersionedMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage<T> DeserializeMessage<T>(MessageProperties properties, byte[] body)
  • public IMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • public IMessage DeserializeMessage(MessageProperties properties, ref ReadOnlyMemory body)
• public class VersionedPublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy

EasyNetQ.MultipleExchange

• public class MultipleExchangeDeclareStrategy : IExchangeDeclareStrategy
  • public MultipleExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
  • public Task<Exchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken)
  • public Task<Exchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken)

EasyNetQ.NonGeneric

• public static class NonGenericExtensions

EasyNetQ.Persistent

• public struct ActionBasedPersistentChannelAction : IPersistentChannelAction<NoResult>
  • public ActionBasedPersistentChannelAction(Action<IModel> action)
  • public NoResult Invoke(IModel model)
• public struct FuncBasedPersistentChannelAction<TResult> : IPersistentChannelAction<TResult>
  • public FuncBasedPersistentChannelAction(Func<IModel, TResult> func)
  • public TResult Invoke(IModel model)
• public interface IPersistentChannel : IDisposable
  • Task<TResult> InvokeChannelActionAsync<TResult, TChannelAction>(TChannelAction channelAction, CancellationToken cancellationToken = default) where TChannelAction : struct, IPersistentChannelAction<TResult>
• public interface IPersistentChannelAction<TResult>
  • TResult Invoke(IModel model)
• public interface IPersistentChannelFactory
  • IPersistentChannel CreatePersistentChannel(IPersistentConnection connection, PersistentChannelOptions options)
• public interface IPersistentConnection : IDisposable
  • bool IsConnected { get; }
  • void Connect()
  • IModel CreateModel()
• public class PersistentChannel : IPersistentChannel, IDisposable
  • public PersistentChannel(ref PersistentChannelOptions options, IPersistentConnection connection, IEventBus eventBus)
  • public PersistentChannel(ref PersistentChannelOptions options, IPersistentConnection connection, IEventBus eventBus, ILogger<PersistentChannel> logger)
  • public void Dispose()
  • public Task<TResult> InvokeChannelActionAsync<TResult, TChannelAction>(TChannelAction channelAction, CancellationToken cancellationToken = default) where TChannelAction : struct, IPersistentChannelAction<TResult>
• public class PersistentChannelFactory : IPersistentChannelFactory
  • public PersistentChannelFactory(IEventBus eventBus)
  • public PersistentChannelFactory(IEventBus eventBus, ILogger<PersistentChannel> logger)
  • public IPersistentChannel CreatePersistentChannel(IPersistentConnection connection, PersistentChannelOptions options)
• public struct PersistentChannelOptions
  • public bool PublisherConfirms { get; }
  • public PersistentChannelOptions(bool publisherConfirms)
• public class PersistentConnection : IPersistentConnection, IDisposable
  • public bool IsConnected { get; }
  • public PersistentConnection(PersistentConnectionType type, ILogger<IPersistentConnection> logger, ConnectionConfiguration configuration, IConnectionFactory connectionFactory, IEventBus eventBus)
  • public void Connect()
  • public IModel CreateModel()
  • public void Dispose()
• public enum PersistentConnectionType
  • Consumer = 1
  • Producer = 0

EasyNetQ.Producer

• public class ClientCommandDispatcher : IClientCommandDispatcher, IDisposable
• public class ClientCommandDispatcherFactory : IClientCommandDispatcherFactory
• public class ClientCommandDispatcherSingleton : IClientCommandDispatcher, IDisposable
• public interface IClientCommandDispatcher : IDisposable
• public interface IClientCommandDispatcherFactory
• public interface IPersistentChannel : IDisposable
• public interface IPersistentChannelFactory
• public interface IPublisher
• public interface IPublishExchangeDeclareStrategy
• public interface IResponderConfiguration
• public interface IRpc
• public interface ISendReceive
• public class PersistentChannel : IPersistentChannel, IDisposable
• public class PersistentChannelFactory : IPersistentChannelFactory
• public abstract class PublisherBase : IPublisher
• public class PublisherBasic : PublisherBase
• public class PublisherConfirms : PublisherBase
• public static class PublisherFactory
• public class PublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
• public class DefaultExchangeDeclareStrategy : IExchangeDeclareStrategy
  • public DefaultExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
  • public Task<Exchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken)
  • public Task<Exchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken)
• public interface IExchangeDeclareStrategy
  • Task<Exchange> DeclareExchangeAsync(string exchangeName, string exchangeType, CancellationToken cancellationToken = default)
  • Task<Exchange> DeclareExchangeAsync(Type messageType, string exchangeType, CancellationToken cancellationToken = default)
• public interface IProducerConnection : IPersistentConnection, IDisposable
• public interface IPublishConfirmationListener : IDisposable
  • IPublishPendingConfirmation CreatePendingConfirmation(IModel model)
• public interface IPublishPendingConfirmation
  • ulong Id { get; }
  • void Cancel()
  • Task WaitAsync(CancellationToken cancellationToken = default)
• public class ProducerConnection : PersistentConnection, IProducerConnection, IPersistentConnection, IDisposable
  • public ProducerConnection(ILogger<ProducerConnection> logger, ConnectionConfiguration configuration, IConnectionFactory connectionFactory, IEventBus eventBus)
• public class PublishConfirmationListener : IPublishConfirmationListener, IDisposable
  • public PublishConfirmationListener(IEventBus eventBus)
  • public IPublishPendingConfirmation CreatePendingConfirmation(IModel model)
  • public void Dispose()
• public class PublishInterruptedException : Exception
  • public PublishInterruptedException()
  • public PublishInterruptedException(string message)
  • public PublishInterruptedException(string message, Exception inner)
  • protected PublishInterruptedException(SerializationInfo info, StreamingContext context)
• public class ResponderConfiguration : IResponderConfiguration
• public class Rpc : IRpc
• public class SendReceive : ISendReceive
• public class PublishReturnedException : Exception
  • public PublishReturnedException()
  • public PublishReturnedException(string message)
  • public PublishReturnedException(string message, Exception inner)
  • protected PublishReturnedException(SerializationInfo info, StreamingContext context)

EasyNetQ.SystemMessages

• public class Error
  • public string Queue { get; set; }
• public class ScheduleMe
• public class UnscheduleMe

EasyNetQ.Topology

• public class Binding : IBinding
• public struct Binding<TBindable> where TBindable : struct, IBindable
  • public IDictionary<string, object> Arguments { get; }
  • public TBindable Destination { get; }
  • public string RoutingKey { get; }
  • public Exchange Source { get; }
  • public Binding(ref Exchange source, ref TBindable destination, string routingKey, IDictionary<string, object> arguments = null)
• public struct Exchange : IBindable
  • public static Exchange Default { get; }
  • public IDictionary<string, object> Arguments { get; }
  • public bool IsAutoDelete { get; }
  • public bool IsDurable { get; }
  • public Exchange(string name)
  • public static IExchange GetDefault()
  • public string Type { get; }
  • public Exchange(string name, string type = "direct", bool durable = true, bool autoDelete = false, IDictionary<string, object> arguments = null)
• public interface IBindable
  • string Name { get; }
• public interface IBinding
• public interface IExchange : IBindable
• public interface IQueue : IBindable
• public struct Queue : IBindable
  • public IDictionary<string, object> Arguments { get; }
  • public bool IsAutoDelete { get; }
  • public bool IsDurable { get; }
  • public Queue(string name, bool isExclusive)
  • public Queue(string name, bool isDurable = true, bool isExclusive = false, bool isAutoDelete = false, IDictionary<string, object> arguments = null)

Sprache

• public interface IFailure<T> : IResult<T>
• public class Input
• public interface IResult<T>
• public interface ISuccess<T> : IResult<T>
• public static class Parse
• public class ParseException : Exception
• public sealed delegate Parser<T> : MulticastDelegate
• public static class ParserExtensions