EasyNetQ by Mike Hadlow, Chris Edwards, A Hazelwood

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

---

API Diff between 0.33.2.277 and 0.9.2.76

623 Additions 127 Removals

EasyNetQ

• public class AutoSubscriber
• public static class BusExtensions
  • public static void FuturePublish<T>(this IPublishChannel publishChannel, DateTime timeToRespond, T message)
  • 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 static IServiceProvider CreateServiceProvider(Action<IServiceRegister> registerServices)
  • public static void RegisterServices(IContainer container)
• public class ConcurrentHashSet<T> : ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable
• public class ConnectionConfiguration : IConnectionConfiguration
  • public IDictionary<string, string> ClientProperties { get; }
  • public Uri AMQPConnectionString { get; set; }
  • public bool CancelOnHaFailover { get; set; }
  • public IDictionary<string, object> ClientProperties { get; }
  • public bool PersistentMessages { get; set; }
  • public string Platform { get; set; }
  • public string Product { get; set; }
  • public bool PublisherConfirms { get; set; }
  • public SslOption Ssl { get; }
  • public ushort Timeout { get; set; }
• public class ConsumerAttribute : Attribute
• public class ConsumerInfo
• public sealed delegate ConsumerTagConvention : MulticastDelegate
  • public ConsumerTagConvention(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke()
• public class Conventions : IConventions
  • public ConsumerTagConvention ConsumerTagConvention { get; set; }
  • public RpcReturnQueueNamingConvention RpcReturnQueueNamingConvention { get; set; }
  • public RpcRoutingKeyNamingConvention RpcRoutingKeyNamingConvention { get; set; }
  • public Conventions()
  • public Conventions(ITypeNameSerializer typeNameSerializer)
• public class CorrelationIdGenerator
• public class DefaultConsumerErrorStrategy : IConsumerErrorStrategy, IDisposable
• public class DefaultMessageDispatcher : IMessageDispatcher
• public class DefaultCorrelationIdGenerationStrategy : ICorrelationIdGenerationStrategy
  • public DefaultCorrelationIdGenerationStrategy()
  • public string GetCorrelationId()
• public class DefaultMessageSerializationStrategy : IMessageSerializationStrategy
  • public DefaultMessageSerializationStrategy(ITypeNameSerializer typeNameSerializer, ISerializer serializer, ICorrelationIdGenerationStrategy correlationIdGenerator)
  • public DeserializedMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • public SerializedMessage SerializeMessage<T>(IMessage<T> message)
• public class DefaultServiceProvider : IContainer, IServiceProvider, IServiceRegister
  • public IServiceRegister Register<TService, TImplementation>() where TImplementation : TService
  • public object Resolve(Type serviceType)
• public class EasyNetQConsumer : DefaultBasicConsumer
• public class DeserializedMessage
  • public object Message { get; }
  • public Type MessageType { get; }
  • public DeserializedMessage(Type messageType, object message)
• public class EasyNetQResponderException : EasyNetQException
  • public EasyNetQResponderException()
  • public EasyNetQResponderException(string message)
  • public EasyNetQResponderException(string format, string[] args)
  • public EasyNetQResponderException(string message, Exception inner)
  • protected EasyNetQResponderException(SerializationInfo info, StreamingContext context)
• public sealed delegate ErrorExchangeNameConvention : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(string originalRoutingKey, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(MessageReceivedInfo info, AsyncCallback callback, object object)
  • public virtual string Invoke(string originalRoutingKey)
  • public virtual string Invoke(MessageReceivedInfo info)
• public class EventBus : IEventBus
  • public EventBus()
  • public void Publish<TEvent>(TEvent event)
  • public CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
• public interface IAdvancedBus : IDisposable
  • IContainer Container { get; }
  • ISerializer Serializer { get; }
  • SerializeType SerializeType { get; }
  • IAdvancedPublishChannel OpenPublishChannel()
  • IAdvancedPublishChannel OpenPublishChannel(Action<IChannelConfiguration> configure)
  • void Subscribe<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • void Subscribe(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
  • 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 IAdvancedPublishChannel : IDisposable
• public interface IBus : IDisposable
  • IPublishChannel OpenPublishChannel()
  • IPublishChannel OpenPublishChannel(Action<IChannelConfiguration> configure)
  • void Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • void Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder, IDictionary<string, object> arguments)
  • void RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • void RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, IDictionary<string, object> arguments)
  • 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)
  • void Publish<T>(T message)
  • void Publish<T>(T message, string topic)
  • Task PublishAsync<T>(T message)
  • Task PublishAsync<T>(T message, string topic)
  • IDisposable Receive<T>(string queue, Action<T> onMessage)
  • IDisposable Receive<T>(string queue, Func<T, Task> onMessage)
  • IDisposable Receive(string queue, Action<IReceiveRegistration> addHandlers)
  • TResponse Request<TRequest, TResponse>(TRequest request)
  • Task<TResponse> RequestAsync<TRequest, TResponse>(TRequest request)
  • IDisposable Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • IDisposable RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • void Send<T>(string queue, T message)
  • IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage)
  • IDisposable Subscribe<T>(string subscriptionId, Action<T> onMessage, Action<ISubscriptionConfiguration> configure)
  • IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage)
  • IDisposable SubscribeAsync<T>(string subscriptionId, Func<T, Task> onMessage, Action<ISubscriptionConfiguration> configure)
