internal static bool IsSimpleType(Type type)
{
var isListOfSimpleThings = false;
if (typeof(IEnumerable).IsAssignableFrom(type) && type != typeof(string))
{
if (type.IsGenericType)
{
var firstGenericParameter = type.GetGenericArguments().First();
var isResolveableType = TypeResolver.IsResolvableType(firstGenericParameter);
isListOfSimpleThings = (firstGenericParameter.IsPrimitive || firstGenericParameter.IsEnum || firstGenericParameter == typeof(string) || isResolveableType);
}
}
return(type.IsPrimitive || type.IsEnum || type == typeof(string) || isListOfSimpleThings);
}
internal static Parameter Create(ParameterInfo para, ParameterAttribute paraConfig)
{
if (IsSimpleType(para.ParameterType))
{
return(new SimpleParameter(para, paraConfig));
}
else if (TypeResolver.IsResolvableType(para.ParameterType))
{
return(new ResolvedParameter(para, paraConfig));
}
else
{
if (paraConfig != null)
{
throw new ModelParmeterHasParameterAttributeException(para);
}
return(new ModelParameter(para));
}
}
private List <ParameterAttribute> getMethodParameterInfo(MethodInfo method, bool enumerateModelProperties = false)
{
var paraConfigList = method.GetCustomAttributes <ParameterAttribute>();
List <ParameterAttribute> pi = new List <ParameterAttribute>();
foreach (var para in method.GetParameters())
{
if (Parameter.IsSimpleType(para.ParameterType) || TypeResolver.IsResolvableType(para.ParameterType))
{
var paraConfig = paraConfigList.SingleOrDefault(x => x.ShortName.ToString().Equals(para.Name, StringComparison.CurrentCultureIgnoreCase) || string.Equals(x.LongName, para.Name, StringComparison.CurrentCultureIgnoreCase));
if (paraConfig == null)
{
if (para.Name.Length == 1)
{
paraConfig = new ParameterAttribute {
ShortName = (char)para.Name.First()
}
}
}
;
else
{
paraConfig = new ParameterAttribute {
LongName = para.Name
}
};
if (para.HasDefaultValue)
{
paraConfig.IsRequired = false;
paraConfig.Default = para.DefaultValue;
}
paraConfig.isSimpleType = Parameter.IsSimpleType(para.ParameterType);
paraConfig.Type = para.ParameterType;
pi.Add(paraConfig);
}
private object getTypedParameterValue(ParameterAttribute para, CommandLineParameterInfo pi)
{
if (para.Type == typeof(bool))
{
return(pi.Exists);
}
bool isList = typeof(IEnumerable).IsAssignableFrom(para.Type) && para.Type != typeof(string);
if (pi.HasValue)
{
var value = pi.Value;
if (para.Type.IsEnum)
{
if (Enum.TryParse(para.Type, value, ignoreCase: true, out object res))
{
return(res);
}
else
{
throw new InvalidParameterException(para);
}
}
if (TypeResolver.IsResolvableType(para.Type))
{
return(TypeResolver.Resolve(value, para.Type));
}
if (isList)
{
var separator = " ";
if (!string.IsNullOrWhiteSpace(para.ListSeparator))
{
separator = para.ListSeparator;
}
var splitValue = value.Split(new string[] { separator }, StringSplitOptions.RemoveEmptyEntries);
var underlyingType = para.Type.GetGenericArguments().FirstOrDefault();
var constructedListType = typeof(List <>).MakeGenericType(underlyingType);
var constructedList = (IList)Activator.CreateInstance(constructedListType);
try
{
if (Parameter.IsSimpleType(underlyingType))
{
splitValue.ToList().ForEach(x => constructedList.Add(Convert.ChangeType(x, underlyingType)));
}
else if (TypeResolver.IsResolvableType(underlyingType))
{
splitValue.ToList().ForEach(x => constructedList.Add(TypeResolver.Resolve(x, underlyingType)));
}
}
catch (FormatException)
{
throw new InvalidParameterException(para);
}
return(constructedList);
}
else
{
return(Convert.ChangeType(value, para.Type));
}
}
else
{
if (para.IsRequired)
{
throw new ParameterMissingException(para);
}
else
{
return(null);
}
}
}