EasyNetQ by Mike Hadlow, Chris Edwards, A Hazelwood

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

---

API Diff between 0.14.2.122 and 0.47.10.384

241 Additions 318 Removals

EasyNetQ

• public class AdvancedBusEventHandlers
• public class BasicGetResult : IBasicGetResult
• public class BasicGetResult<T> : IBasicGetResult<T>
• public sealed delegate CancelSubscription : MulticastDelegate
• public static class BusExtensions
  • public static void FuturePublish<T>(this IPublishChannel publishChannel, DateTime timeToRespond, T message)
• public class ComponentRegistration
  • public static void RegisterServices(IContainer container)
  • public static IServiceProvider CreateServiceProvider(Action<IServiceRegister> registerServices)
• public class ConnectionConfiguration : IConnectionConfiguration
  • public bool CancelOnHaFailover { get; set; }
  • public IDictionary<string, object> ClientProperties { get; }
  • public IEnumerable<HostConfiguration> Hosts { get; set; }
  • public IDictionary<string, string> ClientProperties { get; }
  • public IEnumerable<IHostConfiguration> Hosts { get; set; }
  • public bool PersistentMessages { get; set; }
  • public string Platform { get; set; }
  • public string Product { get; set; }
  • public bool PublisherConfirms { get; set; }
  • public ushort Timeout { get; set; }
• public class ConnectionFactoryInfo
  • public HostConfiguration HostConfiguration { get; }
  • public ConnectionFactoryInfo(ConnectionFactory connectionFactory, HostConfiguration hostConfiguration)
  • public IHostConfiguration HostConfiguration { get; }
  • public ConnectionFactoryInfo(ConnectionFactory connectionFactory, IHostConfiguration hostConfiguration)
• public class ConnectionFactoryWrapper : IConnectionFactory
  • public virtual ConnectionConfiguration Configuration { get; }
  • public virtual HostConfiguration CurrentHost { get; }
  • public virtual IConnectionConfiguration Configuration { get; }
  • public virtual IHostConfiguration CurrentHost { get; }
  • public ConnectionFactoryWrapper(ConnectionConfiguration connectionConfiguration, IClusterHostSelectionStrategy<ConnectionFactoryInfo> clusterHostSelectionStrategy)
  • public ConnectionFactoryWrapper(IConnectionConfiguration connectionConfiguration, IClusterHostSelectionStrategy<ConnectionFactoryInfo> clusterHostSelectionStrategy)
• public class Conventions : IConventions
  • public Conventions(ITypeNameSerializer typeNameSerializer)
  • public Conventions()
• public class DefaultCorrelationIdGenerationStrategy : ICorrelationIdGenerationStrategy
• public class DefaultMessageSerializationStrategy : IMessageSerializationStrategy
• public class CorrelationIdGenerator
  • public CorrelationIdGenerator()
  • public static string GetCorrelationId()
• 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 DefaultMessageValidationStrategy : IMessageValidationStrategy
  • public DefaultMessageValidationStrategy(IEasyNetQLogger logger, SerializeType serializeType)
  • public void CheckMessageType<TMessage>(byte[] body, MessageProperties properties, MessageReceivedInfo messageReceivedInfo)
• public class DefaultServiceProvider : IServiceProvider, IServiceRegister
  • public IServiceRegister Register<TService, TImplementation>() where TImplementation : TService
  • public object Resolve(Type serviceType)
• public class DelayedExchangeScheduler : IScheduler
• public class DeliveryModeAttribute : Attribute
• public class EasyNetQResponderException : EasyNetQException
• public sealed delegate ErrorExchangeNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(MessageReceivedInfo info, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(string originalRoutingKey, AsyncCallback callback, object object)
  • public virtual string Invoke(MessageReceivedInfo info)
  • public virtual string Invoke(string originalRoutingKey)
• public class EventBus : IEventBus
• public class HostConfiguration : IHostConfiguration
  • public SslOption Ssl { get; }
• public interface IAdvancedBus : IDisposable
  • IContainer Container { get; }
  • IConventions Conventions { get; }
  • event EventHandler<ConnectionBlockedEventArgs> Blocked
  • event EventHandler Connected
  • event EventHandler Disconnected
  • event EventHandler<MessageReturnedEventArgs> MessageReturned
  • event EventHandler Unblocked
  • ISerializer Serializer { get; }
  • SerializeType SerializeType { get; }
  • event Action Connected
  • event Action Disconnected
  • Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey)
  • Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey)
  • 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 Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • void Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
  • IExchange ExchangeDeclare(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = 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)
  • IAdvancedPublishChannel OpenPublishChannel()
  • IAdvancedPublishChannel OpenPublishChannel(Action<IChannelConfiguration> configure)
  • IQueue QueueDeclare(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, uint perQueueTtl = 4294967295, uint expires = 4294967295)
  • 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 interface IBasicGetResult
