EasyNetQ by Mike Hadlow, Chris Edwards, A Hazelwood

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

---

API Diff between 0.33.2.277 and 8.0.0-beta94

730 Additions 388 Removals

EasyNetQ

• public class AdvancedBusEventHandlers
• public static class AdvancedBusExtensions
• public static class Argument
• public static class ArgumentsExtensions
• public class BlockedEventArgs : EventArgs
• public class ConnectedEventArgs : EventArgs
• public static class BusExtensions
  • public static void CancelFuturePublish(this IBus bus, string cancellationKey)
  • public static Task CancelFuturePublishAsync(this IBus bus, string cancellationKey)
  • public static void FuturePublish<T>(this IBus bus, DateTime futurePublishDate, T message)
  • public static void FuturePublish<T>(this IBus bus, DateTime futurePublishDate, string cancellationKey, T message)
  • public static Task FuturePublishAsync<T>(this IBus bus, DateTime futurePublishDate, T message)
  • public static Task FuturePublishAsync<T>(this IBus bus, DateTime futurePublishDate, string cancellationKey, T message)
• public sealed delegate CancelSubscription : MulticastDelegate
  • public CancelSubscription(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke()
• public class ComponentRegistration
  • public ComponentRegistration()
  • public static void RegisterServices(IContainer container)
• public class ConnectionConfiguration : IConnectionConfiguration
  • public const int DefaultAmqpsPort = 5671
  • public const int DefaultPort = 5672
  • public IList<IAuthMechanismFactory> AuthMechanisms { get; set; }
  • public Uri AMQPConnectionString { get; set; }
  • public bool CancelOnHaFailover { 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 IEnumerable<IHostConfiguration> Hosts { get; set; }
  • public ushort RequestedChannelMax { get; set; }
  • public TimeSpan RequestedHeartbeat { get; set; }
  • public ushort RequestedHeartbeat { get; set; }
  • public TimeSpan Timeout { get; set; }
  • public ushort Timeout { get; set; }
  • public void Validate()
• public class ConnectionFactoryInfo
  • public ConnectionFactory ConnectionFactory { get; }
  • public IHostConfiguration HostConfiguration { get; }
  • public ConnectionFactoryInfo(ConnectionFactory connectionFactory, IHostConfiguration hostConfiguration)
• public class ConnectionFactoryWrapper : IConnectionFactory
  • public virtual IConnectionConfiguration Configuration { get; }
  • public virtual IHostConfiguration CurrentHost { get; }
  • public virtual bool Succeeded { get; }
  • public ConnectionFactoryWrapper(IConnectionConfiguration connectionConfiguration, IClusterHostSelectionStrategy<ConnectionFactoryInfo> clusterHostSelectionStrategy)
  • public virtual IConnection CreateConnection()
  • public virtual bool Next()
  • public virtual void Reset()
  • public virtual void Success()
• public static class ConsumeConfigurationExtensions
• public struct ConsumedMessage : IEquatable<ConsumedMessage>
• public class Conventions : IConventions
  • public ErrorExchangeRoutingKeyConvention ErrorExchangeRoutingKeyConvention { get; set; }
  • public ErrorExchangeTypeConvention ErrorExchangeTypeConvention { get; set; }
  • public ErrorQueueTypeConvention ErrorQueueTypeConvention { get; set; }
  • public QueueTypeConvention QueueTypeConvention { get; set; }
  • public RpcExchangeNameConvention RpcRequestExchangeNamingConvention { get; set; }
  • public RpcExchangeNameConvention RpcResponseExchangeNamingConvention { get; set; }
  • public RpcExchangeNameConvention RpcExchangeNamingConvention { get; set; }
• public class DeadLetterExchangeAndMessageTtlScheduler : IScheduler
• public static class DeadLetterStrategy
• public class DefaultClusterHostSelectionStrategy<T> : IClusterHostSelectionStrategy<T>, IEnumerable<T>, IEnumerable
  • public virtual bool Succeeded { get; }
  • public DefaultClusterHostSelectionStrategy()
  • public virtual void Add(T item)
  • public virtual T Current()
  • public virtual IEnumerator<T> GetEnumerator()
  • public virtual bool Next()
  • public virtual void Reset()
  • public virtual void Success()
• public class DefaultExchangeDeclareStrategy : IExchangeDeclareStrategy
• public class DefaultMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage DeserializeMessage(ref MessageProperties properties, ref ReadOnlyMemory body)
  • public SerializedMessage SerializeMessage(IMessage message)
  • public DeserializedMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • public SerializedMessage SerializeMessage<T>(IMessage<T> message)
• public class DefaultPubSub : IPubSub
• public class DefaultRpc : IRpc, IDisposable
• public class DefaultSendReceive : ISendReceive
• public class DefaultTypeNameSerializer : ITypeNameSerializer
• public static class DelayedExchangeExtensions
• public class DelayedExchangeScheduler : IScheduler
• public class DeliveryModeAttribute : Attribute
• public class DisconnectedEventArgs : EventArgs
• public class DefaultServiceProvider : IContainer, IServiceProvider, IServiceRegister
  • public DefaultServiceProvider()
  • public virtual IServiceRegister Register<TService>(Func<IServiceProvider, TService> serviceCreator)
  • public IServiceRegister Register<TService, TImplementation>() where TImplementation : TService
  • public virtual TService Resolve<TService>()
  • public object Resolve(Type serviceType)
• public class DeserializedMessage
  • public object Message { get; }
  • public Type MessageType { get; }
  • public DeserializedMessage(Type messageType, object message)
• public class EasyNetQException : Exception
  • public EasyNetQException(string format, object[] args)
  • public EasyNetQException(string format, string[] args)
• public class EasyNetQInvalidMessageTypeException : EasyNetQException
  • public EasyNetQInvalidMessageTypeException()
  • public EasyNetQInvalidMessageTypeException(string message)
  • public EasyNetQInvalidMessageTypeException(string format, string[] args)
  • public EasyNetQInvalidMessageTypeException(string message, Exception inner)
  • protected EasyNetQInvalidMessageTypeException(SerializationInfo info, StreamingContext context)
• public class EasyNetQResponderException : EasyNetQException
  • public EasyNetQResponderException(string format, object[] args)
  • public EasyNetQResponderException(string format, string[] args)
• public sealed delegate ErrorExchangeRoutingKeyConvention : MulticastDelegate
• public sealed delegate ErrorExchangeTypeConvention : MulticastDelegate
• public sealed delegate ErrorQueueNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(MessageReceivedInfo receivedInfo, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual string Invoke(MessageReceivedInfo receivedInfo)
  • public virtual string Invoke()
• public sealed delegate ErrorQueueTypeConvention : MulticastDelegate
• public class EventBus : IEventBus
  • public EventBus(ILogger<EventBus> logger)
  • public void Publish<TEvent>(ref TEvent event) where TEvent : struct
  • public IDisposable Subscribe<TEvent>(TEventHandler<TEvent> eventHandler) where TEvent : struct
  • public EventBus()
  • public void Publish<TEvent>(TEvent event)
  • public CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
• public sealed class ExchangeAttribute : Attribute
• public static class ExchangeDeclareConfigurationExtensions
• public static class ExchangeType
• public class HostConfiguration : IHostConfiguration
  • public SslOption Ssl { get; }
  • public HostConfiguration(string host, ushort port)
  • public HostConfiguration()
• public interface IAdvancedBus : IDisposable
  • IContainer Container { get; }
  • event EventHandler<BlockedEventArgs> Blocked
  • event EventHandler<ConnectedEventArgs> Connected
  • event EventHandler<DisconnectedEventArgs> Disconnected
  • event EventHandler<MessageReturnedEventArgs> MessageReturned
  • event EventHandler<UnblockedEventArgs> Unblocked
  • 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 ExchangeBindAsync(string destinationExchange, string sourceExchange, string routingKey, IDictionary<string, object> arguments = null, CancellationToken cancellationToken = default)
  • Task<Exchange> ExchangeDeclareAsync(string exchange, string type = "topic", bool durable = true, bool autoDelete = false, IDictionary<string, object> arguments = null, CancellationToken cancellationToken = default)
  • Task ExchangeDeclarePassiveAsync(string exchange, CancellationToken cancellationToken = default)
  • Task ExchangeDeleteAsync(string exchange, bool ifUnused = false, CancellationToken cancellationToken = default)
  • Task ExchangeUnbindAsync(string destinationExchange, string sourceExchange, string routingKey, IDictionary<string, object> arguments = null, CancellationToken cancellationToken = default)
  • Task<QueueStats> GetQueueStatsAsync(string queue, CancellationToken cancellationToken = default)
  • Task PublishAsync(string exchange, string routingKey, bool? mandatory, bool? publisherConfirms, IMessage message, CancellationToken cancellationToken = default)
  • Task PublishAsync(string exchange, string routingKey, bool? mandatory, bool? publisherConfirms, MessageProperties properties, ReadOnlyMemory<byte> body, CancellationToken cancellationToken = default)
  • Task QueueBindAsync(string queue, string exchange, string routingKey, IDictionary<string, object> arguments = null, CancellationToken cancellationToken = default)
  • Task<Queue> QueueDeclareAsync(string queue, bool durable = true, bool exclusive = false, bool autoDelete = false, IDictionary<string, object> arguments = null, CancellationToken cancellationToken = default)
  • Task QueueDeclarePassiveAsync(string queue, CancellationToken cancellationToken = default)
  • Task QueueDeleteAsync(string queue, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • Task QueuePurgeAsync(string queue, CancellationToken cancellationToken = default)
  • Task QueueUnbindAsync(string queue, string exchange, string routingKey, IDictionary<string, object> arguments = null, CancellationToken cancellationToken = default)
  • event Action Connected
  • event Action Disconnected
  • event Action<byte[], MessageProperties, MessageReturnedInfo> MessageReturned
  • IBinding Bind(IExchange exchange, IQueue queue, string routingKey)
  • IBinding Bind(IExchange source, IExchange destination, string routingKey)
  • void BindingDelete(IBinding binding)
  • IDisposable Consume<T>(IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage)
  • IDisposable Consume<T>(IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • IDisposable Consume(IQueue queue, Action<IHandlerRegistration> addHandlers)
  • IDisposable Consume(IQueue queue, 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)
  • void ExchangeDelete(IExchange exchange, bool ifUnused = false)
  • void Publish(IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body)
  • void Publish<T>(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage<T> message)
  • Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body)
  • Task PublishAsync<T>(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage<T> message)
  • IQueue QueueDeclare(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int perQueueTtl = 2147483647, int expires = 2147483647, string deadLetterExchange = null)
  • IQueue QueueDeclare()
  • void QueueDelete(IQueue queue, bool ifUnused = false, bool ifEmpty = false)
  • void QueuePurge(IQueue queue)
• public interface IBus : IDisposable
  • IPubSub PubSub { get; }
  • IRpc Rpc { get; }
  • IScheduler Scheduler { get; }
  • ISendReceive SendReceive { get; }
  • bool IsConnected { get; }
  • event Action Connected
  • event Action Disconnected
  • void Publish<T>(T message)
  • void Publish<T>(T message, string topic)
  • Task PublishAsync<T>(T message)
  • Task PublishAsync<T>(T message, string topic)
  • IDisposable Receive<T>(string queue, Action<T> onMessage)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • TResponse Request<TRequest, TResponse>(TRequest request)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • void Send<T>(string queue, T message)
  • IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
• public interface IConsumeConfiguration
• public interface IClusterHostSelectionStrategy<T>
  • bool Succeeded { get; }
  • void Add(T item)
  • T Current()
  • bool Next()
  • void Reset()
  • void Success()
• public interface IConnectionConfiguration
  • Uri AMQPConnectionString { get; }
  • bool CancelOnHaFailover { get; }
  • IDictionary<string, object> ClientProperties { get; }
  • IEnumerable<IHostConfiguration> Hosts { get; }
  • string Password { get; }
  • bool PersistentMessages { get; set; }
  • ushort Port { get; }
  • ushort PrefetchCount { get; }
  • bool PublisherConfirms { get; }
  • ushort RequestedHeartbeat { get; }
  • SslOption Ssl { get; }
  • ushort Timeout { get; }
  • string UserName { get; }
  • string VirtualHost { get; }
• public interface IConnectionFactory
  • IConnectionConfiguration Configuration { get; }
  • IHostConfiguration CurrentHost { get; }
  • bool Succeeded { get; }
  • IConnection CreateConnection()
  • bool Next()
  • void Reset()
  • void Success()
• public interface IContainer : IServiceProvider, IServiceRegister
• public interface IConventions
  • ErrorExchangeRoutingKeyConvention ErrorExchangeRoutingKeyConvention { get; }
  • ErrorExchangeTypeConvention ErrorExchangeTypeConvention { get; }
  • ErrorQueueTypeConvention ErrorQueueTypeConvention { get; }
  • QueueTypeConvention QueueTypeConvention { get; }
  • RpcExchangeNameConvention RpcRequestExchangeNamingConvention { get; }
  • RpcExchangeNameConvention RpcResponseExchangeNamingConvention { get; }
  • RpcExchangeNameConvention RpcExchangeNamingConvention { get; set; }
• public interface IEasyNetQLogger
  • void DebugWrite(string format, object[] args)
  • void ErrorWrite(string format, object[] args)
  • void ErrorWrite(Exception exception)
  • void InfoWrite(string format, object[] args)
• public interface IEventBus
  • void Publish<TEvent>(TEvent& modreq(System.Runtime.InteropServices.InAttribute) event) where TEvent : struct
  • IDisposable Subscribe<TEvent>(TEventHandler<TEvent> eventHandler) where TEvent : struct
  • void Publish<TEvent>(TEvent event)
  • CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
• public interface IExchangeDeclareConfiguration
• public interface IExchangeDeclareStrategy
• public interface IFuturePublishConfiguration
• public interface IMessage
• public interface IHostConfiguration
  • string Host { get; }
  • ushort Port { get; }
• public interface IMessage<T>
  • MessageProperties Properties { get; }
• public interface IMessageDeliveryModeStrategy
• public interface IMessageSerializationStrategy
  • IMessage DeserializeMessage(MessageProperties& modreq(System.Runtime.InteropServices.InAttribute) properties, ReadOnlyMemory body)
  • SerializedMessage SerializeMessage(IMessage message)
  • DeserializedMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • SerializedMessage SerializeMessage<T>(IMessage<T> message)
• public interface IPerQueueConsumeConfiguration
• public interface IPublishConfiguration
• public interface IPubSub
• public interface IPullingConsumer<TPullResult> : IDisposable where TPullResult : IPullResult
• public interface IPullingConsumerFactory
• public interface IPullResult : IDisposable
• public interface IQueueDeclareConfiguration
• public interface IReceiveConfiguration
• public interface IReceiveRegistration
• public interface IRequestConfiguration
• public interface IResponderConfiguration
• public interface IRpc
• public interface IScheduler
• public interface ISendConfiguration
• public interface ISendReceive
• public interface IPersistentConnection : IDisposable
  • bool IsConnected { get; }
  • IModel CreateModel()
• public interface ISaga
  • void Initialize(IBus bus)
• public interface ISerializer
  • object BytesToMessage(Type messageType, ReadOnlyMemory bytes)
  • IMemoryOwner<byte> MessageToBytes(Type messageType, object message)
  • T BytesToMessage<T>(byte[] bytes)
  • object BytesToMessage(string typeName, byte[] bytes)
  • byte[] MessageToBytes<T>(T message)
• public interface ISimpleConsumeConfiguration
• public interface ISubscriptionConfiguration
• public interface IServiceProvider
  • TService Resolve<TService>()
• public interface IServiceRegister
  • IServiceRegister Register<TService>(Func<IServiceProvider, TService> serviceCreator)
  • IServiceRegister Register<TService, TImplementation>() where TImplementation : TService
• public interface ITypeNameSerializer
  • Type Deserialize(string typeName)
  • Type DeSerialize(string typeName)
• public class JsonSerializer : ISerializer
  • public JsonSerializer(object serializerSettings = null)
  • public object BytesToMessage(Type messageType, ref ReadOnlyMemory bytes)
  • public IMemoryOwner<byte> MessageToBytes(Type messageType, object message)
  • public JsonSerializer(ITypeNameSerializer typeNameSerializer)
  • public T BytesToMessage<T>(byte[] bytes)
  • public object BytesToMessage(string typeName, byte[] bytes)
  • public byte[] MessageToBytes<T>(T message)
• public class LegacyRpcConventions : Conventions
• public class LegacyTypeNameSerializer : ITypeNameSerializer
• public static class LinqExtensions
  • public static IEnumerable<T> AtLeastOneWithDefault<T>(this IEnumerable<T> items, T default)
  • public static IEnumerable<KeyValuePair<string, string>> EnumerateDictionary(this IDictionary<string, object> dictionary)
  • public static IEnumerable<T> Intersperse<T>(this IEnumerable<T> items, T separator)
  • public static void Shuffle<T>(this IList<T> list)
  • public static IEnumerable<T> SurroundWith<T>(this IEnumerable<T> items, T first, T last)
• public static class Message
  • public static object CreateInstance(Type messageType, object body)
• public class Message<T> : IMessage<T>
  • public Type MessageType { get; }
  • public Message()
  • public Message(T body, ref MessageProperties properties)
  • public object GetBody()
  • public void SetProperties(MessageProperties properties)
• public static class MessageDeliveryMode
• public class MessageDeliveryModeStrategy : IMessageDeliveryModeStrategy
• public static class MessageFactory
• public class MessageProperties
  • public static MessageProperties Empty { get; }
  • public TimeSpan? Expiration { get; set; }
  • public string Expiration { get; set; }
  • public static bool op_Equality(MessageProperties left, MessageProperties right)
  • public static bool op_Inequality(MessageProperties left, MessageProperties right)
  • public bool Equals(MessageProperties other)
  • public MessageProperties()
  • public MessageProperties(IBasicProperties basicProperties)
  • public void AppendPropertyDebugStringTo(StringBuilder stringBuilder)
  • public void CopyFrom(IBasicProperties basicProperties)
  • public void CopyTo(IBasicProperties basicProperties)
• public static class MessagePropertiesExtensions
• public class MessageReceivedInfo
  • public ulong DeliveryTag { get; set; }
  • public ulong DeliverTag { get; set; }
  • public MessageReceivedInfo()
  • public static bool op_Equality(MessageReceivedInfo left, MessageReceivedInfo right)
  • public static bool op_Inequality(MessageReceivedInfo left, MessageReceivedInfo right)
  • public void Deconstruct(out string ConsumerTag, out ulong DeliveryTag, out bool Redelivered, out string Exchange, out string RoutingKey, out string Queue)
  • public bool Equals(MessageReceivedInfo other)
• public class MessageReturnedEventArgs : EventArgs
• public static class NonGenericPubSubExtensions
• public static class NonGenericRpcExtensions
• public static class NonGenericSchedulerExtensions
• public static class NonGenericSendReceiveExtensions
• public static class OverflowType
• public static class PerQueueConsumeConfigurationExtensions
• public struct ProducedMessage : IEquatable<ProducedMessage>
• public class PersistentConnection : IPersistentConnection, IDisposable
  • public bool IsConnected { get; }
  • public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger, IEventBus eventBus)
  • public IModel CreateModel()
  • public void Dispose()
  • public void OnConnected()
  • public void OnDisconnected()
• public static class PubSubExtensions
• public struct PullBatchResult<TPullResult> : IDisposable where TPullResult : IPullResult
• public class PullingConsumer : IPullingConsumer<PullResult>, IDisposable
• public class PullingConsumer<T> : IPullingConsumer<PullResult<T>>, IDisposable
• public static class PullingConsumerExtensions
• public class PullingConsumerFactory : IPullingConsumerFactory
• public struct PullingConsumerOptions
• public struct PullResult : IPullResult, IDisposable
• public struct PullResult<T> : IPullResult, IDisposable
• public class QueueAttribute : Attribute
  • public string Name { get; set; }
  • public string Type { get; set; }
  • public QueueAttribute()
  • public string ExchangeName { get; set; }
  • public string QueueName { get; }
  • public QueueAttribute(string queueName)
• public static class QueueDeclareConfigurationExtensions
• public static class QueueMasterLocator
• public static class QueueMode
• public struct QueueStats
• public static class QueueType
• public sealed delegate QueueTypeConvention : MulticastDelegate
• public class RabbitAdvancedBus : IAdvancedBus, IDisposable
  • public IContainer Container { get; }
  • public event EventHandler<BlockedEventArgs> Blocked
  • public event EventHandler<ConnectedEventArgs> Connected
  • public event EventHandler<DisconnectedEventArgs> Disconnected
  • public event EventHandler<MessageReturnedEventArgs> MessageReturned
  • public event EventHandler<UnblockedEventArgs> Unblocked
  • public RabbitAdvancedBus(ILogger<RabbitAdvancedBus> logger, IProducerConnection producerConnection, IConsumerConnection consumerConnection, IConsumerFactory consumerFactory, IPersistentChannelDispatcher persistentChannelDispatcher, IPublishConfirmationListener confirmationListener, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, ConnectionConfiguration configuration, ProducePipelineBuilder producePipelineBuilder, ConsumePipelineBuilder consumePipelineBuilder, IServiceResolver serviceResolver, IMessageSerializationStrategy messageSerializationStrategy, IPullingConsumerFactory pullingConsumerFactory, AdvancedBusEventHandlers advancedBusEventHandlers)
  • 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 event Action Connected
  • public event Action Disconnected
  • public event Action<byte[], MessageProperties, MessageReturnedInfo> MessageReturned
  • public RabbitAdvancedBus(IConnectionFactory connectionFactory, IConsumerFactory consumerFactory, IEasyNetQLogger logger, IClientCommandDispatcherFactory clientCommandDispatcherFactory, IPublisher publisher, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, IContainer container, IConnectionConfiguration connectionConfiguration, IMessageSerializationStrategy messageSerializationStrategy)
  • public virtual IBinding Bind(IExchange exchange, IQueue queue, string routingKey)
  • public virtual IBinding Bind(IExchange source, IExchange destination, string routingKey)
  • public virtual void BindingDelete(IBinding binding)
  • public IDisposable Consume<T>(IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage)
  • public IDisposable Consume<T>(IQueue queue, Action<IMessage<T>, MessageReceivedInfo> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • public IDisposable Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage, Action<IConsumerConfiguration> configure)
  • public virtual IDisposable Consume(IQueue queue, Action<IHandlerRegistration> addHandlers)
  • public 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 virtual Task ExchangeBindAsync(string destinationExchange, string sourceExchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public Task<Exchange> ExchangeDeclareAsync(string exchange, string type, bool durable, bool autoDelete, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public Task ExchangeDeclarePassiveAsync(string exchange, CancellationToken cancellationToken = default)
  • public virtual Task ExchangeDeleteAsync(string 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 queue, CancellationToken cancellationToken)
  • public virtual Task PublishAsync(string exchange, string routingKey, bool? mandatory, bool? publisherConfirms, IMessage message, CancellationToken cancellationToken)
  • public virtual Task PublishAsync(string exchange, string routingKey, bool? mandatory, bool? publisherConfirms, MessageProperties properties, ReadOnlyMemory<byte> body, CancellationToken cancellationToken)
  • public virtual Task QueueBindAsync(string queue, string exchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public Task<Queue> QueueDeclareAsync(string queue, bool durable, bool exclusive, bool autoDelete, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public Task QueueDeclarePassiveAsync(string queue, CancellationToken cancellationToken = default)
  • public virtual Task QueueDeleteAsync(string queue, bool ifUnused = false, bool ifEmpty = false, CancellationToken cancellationToken = default)
  • public virtual Task QueuePurgeAsync(string queue, CancellationToken cancellationToken)
  • public virtual Task QueueUnbindAsync(string queue, string exchange, string routingKey, IDictionary<string, object> arguments, CancellationToken cancellationToken)
  • public virtual IExchange ExchangeDeclare(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = false, string alternateExchange = null)
  • public virtual void ExchangeDelete(IExchange exchange, bool ifUnused = false)
  • protected void OnConnected()
  • protected void OnDisconnected()
  • protected void OnMessageReturned(ReturnedMessageEvent args)
  • public void Publish(IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body)
  • public void Publish<T>(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage<T> message)
  • public virtual Task PublishAsync(IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body)
  • public virtual Task PublishAsync<T>(IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage<T> message)
  • public virtual IQueue QueueDeclare(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, int perQueueTtl = 2147483647, int expires = 2147483647, string deadLetterExchange = null)
  • public virtual IQueue QueueDeclare()
  • public virtual void QueueDelete(IQueue queue, bool ifUnused = false, bool ifEmpty = false)
  • public virtual void QueuePurge(IQueue queue)
• public class RabbitBus : IBus, IDisposable
  • public IPubSub PubSub { get; }
  • public IRpc Rpc { get; }
  • public IScheduler Scheduler { get; }
  • public ISendReceive SendReceive { get; }
  • public RabbitBus(IAdvancedBus advanced, IPubSub pubSub, IRpc rpc, ISendReceive sendReceive, IScheduler scheduler)
  • public IConventions Conventions { get; }
  • public virtual bool IsConnected { get; }
  • public IEasyNetQLogger Logger { get; }
  • public event Action Connected
  • public event Action Disconnected
  • public RabbitBus(IEasyNetQLogger logger, IConventions conventions, IAdvancedBus advancedBus, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IRpc rpc, ISendReceive sendReceive, IConnectionConfiguration connectionConfiguration)
  • public virtual void Dispose()
  • protected void OnConnected()
  • protected void OnDisconnected()
  • public virtual void Publish<T>(T message)
  • public virtual void Publish<T>(T message, string topic)
  • public virtual Task PublishAsync<T>(T message)
  • public virtual Task PublishAsync<T>(T message, string topic)
  • public virtual IDisposable Receive<T>(string queue, Action<T> onMessage)
  • public virtual IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • public virtual IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • public virtual TResponse Request<TRequest, TResponse>(TRequest request)
  • public virtual Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • public virtual IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • public virtual IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • public virtual void Send<T>(string queue, T message)
  • public virtual IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • public virtual IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • public virtual IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • public virtual IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
• public static class RabbitBusExtensions
  • public static void FuturePublish<T>(this IBus bus, TimeSpan messageDelay, T message)
  • public static Task FuturePublishAsync<T>(this IBus bus, TimeSpan messageDelay, T message)
• public static class RabbitHutch
  • public static SelfHostedBus CreateBus(string connectionString)
  • public static SelfHostedBus CreateBus(string connectionString, Action<IServiceRegister> registerServices)
  • public static SelfHostedBus CreateBus(string hostName, ushort hostPort, string virtualHost, string username, string password, TimeSpan requestedHeartbeat, Action<IServiceRegister> registerServices)
  • public static SelfHostedBus CreateBus(ConnectionConfiguration connectionConfiguration, Action<IServiceRegister> registerServices)
  • public static SelfHostedBus CreateBus(Func<IServiceResolver, ConnectionConfiguration> connectionConfigurationFactory, Action<IServiceRegister> registerServices)
  • public static void RegisterBus(IServiceRegister serviceRegister, Func<IServiceResolver, ConnectionConfiguration> connectionConfigurationFactory, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string connectionString)
  • public static IBus CreateBus(string connectionString, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(string hostName, ushort hostPort, string virtualHost, string username, string password, ushort requestedHeartbeat, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus(IConnectionConfiguration connectionConfiguration, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus()
  • public static void SetContainerFactory(Func<IContainer> createContainer)
• public static class ReceiveRegistrationExtensions
• public class RandomClusterHostSelectionStrategy<T> : IClusterHostSelectionStrategy<T>, IEnumerable<T>, IEnumerable
  • public bool Succeeded { get; }
  • public RandomClusterHostSelectionStrategy()
  • public void Add(T item)
  • public T Current()
  • public virtual IEnumerator<T> GetEnumerator()
  • public bool Next()
  • public void Reset()
  • public void Success()
• public sealed delegate RpcExchangeNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(Type messageType, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual string Invoke(Type messageType)
  • public virtual string Invoke()
• public static class RpcExtensions
• public sealed delegate RpcReturnQueueNamingConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(Type messageType, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual string Invoke(Type messageType)
  • public virtual string Invoke()
• public static class SchedulerExtensions
• public sealed class SelfHostedBus : IBus, IDisposable
• public static class SendReceiveExtensions
• public class SerializedMessage
  • public ReadOnlyMemory<byte> Body { get; }
  • public byte[] Body { get; }
  • public SerializedMessage(ref MessageProperties properties, IMemoryOwner<byte> body)
  • public void Dispose()
  • public SerializedMessage(MessageProperties properties, byte[] messageBody)
• public static class ServiceRegisterExtensions
• public static class SimpleConsumeConfigurationExtensions
• public struct SubscriptionResult : IDisposable
• public sealed delegate SubsriberNameFromDelegate : MulticastDelegate
  • public SubsriberNameFromDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Delegate delegate, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(Delegate delegate)
• public sealed delegate TEventHandler<TEvent> : MulticastDelegate where TEvent : struct
• public static class TaskHelpers
  • public static Task ExecuteSynchronously(Action action)
  • public static Task FromException(Exception ex)
• public class UnblockedEventArgs : EventArgs
• public class TypeNameSerializer : ITypeNameSerializer
  • public TypeNameSerializer()
  • public Type DeSerialize(string typeName)
  • public string Serialize(Type type)

EasyNetQ.AmqpExceptions

• public class AmapExceptionPreface
  • public string Text { get; }
  • public AmapExceptionPreface(string text)
• public class AmqpException
  • public static ushort ConnectionClosed
  • public int ClassId { get; }
  • public int Code { get; }
  • public IList<IAmqpExceptionElement> Elements { get; }
  • public int MethodId { get; }
  • public AmapExceptionPreface Preface { get; }
  • public AmqpException(AmapExceptionPreface preface, IList<IAmqpExceptionElement> elements)
• public class AmqpExceptionClassIdElement : AmqpExceptionIntegerValueElement
  • public AmqpExceptionClassIdElement()
• public class AmqpExceptionCodeElement : AmqpExceptionIntegerValueElement
  • public AmqpExceptionCodeElement()
• public static class AmqpExceptionGrammar
  • public static Parser<ushort> Number
  • public static Parser<T> MakeIntegerElementParser<T>(string key) where T : AmqpExceptionIntegerValueElement
  • public static AmqpException ParseExceptionString(string exceptionMessage)
• public abstract class AmqpExceptionIntegerValueElement : IAmqpExceptionElement
  • public int Value { get; set; }
  • protected AmqpExceptionIntegerValueElement()
• public class AmqpExceptionKeyValueElement : IAmqpExceptionElement
  • public string Key { get; }
  • public string Value { get; }
  • public AmqpExceptionKeyValueElement(string key, string value)
• public class AmqpExceptionMethodIdElement : AmqpExceptionIntegerValueElement
  • public AmqpExceptionMethodIdElement()
• public interface IAmqpExceptionElement
• public class TextElement : IAmqpExceptionElement
  • public string Text { get; }
  • public TextElement(string text)

EasyNetQ.AutoSubscribe

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

EasyNetQ.ChannelDispatcher

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

EasyNetQ.ConnectionString

• public class AmqpConnectionStringParser : IConnectionStringParser
• public static class ConnectionStringGrammar
  • public static Parser<Uri> AMQP
  • public static Parser<Func<ConnectionConfiguration, ConnectionConfiguration>> AMQPAlone
  • public static Parser<bool> Bool
  • public static Parser<IEnumerable<Func<ConnectionConfiguration, ConnectionConfiguration>>> ConnectionStringBuilder
  • public static Parser<IHostConfiguration> Host
  • public static Parser<IEnumerable<IHostConfiguration>> Hosts
  • public static Parser<ushort> Number
  • public static Parser<Func<ConnectionConfiguration, ConnectionConfiguration>> Part
  • public static Parser<string> Text
  • public static Parser<Func<ConnectionConfiguration, ConnectionConfiguration>> BuildKeyValueParser<T>(string keyName, Parser<T> valueParser, Expression<Func<ConnectionConfiguration, T>> getter)
  • public static IEnumerable<T> Cons<T>(this T head, IEnumerable<T> rest)
  • public static Action<ConnectionConfiguration, T> CreateSetter<T>(Expression<Func<ConnectionConfiguration, T>> getter)
  • public static Action<TContaining, TProperty> CreateSetter<TContaining, TProperty>(Expression<Func<TContaining, TProperty>> getter)
  • public static Parser<IEnumerable<T>> ListDelimitedBy<T>(this Parser<T> parser, char delimiter)
• public class ConnectionStringParser : IConnectionStringParser
  • public ConnectionConfiguration Parse(string connectionString)
  • public IConnectionConfiguration Parse(string connectionString)
• public interface IConnectionStringParser
  • ConnectionConfiguration Parse(string connectionString)
  • IConnectionConfiguration Parse(string connectionString)

EasyNetQ.Consumer

• public static class AckStrategies
  • public static AckStrategy Nothing
• public class Base64ErrorMessageSerializer : IErrorMessageSerializer
• public struct ConsumeContext : IEquatable<ConsumeContext>
• public sealed delegate ConsumeDelegate : MulticastDelegate
• public sealed class ConsumePipelineBuilder
• public class Consumer : IConsumer, IDisposable
• public class ConsumerCancellation : IDisposable
  • public ConsumerCancellation(Action onCancellation)
  • public void Dispose()
• public class ConsumerConfiguration : IConsumerConfiguration
  • public IReadOnlyDictionary<Queue, PerQueueConsumerConfiguration> PerQueueConfigurations { get; }
  • public bool CancelOnHaFailover { get; }
  • public ConsumerConfiguration(ushort prefetchCount, IReadOnlyDictionary<Queue, PerQueueConsumerConfiguration> perQueueConfigurations)
  • public int Priority { get; }
  • public ConsumerConfiguration(ushort defaultPrefetchCount)
  • public IConsumerConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • public IConsumerConfiguration WithPrefetchCount(ushort prefetchCount)
  • public IConsumerConfiguration WithPriority(int priority)
• public sealed class ConsumerConnection : PersistentConnection, IConsumerConnection, IPersistentConnection, IDisposable
• public class ConsumerDispatcher : IConsumerDispatcher, IDisposable
  • public bool IsDisposed { get; }
  • public ConsumerDispatcher(IEasyNetQLogger logger)
  • public void Dispose()
  • public void OnDisconnected()
  • public void QueueAction(Action action)
• public class ConsumerDispatcherFactory : IConsumerDispatcherFactory, IDisposable
  • public ConsumerDispatcherFactory(IEasyNetQLogger logger)
  • public void Dispose()
  • public IConsumerDispatcher GetConsumerDispatcher()
  • public void OnDisconnected()
• public class ConsumerExecutionContext
  • public byte[] Body { get; }
  • public IBasicConsumer Consumer { get; }
  • public MessageReceivedInfo Info { get; }
  • public MessageProperties Properties { 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 class ConsumerFactory : IConsumerFactory, IDisposable
  • public ConsumerFactory(ILogger<Consumer> logger, IEventBus eventBus, IInternalConsumerFactory internalConsumerFactory)
  • public IConsumer CreateConsumer(ConsumerConfiguration configuration)
  • public ConsumerFactory(IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
• public class DefaultConsumeErrorStrategy : IConsumeErrorStrategy
• public class DefaultErrorMessageSerializer : IErrorMessageSerializer
• public class DefaultConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable
  • public DefaultConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer, IEasyNetQLogger logger, IConventions conventions, ITypeNameSerializer typeNameSerializer)
  • public virtual void Dispose()
  • public AckStrategy HandleConsumerCancelled(ConsumerExecutionContext context)
  • public virtual AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception)
• public class HandlerCollection : IHandlerCollection, IHandlerRegistration
  • public HandlerCollection()
  • public IHandlerRegistration Add<T>(IMessageHandler<T> handler)
  • public IMessageHandler GetHandler(Type messageType)
  • public HandlerCollection(IEasyNetQLogger logger)
  • public IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • public IHandlerRegistration Add<T>(Action<IMessage<T>, MessageReceivedInfo> handler)
  • public Func<IMessage<T>, MessageReceivedInfo, Task> GetHandler<T>()
  • public object GetHandler(Type messageType)
• public class HandlerCollectionFactory : IHandlerCollectionFactory
  • public HandlerCollectionFactory()
  • public IHandlerCollection CreateHandlerCollection(ref Queue queue)
  • public HandlerCollectionFactory(IEasyNetQLogger logger)
  • public IHandlerCollection CreateHandlerCollection()
• public class HandlerCollectionPerQueueFactory : IHandlerCollectionFactory
• public static class HandlerRegistrationExtensions
• public interface IConsumeErrorStrategy
• public class HandlerRunner : IHandlerRunner, IDisposable
  • public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus)
  • public void Dispose()
  • public void InvokeUserMessageHandler(ConsumerExecutionContext context)
• public interface IConsumer : IDisposable
  • Guid Id { get; }
  • void StartConsuming()
  • IDisposable StartConsuming()
• public interface IConsumerConnection : IPersistentConnection, IDisposable
• public interface IConsumerConfiguration
  • bool CancelOnHaFailover { get; }
  • ushort PrefetchCount { get; }
  • int Priority { get; }
  • IConsumerConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • IConsumerConfiguration WithPrefetchCount(ushort prefetchCount)
  • IConsumerConfiguration WithPriority(int priority)
• public interface IConsumerDispatcher : IDisposable
  • void OnDisconnected()
  • void QueueAction(Action action)
• public interface IConsumerDispatcherFactory : IDisposable
  • IConsumerDispatcher GetConsumerDispatcher()
  • void OnDisconnected()
• public interface IConsumerErrorStrategy : IDisposable
  • AckStrategy HandleConsumerCancelled(ConsumerExecutionContext context)
  • AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception)
• public interface IConsumerFactory : IDisposable
  • IConsumer CreateConsumer(ConsumerConfiguration configuration)
  • IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
• public interface IErrorMessageSerializer
• public interface IHandlerCollection : IHandlerRegistration
  • IMessageHandler GetHandler(Type messageType)
  • Func<IMessage<T>, MessageReceivedInfo, Task> GetHandler<T>()
  • object GetHandler(Type messageType)
• public interface IHandlerCollectionFactory
  • IHandlerCollection CreateHandlerCollection(Queue& modreq(System.Runtime.InteropServices.InAttribute) queue)
  • IHandlerCollection CreateHandlerCollection()
• public interface IHandlerRegistration
  • IHandlerRegistration Add<T>(IMessageHandler<T> handler)
  • bool ThrowOnNoMatchingHandler { get; set; }
  • IHandlerRegistration Add<T>(Func<IMessage<T>, MessageReceivedInfo, Task> handler)
  • IHandlerRegistration Add<T>(Action<IMessage<T>, MessageReceivedInfo> handler)
• public interface IHandlerRunner : IDisposable
  • void InvokeUserMessageHandler(ConsumerExecutionContext context)
• public interface IInternalConsumer : IDisposable
  • event EventHandler<InternalConsumerCancelledEventArgs> Cancelled
  • InternalConsumerStatus StartConsuming(bool firstStart = true)
  • void StopConsuming()
  • event Action<IInternalConsumer> Cancelled
  • void StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
• public interface IInternalConsumerFactory : IDisposable
  • IInternalConsumer CreateConsumer(ConsumerConfiguration configuration)
  • IInternalConsumer CreateConsumer()
  • void OnDisconnected()
• public sealed delegate IMessageHandler : MulticastDelegate
• public sealed delegate IMessageHandler<T> : MulticastDelegate
• public class InternalConsumer : IBasicConsumer, IInternalConsumer, IDisposable
  • public event EventHandler<InternalConsumerCancelledEventArgs> Cancelled
  • public InternalConsumer(IServiceResolver serviceResolver, ILogger<InternalConsumer> logger, ConsumerConfiguration configuration, IConsumerConnection connection, IEventBus eventBus)
  • 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, IConnectionConfiguration connectionConfiguration, IEventBus eventBus)
  • public InternalConsumerStatus StartConsuming(bool firstStart)
  • public void StopConsuming()
  • public void HandleBasicCancel(string consumerTag)
  • public void HandleBasicCancelOk(string consumerTag)
  • public void HandleBasicConsumeOk(string consumerTag)
  • public void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
  • public void HandleModelShutdown(IModel model, ShutdownEventArgs reason)
  • public void StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
• public class InternalConsumerCancelledEventArgs : EventArgs
• public class InternalConsumerFactory : IInternalConsumerFactory, IDisposable
  • public InternalConsumerFactory(IServiceResolver serviceResolver, ILogger<InternalConsumer> logger, IConsumerConnection connection, IEventBus eventBus)
  • public IInternalConsumer CreateConsumer(ConsumerConfiguration configuration)
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConventions conventions, IConnectionConfiguration connectionConfiguration, IConsumerDispatcherFactory consumerDispatcherFactory, IEventBus eventBus)
  • public IInternalConsumer CreateConsumer()
  • public void Dispose()
  • public void OnDisconnected()
• public struct InternalConsumerStatus
• public sealed delegate MessageHandler : MulticastDelegate
• public class PerQueueConsumerConfiguration
• public sealed class SimpleConsumeErrorStrategy : IConsumeErrorStrategy
• public interface IReceiveRegistration
  • IReceiveRegistration Add<T>(Func<T, Task> onMessage)
  • IReceiveRegistration Add<T>(Action<T> onMessage)
• public class PersistentConsumer : IConsumer, IDisposable
  • public PersistentConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public void Dispose()
  • public IDisposable StartConsuming()
• public class TransientConsumer : IConsumer, IDisposable
  • public TransientConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public void Dispose()
  • public IDisposable StartConsuming()

EasyNetQ.DI

• public struct AsyncServiceResolverScope : IServiceResolverScope, IServiceResolver, IDisposable, IAsyncDisposable
• public interface IServiceRegister
• public interface IServiceResolver
• public interface IServiceResolverScope : IServiceResolver, IDisposable
• public enum Lifetime
• public static class ServiceRegisterExtensions
• public class ServiceResolverScope : IServiceResolverScope, IServiceResolver, IDisposable

EasyNetQ.Events

• public class AckEvent
  • public ReadOnlyMemory<byte> Body { get; }
  • public MessageProperties Properties { get; }
  • public MessageReceivedInfo ReceivedInfo { get; }
  • public AckEvent(ref MessageReceivedInfo info, ref MessageProperties properties, ref ReadOnlyMemory body, AckResult ackResult)
  • public ConsumerExecutionContext ConsumerExecutionContext { get; }
  • public AckEvent(ConsumerExecutionContext consumerExecutionContext, AckResult ackResult)
• public enum AckResult
  • Nothing = 3
• public struct ChannelRecoveredEvent
• public struct ChannelShutdownEvent
• public struct ConnectionBlockedEvent
• public class ConnectionCreatedEvent
  • public AmqpTcpEndpoint Endpoint { get; }
  • public PersistentConnectionType Type { get; }
  • public ConnectionCreatedEvent(PersistentConnectionType type, AmqpTcpEndpoint endpoint)
  • public ConnectionCreatedEvent()
• public class ConnectionDisconnectedEvent
  • public AmqpTcpEndpoint Endpoint { get; }
  • public string Reason { get; }
  • public PersistentConnectionType Type { get; }
  • public ConnectionDisconnectedEvent(PersistentConnectionType type, AmqpTcpEndpoint endpoint, string reason)
  • public ConnectionDisconnectedEvent()
• public struct ConnectionRecoveredEvent
• public struct ConnectionUnblockedEvent
• public class ConsumerModelDisposedEvent
  • public IReadOnlyCollection<string> ConsumerTags { get; }
  • public ConsumerModelDisposedEvent(string[] consumerTags)
  • public string ConsumerTag { get; }
  • public ConsumerModelDisposedEvent(string consumerTag)
• public struct DeliveredMessageEvent
• public struct MessageConfirmationEvent
• public struct PublishedMessageEvent
• public class PublishChannelCreatedEvent
  • public IModel Channel { get; }
  • public PublishChannelCreatedEvent(IModel channel)
• public class ReturnedMessageEvent
  • public ReadOnlyMemory<byte> Body { get; }
  • public IModel Channel { get; }
  • public byte[] Body { get; set; }
  • public ReturnedMessageEvent(IModel channel, ref ReadOnlyMemory body, ref MessageProperties properties, ref MessageReturnedInfo info)
  • public ReturnedMessageEvent(byte[] body, MessageProperties properties, MessageReturnedInfo info)
• public struct StartConsumingFailedEvent
• public struct StartConsumingSucceededEvent

EasyNetQ.FluentConfiguration

• public interface ISubscriptionConfiguration
  • ISubscriptionConfiguration WithAutoDelete(bool autoDelete = true)
  • ISubscriptionConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • ISubscriptionConfiguration WithExpires(int expires)
  • ISubscriptionConfiguration WithPrefetchCount(ushort prefetchCount)
  • ISubscriptionConfiguration WithPriority(int priority)
  • ISubscriptionConfiguration WithTopic(string topic)
• public class SubscriptionConfiguration : ISubscriptionConfiguration
  • public bool AutoDelete { get; }
  • public bool CancelOnHaFailover { get; }
  • public int Expires { get; }
  • public ushort PrefetchCount { get; }
  • public int Priority { get; }
  • public IList<string> Topics { get; }
  • public SubscriptionConfiguration(ushort defaultPrefetchCount)
  • public ISubscriptionConfiguration WithAutoDelete(bool autoDelete = true)
  • public ISubscriptionConfiguration WithCancelOnHaFailover(bool cancelOnHaFailover = true)
  • public ISubscriptionConfiguration WithExpires(int expires)
  • public ISubscriptionConfiguration WithPrefetchCount(ushort prefetchCount)
  • public ISubscriptionConfiguration WithPriority(int priority)
  • public ISubscriptionConfiguration WithTopic(string topic)

EasyNetQ.Interception

• public class CompositeProduceConsumerInterceptor : IProduceConsumeInterceptor
• public class GZipInterceptor : IProduceConsumeInterceptor
• public interface IProduceConsumeInterceptor
• public class TripleDESInterceptor : IProduceConsumeInterceptor

EasyNetQ.Internals

• public sealed class ArrayPooledMemoryStream : Stream, IMemoryOwner<byte>, IDisposable
• public sealed class AsyncCache<TKey, TValue> : IDisposable
• public sealed class AsyncCountdownEvent : IDisposable
• public struct AsyncLock : IDisposable
• public sealed class AsyncQueue<T> : IDisposable
• public static class CancellationTokenExtensions
• public static class ConcurrentDictionaryExtensions
• public static class DictionaryExtensions
• public static class DisposableAction
• public struct DisposableAction<TState> : IDisposable
• public sealed class EmptyMemoryOwner : IMemoryOwner<byte>, IDisposable
• public sealed class ReadOnlyMemoryStream : Stream
• public static class ReflectionHelpers
• public static class StringExtensions
• public static class TaskHelpers
• public static class Timers
• public static class UriExtensions

EasyNetQ.Loggers

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

EasyNetQ.Logging

• public sealed class ConsoleLogger<TCategoryName> : ILogger<TCategoryName>, ILogger
• public interface ILogger
• public interface ILogger<TCategoryName> : ILogger
• public static class LoggerExtensions
• public enum LogLevel
• public sealed class NoopLogger<TCategoryName> : ILogger<TCategoryName>, ILogger

EasyNetQ.MessageVersioning

• public class MessageType
  • public Type Type { get; set; }
  • public string TypeString { get; set; }
  • public MessageType()
• public class MessageTypeProperty
  • public MessageProperties AppendTo(ref MessageProperties messageProperties)
  • public Type GetMessageType()
  • public void AppendTo(MessageProperties messageProperties)
  • public MessageType GetMessageType()
• public static class MessageVersioningExtensions
  • public static IServiceRegister EnableMessageVersioning(this IServiceRegister serviceRegister)
• public class VersionedExchangeDeclareStrategy : IExchangeDeclareStrategy
• public class VersionedMessageSerializationStrategy : IMessageSerializationStrategy
  • public IMessage DeserializeMessage(ref MessageProperties properties, ref ReadOnlyMemory body)
  • public SerializedMessage SerializeMessage(IMessage message)
  • public DeserializedMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • public SerializedMessage SerializeMessage<T>(IMessage<T> message)
• public class VersionedPublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
  • public VersionedPublishExchangeDeclareStrategy()
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)

EasyNetQ.MultipleExchange

• public class MultipleExchangeDeclareStrategy : IExchangeDeclareStrategy

EasyNetQ.NonGeneric

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

EasyNetQ.Persistent

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

EasyNetQ.Producer

• public interface IProducerConnection : IPersistentConnection, IDisposable
• public interface IPublishConfirmationListener : IDisposable
• public interface IPublishPendingConfirmation
• public struct ProduceContext : IEquatable<ProduceContext>
• public sealed delegate ProduceDelegate : MulticastDelegate
• public sealed class ProducePipelineBuilder
• public sealed class ProducerConnection : PersistentConnection, IProducerConnection, IPersistentConnection, IDisposable
• public class PublishConfirmationListener : IPublishConfirmationListener, IDisposable
• public class PublishInterruptedException : Exception
• public class ClientCommandDispatcher : IClientCommandDispatcher, IDisposable
  • public ClientCommandDispatcher(IPersistentConnection connection, IPersistentChannelFactory persistentChannelFactory)
  • public void Dispose()
  • public Task<T> Invoke<T>(Func<IModel, T> channelAction)
  • public Task Invoke(Action<IModel> channelAction)
• public class ClientCommandDispatcherFactory : IClientCommandDispatcherFactory
  • public ClientCommandDispatcherFactory(IPersistentChannelFactory persistentChannelFactory)
  • public IClientCommandDispatcher GetClientCommandDispatcher(IPersistentConnection connection)
• public class ClientCommandDispatcherSingleton : IClientCommandDispatcher, IDisposable
  • public ClientCommandDispatcherSingleton(IPersistentConnection connection, IPersistentChannelFactory persistentChannelFactory)
  • public void Dispose()
  • public Task<T> Invoke<T>(Func<IModel, T> channelAction)
  • public Task Invoke(Action<IModel> channelAction)
• public interface IClientCommandDispatcher : IDisposable
  • Task<T> Invoke<T>(Func<IModel, T> channelAction)
  • Task Invoke(Action<IModel> channelAction)
• public interface IClientCommandDispatcherFactory
  • IClientCommandDispatcher GetClientCommandDispatcher(IPersistentConnection connection)
• public interface IPersistentChannel : IDisposable
  • void InvokeChannelAction(Action<IModel> channelAction)
• public interface IPersistentChannelFactory
  • IPersistentChannel CreatePersistentChannel(IPersistentConnection connection)
• public interface IPublisher
  • Task Publish(IModel model, Action<IModel> publishAction)
• public interface IPublishExchangeDeclareStrategy
  • IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)
• public interface IRpc
  • Task<TResponse> Request<TRequest, TResponse>(TRequest request)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
• public interface ISendReceive
  • IDisposable Receive<T>(string queue, Action<T> onMessage)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • void Send<T>(string queue, T message)
• public class PersistentChannel : IPersistentChannel, IDisposable
  • public IModel Channel { get; }
  • public PersistentChannel(IPersistentConnection connection, IEasyNetQLogger logger, IConnectionConfiguration configuration, IEventBus eventBus)
  • public void Dispose()
  • public void InvokeChannelAction(Action<IModel> channelAction)
• public class PersistentChannelFactory : IPersistentChannelFactory
  • public PersistentChannelFactory(IEasyNetQLogger logger, IConnectionConfiguration configuration, IEventBus eventBus)
  • public IPersistentChannel CreatePersistentChannel(IPersistentConnection connection)
• public abstract class PublisherBase : IPublisher
  • protected struct NullStruct
  • protected PublisherBase(IEventBus eventBus)
  • protected void ModelOnBasicReturn(IModel model, BasicReturnEventArgs args)
  • protected virtual void OnChannelClosed(IModel oldModel)
  • protected virtual void OnChannelOpened(IModel newModel)
  • public abstract Task Publish(IModel model, Action<IModel> publishAction)
  • protected void SetModel(IModel model)
• public class PublisherBasic : PublisherBase
  • public PublisherBasic(IEventBus eventBus)
• public class PublisherConfirms : PublisherBase
  • public PublisherConfirms(IConnectionConfiguration configuration, IEasyNetQLogger logger, IEventBus eventBus)
• public static class PublisherFactory
  • public static IPublisher CreatePublisher(IConnectionConfiguration configuration, IEasyNetQLogger logger, IEventBus eventBus)
• public class PublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
  • public PublishExchangeDeclareStrategy()
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, string exchangeName, string exchangeType)
  • public IExchange DeclareExchange(IAdvancedBus advancedBus, Type messageType, string exchangeType)
• public class PublishReturnedException : Exception
• public class Rpc : IRpc
  • protected class ResponseAction
  • protected struct RpcKey
  • protected const string ExceptionMessageKey = "ExceptionMessage"
  • protected const string IsFaultedKey = "IsFaulted"
  • protected readonly IAdvancedBus advancedBus
  • protected readonly IConnectionConfiguration configuration
  • protected readonly IConventions conventions
  • protected readonly TimeSpan disablePeriodicSignaling
  • protected readonly IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy
  • public Rpc(IAdvancedBus advancedBus, IEventBus eventBus, IConventions conventions, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IConnectionConfiguration configuration)
  • protected Task ExecuteResponder<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, IMessage<TRequest> requestMessage)
  • protected void RegisterErrorHandling<TResponse>(Guid correlationId, Timer timer, TaskCompletionSource<TResponse> tcs)
  • public virtual Task<TResponse> Request<TRequest, TResponse>(TRequest request)
  • protected virtual void RequestPublish<TRequest>(TRequest request, string routingKey, string returnQueueName, Guid correlationId)
  • public virtual IDisposable Respond<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • protected virtual string SubscribeToResponse<TRequest, TResponse>()
• public class SendReceive : ISendReceive
  • public SendReceive(IAdvancedBus advancedBus, IConnectionConfiguration connectionConfiguration)
  • public IDisposable Receive<T>(string queue, Action<T> onMessage)
  • public IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • public IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • public void Send<T>(string queue, T message)

EasyNetQ.SystemMessages

• public class Error
  • public string Queue { get; set; }
  • public Error(string routingKey, string exchange, string queue, string exception, string message, DateTime dateTime, MessageProperties basicProperties)
  • public Error()
• public class ScheduleMe
  • public string BindingKey { get; set; }
  • public string CancellationKey { get; set; }
  • public byte[] InnerMessage { get; set; }
  • public DateTime WakeTime { get; set; }
  • public ScheduleMe()
• public class UnscheduleMe
  • public string CancellationKey { get; set; }
  • public UnscheduleMe()

EasyNetQ.Topology

• public struct Binding<TBindable> where TBindable : struct, IBindable
• public class Binding : IBinding
  • public IBindable Bindable { get; }
  • public IExchange Exchange { get; }
  • public string RoutingKey { get; }
  • public Binding(IBindable bindable, IExchange exchange, string routingKey)
• public class Exchange : IExchange, IBindable
  • public const string DefaultName = ""
  • public static Exchange Default { get; }
  • public IDictionary<string, object> Arguments { get; }
  • public bool IsAutoDelete { get; }
  • public bool IsDurable { get; }
  • public string Type { get; }
  • public Exchange(string name, string type = "direct", bool durable = true, bool autoDelete = false, IDictionary<string, object> arguments = null)
  • public Exchange(string name)
  • public static IExchange GetDefault()
• public class ExchangeType
  • public const string Direct = "direct"
  • public const string Fanout = "fanout"
  • public const string Header = "headers"
  • public const string Topic = "topic"
  • public ExchangeType()
• public interface IBindable
  • string Name { get; }
• public interface IBinding
  • IBindable Bindable { get; }
  • IExchange Exchange { get; }
  • string RoutingKey { get; }
• public interface IExchange : IBindable
  • string Name { get; }
• public interface IQueue : IBindable
  • bool IsExclusive { get; }
  • string Name { get; }
• public class Queue : IQueue, IBindable
  • public IDictionary<string, object> Arguments { get; }
  • public bool IsAutoDelete { get; }
  • public bool IsDurable { get; }
  • public Queue(string name, bool isDurable = true, bool isExclusive = false, bool isAutoDelete = false, IDictionary<string, object> arguments = null)
  • public Queue(string name, bool isExclusive)

Sprache

• public interface IFailure<T> : IResult<T>
  • IEnumerable<string> Expectations { get; }
  • Input FailedInput { get; }
  • string Message { get; }
• public class Input
  • public bool AtEnd { get; }
  • public int Column { get; }
  • public char Current { get; }
  • public int Line { get; }
  • public int Position { get; }
  • public string Source { get; set; }
  • public Input(string source)
  • public Input Advance()
• public interface IResult<T>
• public interface ISuccess<T> : IResult<T>
  • Input Remainder { get; }
  • T Result { get; }
• public static class Parse
  • public static readonly Parser<char> AnyChar
  • public static readonly Parser<string> Decimal
  • public static readonly Parser<char> Digit
  • public static readonly Parser<char> Letter
  • public static readonly Parser<char> LetterOrDigit
  • public static readonly Parser<char> Lower
  • public static readonly Parser<string> Number
  • public static readonly Parser<char> Numeric
  • public static readonly Parser<char> Upper
  • public static readonly Parser<char> WhiteSpace
  • public static Parser<IEnumerable<T>> AtLeastOnce<T>(this Parser<T> parser)
  • public static Parser<IEnumerable<char>> CaseInsensitiveString(string s)
  • public static Parser<T> ChainOperator<T, TOp>(Parser<TOp> op, Parser<T> operand, Func<TOp, T, T, T> apply)
  • public static Parser<T> ChainRightOperator<T, TOp>(Parser<TOp> op, Parser<T> operand, Func<TOp, T, T, T> apply)
  • public static Parser<char> Char(Predicate<char> predicate, string description)
  • public static Parser<char> Char(char c)
  • public static Parser<char> CharCaseInsensitive(char c)
  • public static Parser<char> CharExcept(Predicate<char> predicate, string description)
  • public static Parser<char> CharExcept(char c)
  • public static Parser<IEnumerable<T>> Concat<T>(this Parser<IEnumerable<T>> first, Parser<IEnumerable<T>> second)
  • public static Parser<T> End<T>(this Parser<T> parser)
  • public static Parser<T> Except<T, U>(this Parser<T> parser, Parser<U> except)
  • public static Parser<IEnumerable<T>> Many<T>(this Parser<T> parser)
  • public static Parser<T> Named<T>(this Parser<T> parser, string name)
  • public static Parser<IEnumerable<T>> Once<T>(this Parser<T> parser)
  • public static Parser<T> Or<T>(this Parser<T> first, Parser<T> second)
  • public static Parser<T> Ref<T>(Func<Parser<T>> reference)
  • public static Parser<T> Return<T>(T value)
  • public static Parser<U> Return<T, U>(this Parser<T> parser, U value)
  • public static Parser<U> Select<T, U>(this Parser<T> parser, Func<T, U> convert)
  • public static Parser<V> SelectMany<T, U, V>(this Parser<T> parser, Func<T, Parser<U>> selector, Func<T, U, V> projector)
  • public static Parser<IEnumerable<char>> String(string s)
  • public static Parser<string> Text(this Parser<IEnumerable<char>> characters)
  • public static Parser<U> Then<T, U>(this Parser<T> first, Func<T, Parser<U>> second)
  • public static Parser<T> Token<T>(this Parser<T> parser)
  • public static Parser<IEnumerable<T>> Until<T, U>(this Parser<T> parser, Parser<U> until)
  • public static Parser<T> Where<T>(this Parser<T> parser, Func<T, bool> predicate)
  • public static Parser<IEnumerable<T>> XMany<T>(this Parser<T> parser)
  • public static Parser<T> XOr<T>(this Parser<T> first, Parser<T> second)
• public class ParseException : Exception
  • public ParseException(string message)
• public sealed delegate Parser<T> : MulticastDelegate
  • public Parser(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Input input, AsyncCallback callback, object object)
  • public virtual IResult<T> EndInvoke(IAsyncResult result)
  • public virtual IResult<T> Invoke(Input input)
• public static class ParserExtensions
  • public static T Parse<T>(this Parser<T> parser, string input)
  • public static IResult<T> TryParse<T>(this Parser<T> parser, string input)