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); }