• public interface IBasicGetResult<T>
• public interface IAdvancedPublishChannel : IDisposable
  • void Publish<T>(IExchange exchange, string routingKey, IMessage<T> message, Action<IAdvancedPublishConfiguration> configure)
  • void Publish(IExchange exchange, string routingKey, MessageProperties properties, byte[] messageBody, Action<IAdvancedPublishConfiguration> configure)
  • void Publish<T>(IExchange exchange, string routingKey, IMessage<T> message)
  • void Publish(IExchange exchange, string routingKey, MessageProperties properties, byte[] messageBody)
• public interface IBus : IDisposable
  • 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)
  • event Action Connected
  • event Action Disconnected
  • IPublishChannel OpenPublishChannel()
  • IPublishChannel OpenPublishChannel(Action<IChannelConfiguration> configure)
  • void Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • void RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • void Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • void Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration<T>> configure)
  • void SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • void SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration<T>> configure)
• public interface IConnectionConfiguration
  • Uri AMQPConnectionString { get; }
  • IDictionary<string, string> ClientProperties { get; }
  • IEnumerable<IHostConfiguration> Hosts { get; }
  • string Password { get; }
  • ushort Port { get; }
  • ushort PrefetchCount { get; }
  • ushort RequestedHeartbeat { get; }
  • SslOption Ssl { get; }
  • string UserName { get; }
  • string VirtualHost { get; }
• public interface IConnectionFactory
  • ConnectionConfiguration Configuration { get; }
  • HostConfiguration CurrentHost { get; }
  • IConnectionConfiguration Configuration { get; }
  • IHostConfiguration CurrentHost { get; }
• public interface IContainer : IServiceProvider, IServiceRegister
• public interface ICorrelationIdGenerationStrategy
• public interface IEventBus
• 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
• public interface IMessageValidationStrategy
  • void CheckMessageType<TMessage>(byte[] body, MessageProperties properties, MessageReceivedInfo messageReceivedInfo)
• public interface IPersistentConnection : IDisposable
  • event Action Connected
  • event Action Disconnected
  • void Initialize()
• public interface IScheduler
• public interface IPublishChannel : IDisposable
  • IBus Bus { get; }
  • void Publish<T>(T message)
  • void Publish<T>(T message, Action<IPublishConfiguration<T>> configure)
  • void Request<TRequest, TResponse>(TRequest request, Action<TResponse> onResponse)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request, CancellationToken token)
• public interface IPublisherConfirms
  • void FailedPublish(IModel channel, BasicNackEventArgs args)
  • void RegisterCallbacks(IModel channel, Action successCallback, Action failureCallback)
  • void SuccessfulPublish(IModel channel, BasicAckEventArgs args)
• public interface ISaga
  • void Initialize(IBus bus)
• public interface ISerializer
  • object BytesToMessage(string typeName, byte[] bytes)
• public interface IServiceRegister
  • IServiceRegister Register<TService, TImplementation>() where TImplementation : TService
• public interface ISubscriptionResult : IDisposable
• public interface ITimeoutStrategy
• public interface ITypeNameSerializer
• public class JsonSerializer : ISerializer
  • public JsonSerializer(ITypeNameSerializer typeNameSerializer)
  • public JsonSerializer()
  • public object BytesToMessage(string typeName, byte[] bytes)
• public static class LinqExtensions
  • public static IEnumerable<KeyValuePair<string, string>> EnumerateDictionary(this IDictionary<string, object> dictionary)
  • public static IEnumerable<KeyValuePair<string, string>> EnumerateDictionary(this IDictionary dictionary)
  • public static void Shuffle<T>(this IList<T> list)
