public ConventionTypeCache(IConventionTypeCacheFactory <TValue> typeFactory, IInitializerConvention convention)
{
_typeFactory = typeFactory ?? throw new ArgumentNullException(nameof(typeFactory));
_convention = convention;
_dictionary = new ConcurrentDictionary <Type, Cached>();
}
public void Apply(IMessageInitializerBuilder <TMessage, TInput> builder, IInitializerConvention convention)
{
if (convention.TryGetMessagePropertyInitializer <TMessage, TInput, TProperty>(_propertyName, out var initializer))
{
builder.Add(_propertyName, initializer);
}
}
public bool Apply(IMessageInitializerBuilder <TMessage, TInput> builder, IInitializerConvention convention)
{
if (builder.IsInputPropertyUsed(_propertyName))
{
return(false);
}
if (convention.TryGetHeaderInitializer(_propertyName, out IHeaderInitializer <TMessage, TInput> initializer))
{
builder.Add(initializer);
builder.SetInputPropertyUsed(_propertyName);
return(true);
}
return(false);
}
public bool Apply(IMessageInitializerBuilder <TMessage, TInput> builder, IInitializerConvention convention)
{
if (builder.IsInputPropertyUsed(_propertyInfo.Name))
{
return(false);
}
if (!WritePropertyCache <TMessage> .CanWrite(_propertyInfo.Name))
{
return(false);
}
if (convention.TryGetPropertyInitializer <TMessage, TInput, TProperty>(_propertyInfo, out IPropertyInitializer <TMessage, TInput> initializer))
{
builder.Add(_propertyInfo.Name, initializer);
builder.SetInputPropertyUsed(_propertyInfo.Name);
return(true);
}
return(false);
}
IMessageInputInitializerConvention <TMessage> IConventionTypeCacheFactory <IMessageInputInitializerConvention <TMessage> > .Create <T>(
IInitializerConvention convention)
{
return(new DefaultInitializerConvention <TMessage, T>());
}
IMessageInitializerConvention IConventionTypeCacheFactory <IMessageInitializerConvention> .Create <T>(IInitializerConvention convention)
{
return(new DictionaryInitializerConvention <T>(convention));
}
IMessageInputInitializerConvention <TMessage> IConventionTypeCacheFactory <IMessageInputInitializerConvention <TMessage> > .Create <T>(
IInitializerConvention convention)
{
if (typeof(T).ClosesType(typeof(IDictionary <,>), out Type[] argumentTypes) && argumentTypes[0] == typeof(string))
IMessageTypeInitializerConvention <TMessage> IConventionTypeCacheFactory <IMessageTypeInitializerConvention <TMessage> > .Create <T>(
IInitializerConvention convention)
{
return(new CopyInitializerConvention <TMessage, T>());
}
protected InitializerConvention(IConventionTypeCacheFactory <IMessageInputInitializerConvention <TMessage> > cacheFactory, IInitializerConvention
convention)
{
_typeCache = new ConventionTypeCache <IMessageInputInitializerConvention <TMessage> >(cacheFactory, convention);
}
