private static Object GetMemberValue(CommandLineParameterAttribute commandLineSwitchAttribute, Type valueType, TraceSource traceSource)
{
valueType.ThrowIfNull();
foreach (var switchName in commandLineSwitchAttribute.Names
.Where(item => !item.IsNullOrWhiteSpace())
.Select(item => item.Trim())
.Select(item => item.First() != ParameterCharacter
? ParameterCharacter + item
: item))
{
var index = CommandLine.IndexOf(switchName, !commandLineSwitchAttribute.IsCaseSensative
? StringComparison.CurrentCultureIgnoreCase
: StringComparison.CurrentCulture);
if (index > -1)
{
index += switchName.Length;
var nextIndex = CommandLine.IndexOf(ParameterCharacter, index);
if (nextIndex == -1)
{
nextIndex = CommandLine.Length;
}
var domain = CommandLine.Substring(index, nextIndex - index).Trim();
var values = MemberValueRegex
.Matches(domain)
.Cast <Match>()
.Where(match => match.Success)
.Select(match => match.Value)
.Select(value => value.Trim('\"', ' '))
.ToArray();
// Check if the member accepts multiple arguments separated by spaces.
if (typeof(IEnumerable).IsAssignableFrom(valueType))
{
var enumerableTypes = valueType.IsArray
? new[] { valueType.GetElementType() }
: valueType.GetGenericArguments();
switch (enumerableTypes.Length)
{
case 0:
return(values);
case 1:
var enumerableType = enumerableTypes.Single();
if (enumerableType.IsAssignableFrom(typeof(String)))
{
return(values);
}
else
{
var typeConverter = TypeDescriptor.GetConverter(enumerableType);
if (typeConverter.CanConvertFrom(typeof(String)))
{
var result = Array.CreateInstance(enumerableType, values.Length);
for (int valueIndex = 0; valueIndex < values.Length; valueIndex++)
{
result.SetValue(typeConverter.ConvertFromString(values[valueIndex]), valueIndex);
}
return(result);
}
else
{
traceSource.TraceError("Cannot convert '{0}' to '{1}'"
, typeof(String).FullName
, valueType.GetElementType().FullName);
}
}
break;
default:
traceSource.TraceError("Cannot handle more than 1 generic argument ('{0}')", valueType.FullName);
break;
}
}
else if (typeof(Boolean) == valueType && !values.Any())
{
return(true);
}
else if (values.Any())
{
var value = values.First();
var typeConverter = TypeDescriptor.GetConverter(valueType);
if (typeConverter.CanConvertFrom(typeof(String)))
{
return(typeConverter.ConvertFromString(value));
}
else
{
traceSource.TraceError("Cannot convert '{0}' to '{1}'", typeof(String).FullName, valueType.FullName);
}
}
else
{
traceSource.TraceError("Unable to extract any value of type '{0}' from '{1}'", valueType.FullName, domain);
}
}
}
return(GetDefaultValue(valueType));
}
private static void Bind(CommandLineParameterAttribute commandLineSwitchAttribute, Object instance, FieldInfo fieldInfo, TraceSource traceSource)
{
fieldInfo.SetValue(instance, GetMemberValue(commandLineSwitchAttribute, fieldInfo.FieldType, traceSource));
}
private static void Bind(CommandLineParameterAttribute commandLineSwitchAttribute, Object instance, PropertyInfo propertyInfo, TraceSource traceSource)
{
propertyInfo.SetValue(instance, GetMemberValue(commandLineSwitchAttribute, propertyInfo.PropertyType, traceSource), null);
}