• public class Message<T> : IMessage<T>
  • public Type MessageType { get; }
  • public Message(T body, MessageProperties properties)
  • public object GetBody()
• public static class MessageDeliveryMode
• public class MessageDeliveryModeStrategy : IMessageDeliveryModeStrategy
• public static class MessageFactory
• public class MessageNotAvailableException : Exception
• public class MessageProperties
  • public IDictionary<string, object> Headers { get; set; }
  • public IDictionary Headers { get; set; }
• public class MessageReceivedInfo
  • public string Queue { get; set; }
  • public MessageReceivedInfo()
  • public MessageReceivedInfo(string consumerTag, ulong deliverTag, bool redelivered, string exchange, string routingKey, string queue)
  • public MessageReceivedInfo(string consumerTag, ulong deliverTag, bool redelivered, string exchange, string routingKey)
• public class MessageReturnedEventArgs : EventArgs
• public class MessageReturnedInfo
• public class OrderedClusterHostSelectionStrategy<T> : IClusterHostSelectionStrategy<T>, IEnumerable<T>, IEnumerable
• public class PersistentConnection : IPersistentConnection, IDisposable
  • public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger, IEventBus eventBus)
  • public event Action Connected
  • public event Action Disconnected
  • public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger)
  • public void Initialize()
• public class QueueAttribute : Attribute
• public class PublisherConfirms : IPublisherConfirms
  • public int NumCallbacks { get; }
  • public PublisherConfirms()
  • public void FailedPublish(IModel channel, BasicNackEventArgs args)
  • public void RegisterCallbacks(IModel channel, Action successCallback, Action failureCallback)
  • public void SuccessfulPublish(IModel channel, BasicAckEventArgs args)
• public class RabbitAdvancedBus : IAdvancedBus, IDisposable
  • public IContainer Container { get; }
  • public IConventions Conventions { get; }
  • public IPersistentConnection Connection { get; }
  • public Func<string> GetCorrelationId { get; }
  • public event EventHandler<ConnectionBlockedEventArgs> Blocked
  • public event EventHandler Connected
  • public event EventHandler Disconnected
  • public event EventHandler<MessageReturnedEventArgs> MessageReturned
  • public event EventHandler Unblocked
  • public RabbitAdvancedBus(IConnectionFactory connectionFactory, IConsumerFactory consumerFactory, IEasyNetQLogger logger, IClientCommandDispatcherFactory clientCommandDispatcherFactory, IPublisher publisher, IEventBus eventBus, IHandlerCollectionFactory handlerCollectionFactory, IContainer container, ConnectionConfiguration connectionConfiguration, IProduceConsumeInterceptor produceConsumeInterceptor, IMessageSerializationStrategy messageSerializationStrategy, IConventions conventions, AdvancedBusEventHandlers advancedBusEventHandlers)
  • public IEasyNetQLogger Logger { get; }
  • public virtual ISerializer Serializer { get; }
  • public virtual SerializeType SerializeType { get; }
  • public event Action Connected
  • public event Action Disconnected
  • public RabbitAdvancedBus(IConnectionFactory connectionFactory, SerializeType serializeType, ISerializer serializer, IConsumerFactory consumerFactory, IEasyNetQLogger logger, Func<string> getCorrelationId, IMessageValidationStrategy messageValidationStrategy)
  • public Task<IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey)
  • public Task<IBinding> BindAsync(IExchange source, IExchange destination, string routingKey)
  • 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 void Consume<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • public virtual void Consume(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
  • 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 IExchange ExchangeDeclare(string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool internal = 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 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 IAdvancedPublishChannel OpenPublishChannel()
  • public virtual IAdvancedPublishChannel OpenPublishChannel(Action<IChannelConfiguration> configure)
  • public IQueue QueueDeclare(string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, uint perQueueTtl = 4294967295, uint expires = 4294967295)
  • 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 class RabbitAdvancedPublishChannel : IAdvancedPublishChannel, IDisposable
  • public RabbitAdvancedPublishChannel(RabbitAdvancedBus advancedBus, Action<IChannelConfiguration> configure)
  • public virtual void Dispose()
  • public virtual void Publish<T>(IExchange exchange, string routingKey, IMessage<T> message, Action<IAdvancedPublishConfiguration> configure)
  • public virtual void Publish(IExchange exchange, string routingKey, MessageProperties properties, byte[] messageBody, Action<IAdvancedPublishConfiguration> configure)
  • public virtual void Publish<T>(IExchange exchange, string routingKey, IMessage<T> message)
  • public virtual void Publish(IExchange exchange, string routingKey, MessageProperties properties, byte[] messageBody)
• public class RabbitBus : IBus, IDisposable
  • public IConventions Conventions { get; }
  • public RabbitBus(IConventions conventions, IAdvancedBus advancedBus, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IMessageDeliveryModeStrategy messageDeliveryModeStrategy, IRpc rpc, ISendReceive sendReceive, ConnectionConfiguration connectionConfiguration)
  • public IEasyNetQLogger Logger { get; }
  • public SerializeType SerializeType { get; }
  • public event Action Connected
  • public event Action Disconnected
  • public RabbitBus(SerializeType serializeType, IEasyNetQLogger logger, IConventions conventions, IAdvancedBus advancedBus)
  • 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)
  • protected void OnConnected()
  • protected void OnDisconnected()
  • public virtual IPublishChannel OpenPublishChannel()
  • public virtual IPublishChannel OpenPublishChannel(Action<IChannelConfiguration> configure)
  • public virtual void Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • public virtual void RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • public virtual void Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • public virtual void Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration<T>> configure)
  • public virtual void SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • public virtual void SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration<T>> 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, AdvancedBusEventHandlers advancedBusEventHandlers, 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(IConnectionConfiguration connectionConfiguration, Action<IServiceRegister> registerServices)
  • public static IBus CreateBus()