• public interface IConnectionConfiguration
  • IDictionary<string, string> ClientProperties { get; }
  • Uri AMQPConnectionString { get; }
  • bool CancelOnHaFailover { get; }
  • IDictionary<string, object> ClientProperties { get; }
  • bool PersistentMessages { get; set; }
  • bool PublisherConfirms { get; }
  • SslOption Ssl { get; }
  • ushort Timeout { get; }
• public interface IConsume<T>
• public interface IConsumerErrorStrategy : IDisposable
• public interface IConsumerFactory : IDisposable
• public interface IContainer : IServiceProvider, IServiceRegister
• public interface IConventions
  • ConsumerTagConvention ConsumerTagConvention { get; set; }
  • RpcReturnQueueNamingConvention RpcReturnQueueNamingConvention { get; set; }
  • RpcRoutingKeyNamingConvention RpcRoutingKeyNamingConvention { get; set; }
• public interface ICorrelationIdGenerationStrategy
  • string GetCorrelationId()
• public interface IEventBus
  • void Publish<TEvent>(TEvent event)
  • CancelSubscription Subscribe<TEvent>(Action<TEvent> eventHandler)
• public interface IMessageDispatcher
• public interface IMessageSerializationStrategy
  • DeserializedMessage DeserializeMessage(MessageProperties properties, byte[] body)
  • SerializedMessage SerializeMessage<T>(IMessage<T> message)
• public interface IPersistentConnection : IDisposable
  • event Action Connected
  • event Action Disconnected
• public interface IPublishChannel : IDisposable
• public interface IPublisherConfirms
• public interface ISerializer
  • object BytesToMessage(string typeName, byte[] bytes)
• public interface IServiceRegister
  • IServiceRegister Register<TService, TImplementation>() where TImplementation : TService
• public interface ITypeNameSerializer
  • Type DeSerialize(string typeName)
  • string Serialize(Type type)
• public class JsonSerializer : ISerializer
  • public JsonSerializer()
  • public JsonSerializer(ITypeNameSerializer typeNameSerializer)
  • public object BytesToMessage(string typeName, byte[] bytes)
• 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 sealed delegate MessageCallback : MulticastDelegate
• public class MessageProperties
  • public bool AppIdPresent { get; set; }
  • public bool ClusterIdPresent { get; set; }
  • public bool ContentEncodingPresent { get; set; }
  • public bool ContentTypePresent { get; set; }
  • public bool CorrelationIdPresent { get; set; }
  • public bool DeliveryModePresent { get; set; }
  • public IDictionary Headers { get; set; }
  • public bool ExpirationPresent { get; set; }
  • public IDictionary<string, object> Headers { get; set; }
  • public bool HeadersPresent { get; set; }
  • public bool MessageIdPresent { get; set; }
  • public bool PriorityPresent { get; set; }
  • public bool ReplyToPresent { get; set; }
  • public bool TimestampPresent { get; set; }
  • public bool TypePresent { get; set; }
  • public bool UserIdPresent { get; set; }
  • public void AppendPropertyDebugStringTo(StringBuilder stringBuilder)
