public MetaDataMessageSerializationStrategy(ITypeNameSerializer typeNameSerializer, ISerializer serializer, ICorrelationIdGenerationStrategy correlationIdGenerator)
{
_typeNameSerializer = typeNameSerializer ?? throw new ArgumentNullException(nameof(typeNameSerializer));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
_correlationIdGenerator = correlationIdGenerator ?? throw new ArgumentNullException(nameof(correlationIdGenerator));
_bindingCache = new ConcurrentDictionary <Type, List <IMetaDataBinding> >();
}
public DefaultRpc(
ConnectionConfiguration configuration,
IAdvancedBus advancedBus,
IEventBus eventBus,
IConventions conventions,
IExchangeDeclareStrategy exchangeDeclareStrategy,
IMessageDeliveryModeStrategy messageDeliveryModeStrategy,
ITypeNameSerializer typeNameSerializer,
ICorrelationIdGenerationStrategy correlationIdGenerationStrategy
)
{
Preconditions.CheckNotNull(configuration, "configuration");
Preconditions.CheckNotNull(advancedBus, "advancedBus");
Preconditions.CheckNotNull(eventBus, "eventBus");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(exchangeDeclareStrategy, "publishExchangeDeclareStrategy");
Preconditions.CheckNotNull(messageDeliveryModeStrategy, "messageDeliveryModeStrategy");
Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
Preconditions.CheckNotNull(correlationIdGenerationStrategy, "correlationIdGenerationStrategy");
this.configuration = configuration;
this.advancedBus = advancedBus;
this.conventions = conventions;
this.exchangeDeclareStrategy = exchangeDeclareStrategy;
this.messageDeliveryModeStrategy = messageDeliveryModeStrategy;
this.typeNameSerializer = typeNameSerializer;
this.correlationIdGenerationStrategy = correlationIdGenerationStrategy;
eventSubscription = eventBus.Subscribe <ConnectionRecoveredEvent>(OnConnectionRecovered);
}
public Rpc(
ConnectionConfiguration connectionConfiguration,
IAdvancedBus advancedBus,
IEventBus eventBus,
IConventions conventions,
IExchangeDeclareStrategy exchangeDeclareStrategy,
IMessageDeliveryModeStrategy messageDeliveryModeStrategy,
ITimeoutStrategy timeoutStrategy,
ITypeNameSerializer typeNameSerializer)
{
Preconditions.CheckNotNull(connectionConfiguration, nameof(connectionConfiguration));
Preconditions.CheckNotNull(advancedBus, nameof(advancedBus));
Preconditions.CheckNotNull(eventBus, nameof(eventBus));
Preconditions.CheckNotNull(conventions, nameof(conventions));
Preconditions.CheckNotNull(exchangeDeclareStrategy, nameof(exchangeDeclareStrategy));
Preconditions.CheckNotNull(messageDeliveryModeStrategy, nameof(messageDeliveryModeStrategy));
Preconditions.CheckNotNull(timeoutStrategy, nameof(timeoutStrategy));
Preconditions.CheckNotNull(typeNameSerializer, nameof(typeNameSerializer));
this.connectionConfiguration = connectionConfiguration;
this.advancedBus = advancedBus;
this.conventions = conventions;
this.exchangeDeclareStrategy = exchangeDeclareStrategy;
this.messageDeliveryModeStrategy = messageDeliveryModeStrategy;
this.timeoutStrategy = timeoutStrategy;
this.typeNameSerializer = typeNameSerializer;
eventBus.Subscribe <ConnectionCreatedEvent>(OnConnectionCreated);
}
public ConsumerErrorStrategy(IUserRepository userRepository, IConnectionFactory connectionFactory, ITypeNameSerializer typeNameSerializer, ILogger <ConsumerErrorStrategy> logger)
{
_userRepository = userRepository;
_connectionFactory = connectionFactory;
_typeNameSerializer = typeNameSerializer;
_logger = logger;
}
public MyConventions(ITypeNameSerializer typeNameSerializer) : base(typeNameSerializer)
{
ExchangeNamingConvention = type => $"{type.FullName}, Exchange";
QueueNamingConvention = (type, id) => $"{type.FullName}, Queue";
ErrorQueueNamingConvention = info => "ErrorQueue";
ErrorExchangeNamingConvention = info => "BusErrorExchange_" + info.RoutingKey;
}
public Rpc(
ConnectionConfiguration connectionConfiguration,
IAdvancedBus advancedBus,
IEventBus eventBus,
IConventions conventions,
IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy,
IMessageDeliveryModeStrategy messageDeliveryModeStrategy,
ITimeoutStrategy timeoutStrategy,
ITypeNameSerializer typeNameSerializer)
{
Preconditions.CheckNotNull(connectionConfiguration, "configuration");
Preconditions.CheckNotNull(advancedBus, "advancedBus");
Preconditions.CheckNotNull(eventBus, "eventBus");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(publishExchangeDeclareStrategy, "publishExchangeDeclareStrategy");
Preconditions.CheckNotNull(messageDeliveryModeStrategy, "messageDeliveryModeStrategy");
Preconditions.CheckNotNull(timeoutStrategy, "timeoutStrategy");
Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
this.connectionConfiguration = connectionConfiguration;
this.advancedBus = advancedBus;
this.conventions = conventions;
this.publishExchangeDeclareStrategy = publishExchangeDeclareStrategy;
this.messageDeliveryModeStrategy = messageDeliveryModeStrategy;
this.timeoutStrategy = timeoutStrategy;
this.typeNameSerializer = typeNameSerializer;
eventBus.Subscribe <ConnectionCreatedEvent>(OnConnectionCreated);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the MicroServiceEcoSystem.AttributeBasedConventions class.
/// </summary>
///
/// <exception cref="ArgumentNullException"> Thrown when one or more required arguments are
/// null. </exception>
///
/// <param name="typeNameSerializer"> The type name serializer. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
public AttributeBasedConventions(ITypeNameSerializer typeNameSerializer)
: base(typeNameSerializer)
{
_typeNameSerializer = typeNameSerializer ?? throw new ArgumentNullException("typeNameSerializer");
ExchangeNamingConvention = GenerateExchangeName;
QueueNamingConvention = GenerateQueueName;
}
public DefaultMessageValidationStrategy(IEasyNetQLogger logger, ITypeNameSerializer typeNameSerializer)
{
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
this.logger = logger;
this.typeNameSerializer = typeNameSerializer;
}
public DefaultMessageSerializationStrategy(
ITypeNameSerializer typeNameSerializer,
ICorrelationIdGenerationStrategy correlationIdGenerator)
{
this.typeNameSerializer = typeNameSerializer;
this.correlationIdGenerator = correlationIdGenerator;
serializer = SerializationHelper.MsgPack;
}
public TestConventions(ITypeNameSerializer typeNameSerializer) : base(typeNameSerializer)
{
QueueNamingConvention = (messageType, subscriptionId) =>
{
var typeName = typeNameSerializer.Serialize(messageType);
return(string.Format("{0}_{1}", typeName, subscriptionId));
};
}
public DefaultConsumerErrorStrategy(
IConnectionFactory connectionFactory,
ITypeNameSerializer typeNameSerializer)
{
this.connectionFactory = connectionFactory;
serializer = SerializationHelper.MsgPack;
this.typeNameSerializer = typeNameSerializer;
errorExchanges = new ConcurrentDictionary <string, string>();
}
public NackConsumerErrorStrategy(
IConnectionFactory connectionFactory,
ISerializer serializer,
IEasyNetQLogger logger,
IConventions conventions,
ITypeNameSerializer typeNameSerializer)
: base(connectionFactory, serializer, logger, conventions, typeNameSerializer)
{
}
public ConsumerErrorStrategy(
IConnectionFactory connectionFactory,
ISerializer serializer,
IConventions conventions,
ITypeNameSerializer typeNameSerializer,
IErrorMessageSerializer errorMessageSerializer)
: base(connectionFactory, serializer, conventions, typeNameSerializer, errorMessageSerializer)
{
}
public TestConventions(ITypeNameSerializer typeNameSerializer) : base(typeNameSerializer)
{
QueueNamingConvention = (messageType, subscriptionId) =>
{
var typeName = typeNameSerializer.Serialize(messageType);
return string.Format("{0}_{1}", typeName, subscriptionId);
};
}
public BackgroundConsumeRetryStrategy(IConsumeRetryScheduler retryScheduler, IPlatformBus platformBus)
{
this.retryScheduler = retryScheduler;
this.platformBus = platformBus as PlatformBus;
if (this.platformBus != null)
{
this.typeNameSerializer = this.platformBus.CoreBus.Container.Resolve <ITypeNameSerializer>();
}
NextSleepInterval = 15000;
}
/// <summary>
/// Creates DefaultMessageSerializationStrategy
/// </summary>
/// <param name="typeNameSerializer">The type name serialized</param>
/// <param name="serializer">The serializer</param>
/// <param name="correlationIdGenerator">The correlation id generator</param>
public DefaultMessageSerializationStrategy(
ITypeNameSerializer typeNameSerializer,
ISerializer serializer,
ICorrelationIdGenerationStrategy correlationIdGenerator
)
{
this.typeNameSerializer = typeNameSerializer;
this.serializer = serializer;
this.correlationIdGenerator = correlationIdGenerator;
}
public Conventions(ITypeNameSerializer typeNameSerializer)
{
Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
// Establish default conventions.
ExchangeNamingConvention = messageType =>
{
var attr = GetQueueAttribute(messageType);
return(string.IsNullOrEmpty(attr.ExchangeName)
? typeNameSerializer.Serialize(messageType)
: attr.ExchangeName);
};
TopicNamingConvention = messageType => "";
QueueNamingConvention =
(messageType, subscriptionId) =>
{
var attr = GetQueueAttribute(messageType);
if (string.IsNullOrEmpty(attr.QueueName))
{
var typeName = typeNameSerializer.Serialize(messageType);
return(string.IsNullOrEmpty(subscriptionId)
? typeName
: string.Format("{0}_{1}", typeName, subscriptionId));
}
return(string.IsNullOrEmpty(subscriptionId)
? attr.QueueName
: string.Format("{0}_{1}", attr.QueueName, subscriptionId));
};
//RpcRoutingKeyNamingConvention = typeNameSerializer.Serialize;
//RpcRequestExchangeNamingConvention = (type) => "easy_net_q_rpc";
//RpcResponseExchangeNamingConvention = (type) => "easy_net_q_rpc";
//RpcReturnQueueNamingConvention = () => "easynetq.response." + Guid.NewGuid();
ErrorQueueNamingConvention = () => "default-error-queue";
ErrorExchangeNamingConvention = info => "error-exchagne-" + info.RoutingKey;
//RpcRoutingKeyNamingConvention = typeNameSerializer.Serialize;
//RpcRequestExchangeNamingConvention = (type) => "HMI.Control";
//RpcResponseExchangeNamingConvention = (type) => "HMI.Control";
//RpcReturnQueueNamingConvention = () => "Result.Queue." + Guid.NewGuid();
RpcRoutingKeyNamingConvention = (type) => "rpc-routingkey";
RpcRequestExchangeNamingConvention = (type) => "rpc-ex";
RpcResponseExchangeNamingConvention = (type) => "rpc-ex";
RpcReturnQueueNamingConvention = () => "reply-queue-" + Guid.NewGuid();
ConsumerTagConvention = () => Guid.NewGuid().ToString();
}
public TypedMessageSerializationStrategy(
bool useCorrelationIds,
ITypeNameSerializer typeNameSerializer,
ISerializer serializer,
ICorrelationIdGenerationStrategy correlationIdGenerator)
{
_useCorrelationIds = useCorrelationIds;
_typeNameSerializer = typeNameSerializer;
_serializer = serializer;
_correlationIdGenerator = correlationIdGenerator;
}
public MyConventions(ITypeNameSerializer typeNameSerializer) : base(typeNameSerializer)
{
ErrorQueueNamingConvention = messageInfo => "MyErrorQueue";
ExchangeNamingConvention = (msg) =>
{
if (msg.Equals(typeof(AppRoomRequest)))
{
}
return("");
};
}
public ConsumerErrorStrategy(IConnectionFactory connectionFactory, ISerializer serializer,
IEasyNetQLogger logger, IConventions conventions, ITypeNameSerializer typeNameSerializer)
: base(connectionFactory, serializer, logger, conventions, typeNameSerializer)
{
this.logger = logger;
this.connectionFactory = connectionFactory;
this.typeNameSerializer = typeNameSerializer;
this.serializer = serializer;
this.conventions = conventions;
this.maxAttemptsCount = ServiceBusSection.Current.MaxConsumeRetry;
}
private MessageTypeProperty( ITypeNameSerializer typeNameSerializer, string messageType, string alternativeTypesHeader )
{
this.typeNameSerializer = typeNameSerializer;
this.messageType = messageType;
alternativeTypes = new List<string>();
if( !string.IsNullOrWhiteSpace( alternativeTypesHeader ) )
alternativeTypes = alternativeTypesHeader
.Split( new[] {AlternativeMessageTypeSeparator}, StringSplitOptions.RemoveEmptyEntries )
.ToList();
}
public ConsumerErrorStategy(
ILoggerFactory loggerFactory,
EasyNetQComponent.IConnectionFactory connectionFactory,
ITypeNameSerializer typeNameSerializer
)
{
this._logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.connectionFactory = connectionFactory;
this.typeNameSerializer = typeNameSerializer;
}
public ConsumerErrorStrategy(
IPersistentConnection connection,
ISerializer serializer,
IConventions conventions,
ITypeNameSerializer typeNameSerializer,
IErrorMessageSerializer errorMessageSerializer,
ConnectionConfiguration connectionConfiguration,
IServiceProvider serviceProvider) : base(
connection, serializer, conventions, typeNameSerializer, errorMessageSerializer, connectionConfiguration)
{
_logger = serviceProvider.GetService <ILogger <ConsumerErrorStrategy> >();
}
public HandlerAuditIntercepter(
ILogger logger,
IConnectionFactory connectionFactory,
ISerializer serializer,
ITypeNameSerializer typeNameSerializer,
IPersistCorrelation correlationPersister)
{
_logger = logger;
_connectionFactory = connectionFactory;
_serializer = serializer;
_typeNameSerializer = typeNameSerializer;
_correlationPersister = correlationPersister;
}
public ConsumerErrorStrategy(
EasyNetQ.IConnectionFactory connectionFactory,
ISerializer serializer,
IEasyNetQLogger logger,
IConventions conventions,
ITypeNameSerializer typeNameSerializer)
{
this.connectionFactory = connectionFactory;
this.serializer = serializer;
this.logger = logger;
this.conventions = conventions;
this.typeNameSerializer = typeNameSerializer;
}
private MessageTypeProperty( ITypeNameSerializer typeNameSerializer, Type messageType )
{
this.typeNameSerializer = typeNameSerializer;
var messageVersions = new MessageVersionStack( messageType );
// MessageVersionStack has most recent version at the bottom of the stack (hence the reverse)
// and includes the actual message type (hence the first / removeat)
alternativeTypes = messageVersions
.Select( typeNameSerializer.Serialize )
.Reverse()
.ToList();
this.messageType = alternativeTypes.First();
alternativeTypes.RemoveAt( 0 );
}
public void SetUp()
{
typeNameSerializer = new TypeNameSerializer();
var customConventions = new Conventions(typeNameSerializer)
{
ExchangeNamingConvention = x => "CustomExchangeNamingConvention",
QueueNamingConvention = (x, y) => "CustomQueueNamingConvention",
TopicNamingConvention = x => "CustomTopicNamingConvention"
};
mockBuilder = new MockBuilder(x => x.Register <IConventions>(_ => customConventions));
mockBuilder.Bus.Publish(new TestMessage());
}
private MessageTypeProperty(ITypeNameSerializer typeNameSerializer, string messageType, string alternativeTypesHeader)
{
this.typeNameSerializer = typeNameSerializer;
this.messageType = messageType;
alternativeTypes = new List <string>();
if (!string.IsNullOrWhiteSpace(alternativeTypesHeader))
{
alternativeTypes = alternativeTypesHeader
.Split(new[] { AlternativeMessageTypeSeparator }, StringSplitOptions.RemoveEmptyEntries)
.ToList();
}
}
public void SetUp()
{
typeNameSerializer = new TypeNameSerializer();
var customConventions = new Conventions(typeNameSerializer)
{
ExchangeNamingConvention = x => "CustomExchangeNamingConvention",
QueueNamingConvention = (x, y) => "CustomQueueNamingConvention",
TopicNamingConvention = x => "CustomTopicNamingConvention"
};
mockBuilder = new MockBuilder(x => x.Register<IConventions>(_ => customConventions));
mockBuilder.Bus.Publish(new TestMessage());
}
public static MessageTypeProperty ExtractFromProperties( MessageProperties messageProperties, ITypeNameSerializer typeNameSerializer )
{
var messageType = messageProperties.Type;
if( !messageProperties.HeadersPresent || !messageProperties.Headers.ContainsKey( AlternativeMessageTypesHeaderKey ) )
return new MessageTypeProperty( typeNameSerializer, messageType, null );
var rawHeader = messageProperties.Headers[ AlternativeMessageTypesHeaderKey ] as byte[];
if( rawHeader == null )
throw new EasyNetQException( "{0} header was present but contained no data or was not encoded as a byte[].", AlternativeMessageTypesHeaderKey );
var alternativeTypesHeader = Encoding.UTF8.GetString( rawHeader );
return new MessageTypeProperty( typeNameSerializer, messageType, alternativeTypesHeader );
}
public CustomErrorStrategy(
EasyNetQ.IConnectionFactory connectionFactory,
ISerializer serializer,
IEasyNetQLogger logger,
IConventions conventions,
ITypeNameSerializer typeNameSerializer)
{
this.connectionFactory = connectionFactory;
this.serializer = serializer;
this.logger = logger;
this.conventions = conventions;
this.typeNameSerializer = typeNameSerializer;
}
private MessageTypeProperty(ITypeNameSerializer typeNameSerializer, Type messageType)
{
this.typeNameSerializer = typeNameSerializer;
var messageVersions = new MessageVersionStack(messageType);
// MessageVersionStack has most recent version at the bottom of the stack (hence the reverse)
// and includes the actual message type (hence the first / removeat)
alternativeTypes = messageVersions
.Select(typeNameSerializer.Serialize)
.Reverse()
.ToList();
this.messageType = alternativeTypes.First();
alternativeTypes.RemoveAt(0);
}
public AttributeBasedConventions(ITypeNameSerializer typeNameSerializer)
: base(typeNameSerializer)
{
if (typeNameSerializer == null)
{
throw new ArgumentNullException(nameof(typeNameSerializer));
}
_typeNameSerializer = typeNameSerializer;
ExchangeNamingConvention = GenerateExchangeName;
QueueNamingConvention = GenerateQueueName;
TopicNamingConvention = GenerateTopicName;
}
public PlatformConventions(ITypeNameSerializer typeNameSerializer)
: base(typeNameSerializer)
{
var identity = ConfigurationManager.AppSettings["Identity"];
if (!string.IsNullOrEmpty(identity))
{
ConsumerTagConvention = () => identity;
}
this.ErrorQueueNamingConvention = () => $"{identity}_ErrorQueue";
this.ErrorExchangeNamingConvention = info => $"{identity}_ErrorExchange";
}
public EventBusConventions(ITypeNameSerializer typeNameSerializer) : base(typeNameSerializer)
{
ExchangeNamingConvention = type =>
{
QueueAttribute MyAttribute = (QueueAttribute)Attribute.GetCustomAttribute(type, typeof(QueueAttribute));
return(MyAttribute.ExchangeName);
};
RpcRoutingKeyNamingConvention = type =>
{
QueueAttribute MyAttribute = (QueueAttribute)Attribute.GetCustomAttribute(type, typeof(QueueAttribute));
return(MyAttribute.QueueName);
};
//ErrorQueueNamingConvention = info => "ErrorQueue";
//ErrorExchangeNamingConvention = info => "BusErrorExchange_" + info.RoutingKey + assemblyName;
}
public EasyNetQOutputMessageChannel(
IBus bus,
ITypeNameSerializer serializer,
IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy,
IMessageDeliveryModeStrategy messageDeliveryModeStrategy)
{
Guard.NotNull(messageDeliveryModeStrategy, nameof(messageDeliveryModeStrategy));
Guard.NotNull(publishExchangeDeclareStrategy, nameof(publishExchangeDeclareStrategy));
Guard.NotNull(serializer, nameof(serializer));
Guard.NotNull(bus, nameof(bus));
this.bus = bus;
this.serializer = serializer;
this.publishExchangeDeclareStrategy = publishExchangeDeclareStrategy;
this.messageDeliveryModeStrategy = messageDeliveryModeStrategy;
}
public Conventions(ITypeNameSerializer typeNameSerializer)
{
Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
// Establish default conventions.
this.TopicNamingConvention = messageType => string.Empty;
this.RpcRoutingKeyNamingConvention = typeNameSerializer.Serialize;
this.ErrorQueueNamingConvention = () => "AzureNetQ_Default_Error_Queue";
this.RpcReturnQueueNamingConvention = () => "azurenetq.response." + Guid.NewGuid();
this.ConsumerTagConvention = () => Guid.NewGuid().ToString();
this.QueueNamingConvention = messageType =>
{
var typeName = typeNameSerializer.Serialize(messageType);
return string.Format("{0}", typeName);
};
}
public Conventions(ITypeNameSerializer typeNameSerializer)
{
Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
// Establish default conventions.
this.TopicNamingConvention = messageType => string.Empty;
this.RpcRoutingKeyNamingConvention = typeNameSerializer.Serialize;
this.ErrorQueueNamingConvention = () => "AzureNetQ_Default_Error_Queue";
this.RpcReturnQueueNamingConvention = () => "azurenetq.response." + Guid.NewGuid();
this.ConsumerTagConvention = () => Guid.NewGuid().ToString();
this.QueueNamingConvention = messageType =>
{
var typeName = typeNameSerializer.Serialize(messageType);
return(string.Format("{0}", typeName));
};
}
public Conventions(ITypeNameSerializer typeNameSerializer)
{
Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
// Establish default conventions.
ExchangeNamingConvention = messageType =>
{
var attr = GetQueueAttribute(messageType);
return string.IsNullOrEmpty(attr.ExchangeName)
? typeNameSerializer.Serialize(messageType)
: attr.ExchangeName;
};
TopicNamingConvention = messageType => "";
QueueNamingConvention =
(messageType, subscriptionId) =>
{
var attr = GetQueueAttribute(messageType);
if (string.IsNullOrEmpty(attr.QueueName))
{
var typeName = typeNameSerializer.Serialize(messageType);
return string.IsNullOrEmpty(subscriptionId)
? typeName
: string.Format("{0}_{1}", typeName, subscriptionId);
}
return string.IsNullOrEmpty(subscriptionId)
? attr.QueueName
: string.Format("{0}_{1}", attr.QueueName, subscriptionId);
};
RpcRoutingKeyNamingConvention = typeNameSerializer.Serialize;
ErrorQueueNamingConvention = () => "EasyNetQ_Default_Error_Queue";
ErrorExchangeNamingConvention = info => "ErrorExchange_" + info.RoutingKey;
RpcExchangeNamingConvention = () => "easy_net_q_rpc";
RpcReturnQueueNamingConvention = () => "easynetq.response." + Guid.NewGuid().ToString();
ConsumerTagConvention = () => Guid.NewGuid().ToString();
}
public DefaultConsumerErrorStrategy(
IConnectionFactory connectionFactory,
ISerializer serializer,
IEasyNetQLogger logger,
IConventions conventions,
ITypeNameSerializer typeNameSerializer)
{
Preconditions.CheckNotNull(connectionFactory, "connectionFactory");
Preconditions.CheckNotNull(serializer, "serializer");
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
this.connectionFactory = connectionFactory;
this.serializer = serializer;
this.logger = logger;
this.conventions = conventions;
this.typeNameSerializer = typeNameSerializer;
}
public MyConventions(ITypeNameSerializer typeNameSerializer)
{
_typeNameSerializer = typeNameSerializer;
ExchangeNamingConvention = type => { return string.Format("exchange{0}_", type.Name.Replace(".", "_")); };
ConventionsCallCount++;
}
public void SetUp()
{
typeNameSerializer = new TypeNameSerializer();
}
public static MessageTypeProperty CreateForMessageType(Type messageType, ITypeNameSerializer typeNameSerializer)
{
return new MessageTypeProperty( typeNameSerializer, messageType );
}
public void SetUp()
{
typeNameSerializer = new TypeNameSerializer();
conventions = new Conventions(typeNameSerializer);
}