• public class RandomClusterHostSelectionStrategy<T> : IClusterHostSelectionStrategy<T>, IEnumerable<T>, IEnumerable
• public static class ReflectionHelpers
• public class RabbitPublishChannel : IPublishChannel, IDisposable
  • public IAdvancedBus AdvancedBus { get; }
  • public IAdvancedPublishChannel AdvancedPublishChannel { get; }
  • public virtual IBus Bus { get; }
  • public RabbitPublishChannel(RabbitBus bus, Action<IChannelConfiguration> configure, IConventions conventions)
  • public void Dispose()
  • public virtual void Publish<T>(T message)
  • public virtual void Publish<T>(T message, Action<IPublishConfiguration<T>> configure)
  • public void Request<TRequest, TResponse>(TRequest request, Action<TResponse> onResponse)
  • public Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • public Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request, CancellationToken token)
• public class Scheduler : IScheduler
• public class SerializedMessage
• public sealed delegate SerializeType : MulticastDelegate
  • public SerializeType(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Type type, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(Type type)
• 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 static class TaskHelpers
• public class TimeoutSecondsAttribute : Attribute
• public class TimeoutStrategy : ITimeoutStrategy
• public class TypeNameSerializer
  • public Type DeSerialize(string typeName)

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 DispatchAsyncMethodName = "DispatchAsync"
  • protected Action<ISubscriptionConfiguration> ConfigureSubscriptionConfiguration { get; set; }
  • protected virtual MethodInfo GetSubscribeMethodOfBus(string methodName, Type parmType)
  • protected virtual MethodInfo GetSubscribeMethodOfBus()
  • 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 IEnumerable<KeyValuePair<Type, AutoSubscriberConsumerInfo[]>> GetSubscriptionInfos(IEnumerable<Type> types)
  • public virtual void Subscribe(Type[] consumerTypes)
  • public virtual void SubscribeAsync(Assembly[] assemblies)
  • public virtual void SubscribeAsync(Type[] consumerTypes)
• public class DefaultAutoSubscriberMessageDispatcher : IAutoSubscriberMessageDispatcher
  • public Task DispatchAsync<TMessage, TConsumer>(TMessage message) where TConsumer : IConsumeAsync<TMessage>
• public class ForTopicAttribute : Attribute
• public interface IAutoSubscriberMessageDispatcher
  • Task DispatchAsync<TMessage, TConsumer>(TMessage message) where TConsumer : IConsumeAsync<TMessage>
• public interface IConsumeAsync<T>
• public class SubscriptionConfigurationAttribute : Attribute

EasyNetQ.ConnectionString

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

EasyNetQ.Consumer

• public static class AckStrategies
• public sealed delegate AckStrategy : MulticastDelegate
• public class ConsumerCancellation : IDisposable
• public class ConsumerConfiguration : IConsumerConfiguration
• public class ConsumerDispatcher : IConsumerDispatcher, IDisposable
  • public void OnDisconnected()
• public class ConsumerDispatcherFactory : IConsumerDispatcherFactory, IDisposable
  • public void OnDisconnected()
• public class ConsumerExecutionContext
  • public IEnumerable<Action> PostAckCallbacks { get; }
  • public void SetPostAckCallback(Action callback)
• 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(IInternalConsumerFactory internalConsumerFactory)
  • public IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection)
