private MethodInfo MatchMethods(FactoryConfiguration factory, Type type, string methodName, bool isStatic)
{
MethodInfo[] methods = type.GetMethods();
MethodInfo bestMethodMatch = null;
int bestScore = int.MaxValue;
foreach (MethodInfo method in methods)
{
if (method.Name != methodName)
{
continue;
}
int score = 0;
ParameterInfo[] parameters = method.GetParameters();
//if param count doesnt match , move to next ctor
if (parameters.Length != factory.ParameterConfigurations.Count)
{
continue;
}
if (parameters.Length == 0)
{
return(method);
}
#region Match parameters
for (int i = 0; i < parameters.Length; i++)
{
ParameterConfiguration parameterConfig = (ParameterConfiguration)factory.ParameterConfigurations[i];
Type type1 = parameters[i].ParameterType;
Type type2 = parameterConfig.Type;
if (type2 == null)
{
//untyped parameter
try
{
ValueConfiguration parameterValueConfig = (ValueConfiguration)parameterConfig.Value;
object res = Convert.ChangeType(parameterValueConfig.Value, type1);
}
catch
{
continue;
}
score++;
}
else
{
//typed parameter
if (type1.IsAssignableFrom(type2))
{
if (type1 == type2)
{
//same type
score++;
}
else if (type2.IsSubclassOf(type1))
{
//subclass
Type tmpType = type2;
while (tmpType != type1)
{
score++;
tmpType = tmpType.BaseType;
}
}
else
{
//interface
score++;
}
}
else
{
//ignore this
continue;
}
}
}
#endregion
if (score < bestScore && score != 0)
{
bestMethodMatch = method;
bestScore = score;
}
}
return(bestMethodMatch);
}
private void ConfigureElement(XmlNode node, ElementConfiguration config, IContainer container, Type valueType)
{
config.Type = valueType;
if (node.Attributes["value"] != null)
{
string propertyValueString = node.Attributes["value"].Value;
ValueConfiguration propertyValueConfig = new ValueConfiguration();
propertyValueConfig.Value = propertyValueString;
config.Value = propertyValueConfig;
if (node.Attributes["type-converter"] != null)
{
string typeConverterString = node.Attributes["type-converter"].Value;
Type typeConverterType = ResolveType(typeConverterString);
TypeConverter typeConverter = (TypeConverter)Activator.CreateInstance(typeConverterType);
propertyValueConfig.TypeConverter = typeConverter;
}
if (node.Attributes["type"] != null)
{
string typeString = node.Attributes["type"].Value;
Type type = ResolveType(typeString);
config.Type = type;
}
}
if (node.Attributes["object"] != null)
{
string propertyObjectName = node.Attributes["object"].Value;
IObjectConfiguration propertyObjectConfig = GetObjectConfiguration(propertyObjectName, container);
config.Value = propertyObjectConfig;
//done
if (node.Attributes["instance-mode"] != null)
{
string instanceModeString = node.Attributes["instance-mode"].Value;
config.InstanceMode = (InstanceMode)InstanceMode.Parse(typeof(InstanceMode), instanceModeString);
}
}
if (node.Attributes["list"] != null)
{
string propertyListName = node.Attributes["list"].Value;
IListConfiguration propertyListConfig = GetListConfiguration(propertyListName, container);
config.Value = propertyListConfig;
config.Type = typeof(IList);
}
if (node.Attributes["factory"] != null)
{
string itemFactoryName = node.Attributes["factory"].Value;
IFactoryConfiguration propertyFactoryConfig = GetFactoryConfiguration(itemFactoryName, container);
config.Value = propertyFactoryConfig;
}
}
private ConstructorInfo MatchConstructors(ObjectConfiguration objectConfig)
{
try
{
ConstructorInfo[] constructors = objectConfig.Type.GetConstructors();
ConstructorInfo bestCtorMatch = null;
int bestScore = int.MaxValue;
foreach (ConstructorInfo constructor in constructors)
{
int score = 0;
ParameterInfo[] ctorParameters = constructor.GetParameters();
//if param count doesnt match , move to next ctor
if (ctorParameters.Length != objectConfig.CtorParameterConfigurations.Count)
{
continue;
}
if (ctorParameters.Length == 0)
{
return(constructor);
}
#region Match parameters
for (int i = 0; i < ctorParameters.Length; i++)
{
ParameterConfiguration parameterConfig = (ParameterConfiguration)objectConfig.CtorParameterConfigurations[i];
Type type1 = ctorParameters[i].ParameterType;
Type type2 = parameterConfig.Type;
if (type2 == null)
{
ValueConfiguration parameterValueConfig = (ValueConfiguration)parameterConfig.Value;
if (parameterValueConfig.TypeConverter != null)
{
if (parameterValueConfig.TypeConverter.CanConvertTo(type1))
{
score++;
}
else
{
break;
}
}
else
{
//untyped parameter
try
{
if (type1.IsEnum && parameterValueConfig.Value is string)
{
object res = Enum.Parse(type1, parameterValueConfig.Value.ToString());
}
else
{
object res = Convert.ChangeType(parameterValueConfig.Value, type1);
}
}
catch
{
break;
}
score++;
}
}
else
{
//typed parameter
if (type1.IsAssignableFrom(type2))
{
if (type1 == type2)
{
//same type
score++;
}
else if (type2.IsSubclassOf(type1))
{
//subclass
Type tmpType = type2;
while (tmpType != type1)
{
score++;
tmpType = tmpType.BaseType;
}
}
else
{
//interface
score++;
}
}
else
{
//ignore this
break;
}
}
}
#endregion
if (score < bestScore && score != 0)
{
bestCtorMatch = constructor;
bestScore = score;
}
}
return(bestCtorMatch);
}
catch (Exception x)
{
throw new Exception(string.Format("could not match constructor for object '{0}'", objectConfig.Name), x);
}
}
private IFactoryConfiguration ConfigureFactory(XmlNode configNode, IContainer container)
{
string factoryName = configNode.Attributes["name"].Value;
string factoryMethodName = configNode.Attributes["method"].Value;
IFactoryConfiguration factoryConfig = GetFactoryConfiguration(factoryName, container);
factoryConfig.Name = factoryName;
factoryConfig.MethodName = factoryMethodName;
if (configNode.Attributes["type"] != null) //
{
string objectTypeString = configNode.Attributes["type"].Value;
Type objectType = ResolveType(objectTypeString);
factoryConfig.Type = objectType;
}
else if (configNode.Attributes["object"] != null) //instance
{
string objectName = configNode.Attributes["object"].Value;
IObjectConfiguration objectConfig = GetObjectConfiguration(objectName, container);
factoryConfig.Object = objectConfig;
}
foreach (XmlNode factoryNode in configNode)
{
#region Parameter
if (factoryNode.Name == "parameter")
{
ParameterConfiguration parameterConfig = new ParameterConfiguration();
parameterConfig.Index = Convert.ToInt32(factoryNode.Attributes["index"].Value);
if (factoryNode.Attributes["value"] != null)
{
string propertyValueString = factoryNode.Attributes["value"].Value;
ValueConfiguration propertyValueConfig = new ValueConfiguration();
if (factoryNode.Attributes["type"] != null)
{
//typed parameter
string parameterTypeString = factoryNode.Attributes["type"].Value;
Type parameterType = ResolveType(parameterTypeString);
parameterConfig.Type = parameterType;
propertyValueConfig.Value = Convert.ChangeType(propertyValueString, parameterConfig.Type);
}
else
{
//untyped parameter
propertyValueConfig.Value = propertyValueString;
// parameterConfig.UntypedStringValue = propertyValueString;
parameterConfig.Type = null;
}
parameterConfig.Value = propertyValueConfig;
}
if (factoryNode.Attributes["object"] != null)
{
string parameterObjectName = factoryNode.Attributes["object"].Value;
IObjectConfiguration propertyObjectConfig = GetObjectConfiguration(parameterObjectName, container);
parameterConfig.Value = propertyObjectConfig;
//done
if (factoryNode.Attributes["instance-mode"] != null)
{
string instanceModeString = factoryNode.Attributes["instance-mode"].Value;
parameterConfig.InstanceMode = (InstanceMode)InstanceMode.Parse(typeof(InstanceMode), instanceModeString);
}
}
factoryConfig.ParameterConfigurations.Add(parameterConfig);
}
#endregion
}
return(factoryConfig);
}
