DefaultConversionManager
public class DefaultConversionManager : AbstractSubSystem, IConversionManager, ITypeConverter, ISubSystem, ITypeConverterContext
Composition of all available conversion managers
using Castle.Core;
using Castle.Core.Configuration;
using Castle.MicroKernel.Context;
using System;
using System.Collections.Generic;
namespace Castle.MicroKernel.SubSystems.Conversion
{
[Serializable]
public class DefaultConversionManager : AbstractSubSystem, IConversionManager, ITypeConverter, ISubSystem, ITypeConverterContext
{
[ThreadStatic]
private static Stack<Tuple<ComponentModel, CreationContext>> slot;
private readonly IList<ITypeConverter> converters = new List<ITypeConverter>();
private readonly IList<ITypeConverter> standAloneConverters = new List<ITypeConverter>();
public ITypeConverterContext Context {
get {
return this;
}
set {
throw new NotImplementedException();
}
}
IKernelInternal ITypeConverterContext.Kernel {
get {
return base.Kernel;
}
}
public ComponentModel CurrentModel {
get {
if (CurrentStack.Count == 0)
return null;
return CurrentStack.Peek().Item1;
}
}
public CreationContext CurrentCreationContext {
get {
if (CurrentStack.Count == 0)
return null;
return CurrentStack.Peek().Item2;
}
}
public ITypeConverter Composition => this;
private Stack<Tuple<ComponentModel, CreationContext>> CurrentStack {
get {
if (slot == null)
slot = new Stack<Tuple<ComponentModel, CreationContext>>();
return slot;
}
}
public DefaultConversionManager()
{
InitDefaultConverters();
}
protected virtual void InitDefaultConverters()
{
Add(new PrimitiveConverter());
Add(new TimeSpanConverter());
Add(new TypeNameConverter(new TypeNameParser()));
Add(new EnumConverter());
Add(new ListConverter());
Add(new DictionaryConverter());
Add(new GenericDictionaryConverter());
Add(new GenericListConverter());
Add(new ArrayConverter());
Add(new ComponentConverter());
Add(new AttributeAwareConverter());
Add(new ComponentModelConverter());
}
public void Add(ITypeConverter converter)
{
converter.Context = this;
converters.Add(converter);
if (!(converter is IKernelDependentConverter))
standAloneConverters.Add(converter);
}
public bool CanHandleType(Type type)
{
foreach (ITypeConverter converter in converters) {
if (converter.CanHandleType(type))
return true;
}
return false;
}
public bool CanHandleType(Type type, IConfiguration configuration)
{
foreach (ITypeConverter converter in converters) {
if (converter.CanHandleType(type, configuration))
return true;
}
return false;
}
public object PerformConversion(string value, Type targetType)
{
foreach (ITypeConverter converter in converters) {
if (converter.CanHandleType(targetType))
return converter.PerformConversion(value, targetType);
}
throw new ConverterException($"""{targetType.FullName}");
}
public object PerformConversion(IConfiguration configuration, Type targetType)
{
foreach (ITypeConverter converter in converters) {
if (converter.CanHandleType(targetType, configuration))
return converter.PerformConversion(configuration, targetType);
}
throw new ConverterException($"""{targetType.FullName}");
}
public TTarget PerformConversion<TTarget>(string value)
{
return (TTarget)PerformConversion(value, typeof(TTarget));
}
public TTarget PerformConversion<TTarget>(IConfiguration configuration)
{
return (TTarget)PerformConversion(configuration, typeof(TTarget));
}
public void Push(ComponentModel model, CreationContext context)
{
CurrentStack.Push(new Tuple<ComponentModel, CreationContext>(model, context));
}
public void Pop()
{
CurrentStack.Pop();
}
}
}