• public class DefaultConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable
  • public DefaultConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer, IEasyNetQLogger logger, IConventions conventions, ITypeNameSerializer typeNameSerializer)
  • public DefaultConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer, IEasyNetQLogger logger, IConventions conventions)
  • public AckStrategy HandleConsumerCancelled(ConsumerExecutionContext context)
  • public virtual AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception)
  • public virtual void HandleConsumerError(ConsumerExecutionContext context, Exception exception)
  • public virtual PostExceptionAckStrategy PostExceptionAckStrategy()
• public class ExclusiveConsumer : IConsumer, IDisposable
• public class HandlerCollection : IHandlerCollection, IHandlerRegistration
• public class HandlerCollectionFactory : IHandlerCollectionFactory
• public class HandlerRunner : IHandlerRunner, IDisposable
  • public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus)
  • public Action SynchronisationAction { get; set; }
  • public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy)
• public interface IConsumer : IDisposable
  • IDisposable StartConsuming()
  • event Action<IConsumer> RemoveMeFromList
  • void StartConsuming()
• public interface IConsumerConfiguration
• public interface IConsumerDispatcher : IDisposable
  • void OnDisconnected()
• public interface IConsumerDispatcherFactory : IDisposable
  • void OnDisconnected()
• public interface IConsumerErrorStrategy : IDisposable
  • AckStrategy HandleConsumerCancelled(ConsumerExecutionContext context)
  • AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception)
  • void HandleConsumerError(ConsumerExecutionContext context, Exception exception)
  • PostExceptionAckStrategy PostExceptionAckStrategy()
• public interface IConsumerFactory : IDisposable
  • IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
  • IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection)
• public interface IHandlerCollection : IHandlerRegistration
• public interface IHandlerCollectionFactory
• public interface IHandlerRegistration
• public interface IInternalConsumer : IDisposable
  • event Action<ConsumerExecutionContext> AckOrNackWasSent
  • StartConsumingStatus StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
  • void StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
• public interface IInternalConsumerFactory : IDisposable
  • void OnDisconnected()
• public class InternalConsumer : IBasicConsumer, IInternalConsumer, IDisposable
  • public bool IsRunning { get; }
  • public event Action<ConsumerExecutionContext> AckOrNackWasSent
  • public event ConsumerCancelledEventHandler ConsumerCancelled
  • public InternalConsumer(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConsumerDispatcher consumerDispatcher, IConventions conventions, ConnectionConfiguration connectionConfiguration, IEventBus eventBus)
  • public InternalConsumer(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConsumerDispatcher consumerDispatcher, IConventions conventions, IConnectionConfiguration connectionConfiguration)
  • public StartConsumingStatus StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
  • public void StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
• public class InternalConsumerFactory : IInternalConsumerFactory, IDisposable
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConventions conventions, ConnectionConfiguration connectionConfiguration, IConsumerDispatcherFactory consumerDispatcherFactory, IEventBus eventBus)
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConventions conventions, IConnectionConfiguration connectionConfiguration, IConsumerDispatcherFactory consumerDispatcherFactory)
  • public void OnDisconnected()
• public interface IReceiveRegistration
• public class PersistentConsumer : IConsumer, IDisposable
  • public PersistentConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public event Action<IConsumer> RemoveMeFromList
  • public PersistentConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IInternalConsumerFactory internalConsumerFactory)
  • public IDisposable StartConsuming()
  • public void StartConsuming()
• public enum StartConsumingStatus
• public class SubscriptionResult : ISubscriptionResult, IDisposable
• public enum PostExceptionAckStrategy
  • DoNothing = 3
  • ShouldAck = 0
  • ShouldNackWithoutRequeue = 1
  • ShouldNackWithRequeue = 2