• public class MessageReceivedInfo
  • public string Queue { get; set; }
  • public MessageReceivedInfo(string consumerTag, ulong deliverTag, bool redelivered, string exchange, string routingKey, string queue)
• public class MessageReturnedInfo
  • public string Exchange { get; set; }
  • public string ReturnReason { get; set; }
  • public string RoutingKey { get; set; }
  • public MessageReturnedInfo(string exchange, string routingKey, string returnReason)
• public class PersistentConnection : IPersistentConnection, IDisposable
  • public event Action Connected
  • public event Action Disconnected
  • public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger)
  • public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger, IEventBus eventBus)
• public enum PostExceptionAckStrategy
• public class PublisherConfirms : IPublisherConfirms
• public class QueueingConsumerFactory : IConsumerFactory, IDisposable
• public class QueueAttribute : Attribute
  • public string ExchangeName { get; set; }
  • public string QueueName { get; }
  • public QueueAttribute(string queueName)
• public class RabbitAdvancedBus : IAdvancedBus, IDisposable
  • public const bool NoAck = false
  • public IPersistentConnection Connection { get; }
  • public IConsumerFactory ConsumerFactory { get; }
  • public IConventions Conventions { get; }
  • public Func<string> GetCorrelationId { get; }
  • public IContainer Container { get; }
  • public IEasyNetQLogger Logger { get; }
  • public virtual ISerializer Serializer { get; }
  • public virtual SerializeType SerializeType { get; }
  • public RabbitAdvancedBus(IConnectionConfiguration connectionConfiguration, IConnectionFactory connectionFactory, SerializeType serializeType, ISerializer serializer, IConsumerFactory consumerFactory, IEasyNetQLogger logger, Func<string> getCorrelationId, IConventions conventions)
  • 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 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)
  • public virtual IAdvancedPublishChannel OpenPublishChannel()
  • public virtual IAdvancedPublishChannel OpenPublishChannel(Action<IChannelConfiguration> configure)
  • public virtual void Subscribe<T>(IQueue queue, Func<IMessage<T>, MessageReceivedInfo, Task> onMessage)
  • public virtual void Subscribe(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage)
  • 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 RabbitAdvancedPublishChannel : IAdvancedPublishChannel, IDisposable
• public class RabbitBus : IBus, IDisposable
  • public SerializeType SerializeType { get; }
  • public RabbitBus(SerializeType serializeType, IEasyNetQLogger logger, IConventions conventions, IAdvancedBus advancedBus)
  • public RabbitBus(IEasyNetQLogger logger, IConventions conventions, IAdvancedBus advancedBus, IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy, IRpc rpc, ISendReceive sendReceive, IConnectionConfiguration connectionConfiguration)
  • public virtual IPublishChannel OpenPublishChannel()
  • public virtual IPublishChannel OpenPublishChannel(Action<IChannelConfiguration> configure)
  • public virtual void Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder)
  • public virtual void Respond<TRequest, TResponse>(Func<TRequest, TResponse> responder, IDictionary<string, object> arguments)
  • public virtual void RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder)
  • public virtual void RespondAsync<TRequest, TResponse>(Func<TRequest, Task<TResponse>> responder, IDictionary<string, object> arguments)
  • 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 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 void SetContainerFactory(Func<IContainer> createContainer)