• public class SingleUseConsumer : IConsumer, IDisposable
  • public event Action<IConsumer> RemoveMeFromList
  • public SingleUseConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IInternalConsumerFactory internalConsumerFactory)
  • public void Dispose()
  • public void 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 event Action<IConsumer> RemoveMeFromList
  • public TransientConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IInternalConsumerFactory internalConsumerFactory)
  • public IDisposable StartConsuming()
  • public void StartConsuming()

EasyNetQ.Events

• public class AckEvent
• public enum AckResult
• public class ConnectionBlockedEvent
• public class ConnectionCreatedEvent
• public class ConnectionDisconnectedEvent
• public class ConnectionUnblockedEvent
• public class ConsumerModelDisposedEvent
• public class DeliveredMessageEvent
• public class PublishChannelCreatedEvent
• public class PublishedMessageEvent
• public class ReturnedMessageEvent
• public class StoppedConsumingEvent

EasyNetQ.FluentConfiguration

• public interface ISubscriptionConfiguration
• public class SubscriptionConfiguration : ISubscriptionConfiguration
• public class AdvancedPublishConfiguration : IAdvancedPublishConfiguration
  • public Action FailureCallback { get; }
  • public Action SuccessCallback { get; }
  • public AdvancedPublishConfiguration()
  • public IAdvancedPublishConfiguration OnFailure(Action failureCallback)
  • public IAdvancedPublishConfiguration OnSuccess(Action successCallback)
• public class ChannelConfiguration : IChannelConfiguration
  • public bool PublisherConfirmsOn { get; }
  • public ChannelConfiguration()
  • public IChannelConfiguration WithPublisherConfirms()
• public interface IAdvancedPublishConfiguration
  • IAdvancedPublishConfiguration OnFailure(Action failureCallback)
  • IAdvancedPublishConfiguration OnSuccess(Action successCallback)
• public interface IChannelConfiguration
  • IChannelConfiguration WithPublisherConfirms()
• public interface IPublishConfiguration<T>
  • IPublishConfiguration<T> OnFailure(Action failureCallback)
  • IPublishConfiguration<T> OnSuccess(Action successCallback)
  • IPublishConfiguration<T> WithTopic(string topic)
• public interface ISubscriptionConfiguration<T>
  • ISubscriptionConfiguration<T> WithTopic(string topic)
• public class PublishConfiguration<T> : IPublishConfiguration<T>
  • public Action FailureCallback { get; }
  • public Action SuccessCallback { get; }
  • public IList<string> Topics { get; }
  • public PublishConfiguration()
  • public IPublishConfiguration<T> OnFailure(Action failureCallback)
  • public IPublishConfiguration<T> OnSuccess(Action successCallback)
  • public IPublishConfiguration<T> WithTopic(string topic)
• public class SubscriptionConfiguration<T> : ISubscriptionConfiguration<T>
  • public IList<string> Topics { get; }
  • public SubscriptionConfiguration()
  • public ISubscriptionConfiguration<T> WithTopic(string topic)

EasyNetQ.Interception

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

EasyNetQ.Loggers

• public class NullLogger : IEasyNetQLogger

EasyNetQ.MessageVersioning

• public interface ISupersede<T>
• public class MessageType
• public class MessageTypeProperty
• public static class MessageVersioningExtensions
• public class MessageVersionStack : IEnumerable<Type>, IEnumerable
• public class VersionedMessageSerializationStrategy : IMessageSerializationStrategy
• public class VersionedPublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy

EasyNetQ.NonGeneric

• public static class NonGenericExtensions

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 PublishNackedException : Exception
• public class ResponderConfiguration : IResponderConfiguration
• public class Rpc : IRpc
• public class SendReceive : ISendReceive

EasyNetQ.SystemMessages

• public class ScheduleMe
  • public string CancellationKey { get; set; }
• public class UnscheduleMe

EasyNetQ.Topology

• public class ExchangeType
  • public ExchangeType()
• public interface IQueue : IBindable
  • bool IsSingleUse { get; }
  • IQueue SetAsSingleUse()
• public class Queue : IQueue, IBindable
  • public bool IsSingleUse { get; }
  • public IQueue SetAsSingleUse()