• public class RabbitPublishChannel : IPublishChannel, IDisposable
• 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 SerializeType : MulticastDelegate
• public class SubscriptionAction
• public class SubscriptionInfo
• public sealed delegate RpcReturnQueueNamingConvention : MulticastDelegate
  • public RpcReturnQueueNamingConvention(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke()
• public sealed delegate RpcRoutingKeyNamingConvention : MulticastDelegate
  • public RpcRoutingKeyNamingConvention(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Type messageType, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(Type messageType)
• public class SerializedMessage
  • public byte[] Body { get; }
  • public MessageProperties Properties { get; }
  • public SerializedMessage(MessageProperties properties, byte[] messageBody)
• public static class TaskHelpers
  • public static Task ExecuteSynchronously(Action action)
  • public static Task FromException(Exception ex)
• public class TypeNameSerializer : ITypeNameSerializer
  • public Type DeSerialize(string typeName)

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 const string ConsumeMethodName = "Consume"
  • protected const string DispatchAsyncMethodName = "DispatchAsync"
  • protected const string DispatchMethodName = "Dispatch"
  • protected readonly IBus bus
  • public IAutoSubscriberMessageDispatcher AutoSubscriberMessageDispatcher { get; set; }
  • protected Func<AutoSubscriberConsumerInfo, string> GenerateSubscriptionId { get; set; }
  • public string SubscriptionIdPrefix { get; }
  • public AutoSubscriber(IBus bus, string subscriptionIdPrefix)
  • protected virtual string DefaultSubscriptionIdGenerator(AutoSubscriberConsumerInfo c)
  • protected virtual MethodInfo GetSubscribeMethodOfBus(string methodName, Type parmType)
  • protected virtual AutoSubscriberConsumerAttribute GetSubscriptionAttribute(AutoSubscriberConsumerInfo consumerInfo)
  • 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 AutoSubscriberConsumerAttribute : Attribute
  • public string SubscriptionId { get; set; }
  • public AutoSubscriberConsumerAttribute()
• public class AutoSubscriberConsumerInfo
  • public readonly Type ConcreteType
  • public readonly Type InterfaceType
  • public readonly Type MessageType
  • public AutoSubscriberConsumerInfo(Type concreteType, Type interfaceType, Type messageType)
• public class DefaultAutoSubscriberMessageDispatcher : IAutoSubscriberMessageDispatcher
  • public DefaultAutoSubscriberMessageDispatcher()
  • public void Dispatch<TMessage, TConsumer>(TMessage message) where TConsumer : IConsume<TMessage>
  • public Task DispatchAsync<TMessage, TConsumer>(TMessage message) where TConsumer : IConsumeAsync<TMessage>
• public class ForTopicAttribute : Attribute
  • public string Topic { get; set; }
  • public ForTopicAttribute(string topic)
• public interface IAutoSubscriberMessageDispatcher
  • 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)
• public interface IConsumeAsync<T>
  • Task Consume(T message)

EasyNetQ.ConnectionString

• public static class ConnectionStringGrammar
  • public static Parser<Uri> AMQP
  • public static Parser<Func<ConnectionConfiguration, ConnectionConfiguration>> AMQPAlone
  • public static Parser<bool> Bool

EasyNetQ.Consumer

• public static class AckStrategies
  • public static AckStrategy Ack
  • public static AckStrategy NackWithoutRequeue
  • public static AckStrategy NackWithRequeue
  • public static AckStrategy Nothing
• public sealed delegate AckStrategy : MulticastDelegate
  • public AckStrategy(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(IModel model, ulong deliveryTag, AsyncCallback callback, object object)
  • public virtual AckResult EndInvoke(IAsyncResult result)
  • public virtual AckResult Invoke(IModel model, ulong deliveryTag)
• public class ConsumerCancellation : IDisposable
  • public ConsumerCancellation(Action onCancellation)
  • public void Dispose()
• public class ConsumerConfiguration : IConsumerConfiguration
  • public bool CancelOnHaFailover { get; }
  • public ushort PrefetchCount { get; }
  • 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 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(IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus)
  • public IConsumer CreateConsumer(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
  • public void Dispose()
• 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 bool ThrowOnNoMatchingHandler { get; set; }
  • 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(IEasyNetQLogger logger)
  • public IHandlerCollection CreateHandlerCollection()
• 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
  • IDisposable StartConsuming()
• 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(IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration)
• public interface IHandlerCollection : IHandlerRegistration
  • Func<IMessage<T>, MessageReceivedInfo, Task> GetHandler<T>()
  • object GetHandler(Type messageType)
• public interface IHandlerCollectionFactory
  • IHandlerCollection CreateHandlerCollection()
• public interface IHandlerRegistration
  • 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 Action<IInternalConsumer> Cancelled
  • void StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
• public interface IInternalConsumerFactory : IDisposable
  • IInternalConsumer CreateConsumer()
  • void OnDisconnected()
• public class InternalConsumer : IBasicConsumer, IInternalConsumer, IDisposable
  • public string ConsumerTag { get; }
  • public IModel Model { get; }
  • public event Action<IInternalConsumer> Cancelled
  • public event ConsumerCancelledEventHandler ConsumerCancelled
  • public InternalConsumer(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConsumerDispatcher consumerDispatcher, IConventions conventions, IConnectionConfiguration connectionConfiguration, IEventBus eventBus)
  • public void Dispose()
  • public void HandleBasicCancel(string consumerTag)
  • public void HandleBasicCancelOk(string consumerTag)
  • public void HandleBasicConsumeOk(string consumerTag)
  • public void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
  • public void HandleModelShutdown(IModel model, ShutdownEventArgs reason)
  • public void StartConsuming(IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration)
• public class InternalConsumerFactory : IInternalConsumerFactory, IDisposable
  • public InternalConsumerFactory(IHandlerRunner handlerRunner, IEasyNetQLogger logger, IConventions conventions, IConnectionConfiguration connectionConfiguration, IConsumerDispatcherFactory consumerDispatcherFactory, IEventBus eventBus)
  • public IInternalConsumer CreateConsumer()
  • public void Dispose()
  • public void OnDisconnected()
• 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.Events

• public class AckEvent
  • public AckResult AckResult { get; }
  • public ConsumerExecutionContext ConsumerExecutionContext { get; }
  • public AckEvent(ConsumerExecutionContext consumerExecutionContext, AckResult ackResult)
• public enum AckResult
  • Ack = 0
  • Exception = 2
  • Nack = 1
  • Nothing = 3
• public class ConnectionCreatedEvent
  • public ConnectionCreatedEvent()
• public class ConnectionDisconnectedEvent
  • public ConnectionDisconnectedEvent()
• public class ConsumerModelDisposedEvent
  • public string ConsumerTag { get; }
  • public ConsumerModelDisposedEvent(string consumerTag)
• public class PublishChannelCreatedEvent
  • public IModel Channel { get; }
  • public PublishChannelCreatedEvent(IModel channel)
• public class ReturnedMessageEvent
  • public byte[] Body { get; set; }
  • public MessageReturnedInfo Info { get; set; }
  • public MessageProperties Properties { get; set; }
  • public ReturnedMessageEvent(byte[] body, MessageProperties properties, MessageReturnedInfo info)
• public class StoppedConsumingEvent
  • public IConsumer Consumer { get; }
  • public StoppedConsumingEvent(IConsumer consumer)

EasyNetQ.FluentConfiguration

• public class AdvancedPublishConfiguration : IAdvancedPublishConfiguration
• public class ChannelConfiguration : IChannelConfiguration
• public interface IAdvancedPublishConfiguration
• public interface IChannelConfiguration
• public interface IPublishConfiguration<T>
• public interface ISubscriptionConfiguration<T>
• public class PublishConfiguration<T> : IPublishConfiguration<T>
• public class SubscriptionConfiguration<T> : ISubscriptionConfiguration<T>
• 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.Loggers

• 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.MessageVersioning

• public interface ISupersede<T>
• public class MessageType
  • public Type Type { get; set; }
  • public string TypeString { get; set; }
  • public MessageType()
• public class MessageTypeProperty
  • public static MessageTypeProperty CreateForMessageType(Type messageType, ITypeNameSerializer typeNameSerializer)
  • public static MessageTypeProperty ExtractFromProperties(MessageProperties messageProperties, ITypeNameSerializer typeNameSerializer)
  • public void AppendTo(MessageProperties messageProperties)
  • public MessageType GetMessageType()
• public static class MessageVersioningExtensions
  • public static IServiceRegister EnableMessageVersioning(this IServiceRegister serviceRegister)
• public class MessageVersionStack : IEnumerable<Type>, IEnumerable
  • public MessageVersionStack(Type messageType)
  • public IEnumerator<Type> GetEnumerator()
  • public bool IsEmpty()
  • public Type Pop()
• public class VersionedMessageSerializationStrategy : IMessageSerializationStrategy
  • public VersionedMessageSerializationStrategy(ITypeNameSerializer typeNameSerializer, ISerializer serializer, ICorrelationIdGenerationStrategy correlationIdGenerator)
  • 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.NonGeneric

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

EasyNetQ.Producer

• public class ClientCommandDispatcher : IClientCommandDispatcher, IDisposable
  • public ClientCommandDispatcher(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 PublishNackedException : Exception
  • public PublishNackedException()
  • public PublishNackedException(string message)
  • public PublishNackedException(string message, Exception inner)
  • protected PublishNackedException(SerializationInfo info, StreamingContext context)
• 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 MessageBasicProperties BasicProperties { get; set; }
  • public MessageProperties BasicProperties { get; set; }
• public class MessageBasicProperties
• public class ScheduleMe
  • public string CancellationKey { get; set; }
• public class UnscheduleMe
  • public string CancellationKey { get; set; }
  • public UnscheduleMe()

EasyNetQ.Topology

• public class Binding : IBinding
  • public string[] RoutingKeys { get; }
  • public Binding(IBindable bindable, IExchange exchange, string[] routingKeys)
  • public void Visit(ITopologyVisitor visitor)
  • public string RoutingKey { get; }
  • public Binding(IBindable bindable, IExchange exchange, string routingKey)
• public class DefaultExchange : Exchange
• public class Exchange : IExchange, IBindable
  • protected readonly IList<IBinding> bindings
  • public IDictionary Arguments { get; }
  • public bool AutoDelete { get; }
  • public string ExchangeType { get; }
  • protected Exchange(string name, string exchangeType)
  • protected Exchange(string name, string exchangeType, bool autoDelete, IDictionary arguments)
  • public static IExchange DeclareDirect(string exchangeName)
  • public static IExchange DeclareDirect(string exchangeName, bool autoDelete, IDictionary arguments)
  • public static IExchange DeclareFanout(string exchangeName)
  • public static IExchange DeclareFanout(string exchangeName, bool autoDelete, IDictionary arguments)
  • public static IExchange DeclareTopic(string exchangeName)
  • public static IExchange DeclareTopic(string exchangeName, bool autoDelete, IDictionary arguments)
  • public Exchange(string name)
  • public virtual void BindTo(IExchange exchange, string[] routingKeys)
  • public virtual void Visit(ITopologyVisitor visitor)
• public class ExchangeType
  • public const string Header = "headers"
• public interface IBindable
  • void BindTo(IExchange exchange, string[] routingKeys)
• public interface IBinding
  • string[] RoutingKeys { get; }
  • string RoutingKey { get; }
• public interface IQueue : IBindable
  • bool IsSingleUse { get; }
  • bool IsExclusive { get; }
  • IQueue SetAsSingleUse()
• public interface ITopology
• public interface ITopologyVisitor
• public class Queue : IQueue, IBindable
  • public bool IsSingleUse { get; }
  • public bool IsExclusive { get; }
  • protected Queue(bool durable, bool exclusive, bool autoDelete, string name, IDictionary<string, object> arguements)
  • protected Queue(bool durable, bool exclusive, bool autoDelete, IDictionary<string, object> arguments)
  • public static IQueue Declare(bool durable, bool exclusive, bool autoDelete, IDictionary<string, object> arguments)
  • public static IQueue Declare(bool durable, bool exclusive, bool autoDelete, string name, IDictionary<string, object> arguments)
  • public static IQueue DeclareDurable(string queueName)
  • public static IQueue DeclareDurable(string queueName, IDictionary<string, object> arguments)
  • public static IQueue DeclareTransient(string queueName)
  • public static IQueue DeclareTransient(string queueName, IDictionary<string, object> arguments)
  • public static IQueue DeclareTransient()
  • public void BindTo(IExchange exchange, string[] routingKeys)
  • public IQueue SetAsSingleUse()
  • public void Visit(ITopologyVisitor visitor)
  • public Queue(string name, bool isExclusive)
• public class TopologyBuilder : ITopologyVisitor

Sprache

• public static class Parse
  • public static Parser<IEnumerable<char>> CaseInsensitiveString(string s)
  • public static Parser<char> CharCaseInsensitive(char c)