public void ArrayToCollection()
{
var intArrayArgType = new ArrayArgumentType(typeof(int[]));
Action invocation = () => intArrayArgType.ToCollection(null);
invocation.ShouldThrow<ArgumentNullException>();
var outCollection = intArrayArgType.ToCollection(new ArrayList(new[] { 10, -1 }));
outCollection.Should().BeOfType<int[]>();
var outList = (int[])outCollection;
outList.Length.Should().Be(2);
outList[0].Should().Be(10);
outList[1].Should().Be(-1);
}
/// <summary>
/// Tries to retrieve the registered, stock IArgumentType implementation
/// that describes the specified type.
/// </summary>
/// <param name="type">Type to look up.</param>
/// <param name="argType">On success, receives the object that
/// describes the specified type; receives null otherwise.</param>
/// <returns>True on success; false otherwise.</returns>
public static bool TryGetType(Type type, out IArgumentType argType)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
// See if it's a registered, well-known type.
if (TryGetBuiltInType(type, out argType))
{
return(true);
}
// Or possibly a type that directly implements IArgumentType itself.
if (type.GetTypeInfo().GetInterfaces().Contains(typeof(IArgumentType)))
{
var constructor = type.GetTypeInfo().GetConstructor(Array.Empty <Type>());
if (constructor == null)
{
argType = null;
return(false);
}
argType = (IArgumentType)constructor.Invoke(Array.Empty <object>());
return(true);
}
// Specially handle all enum types.
if (type.GetTypeInfo().IsEnum)
{
argType = EnumArgumentType.Create(type);
return(true);
}
// And arrays.
if (type.IsArray)
{
argType = new ArrayArgumentType(type);
return(true);
}
// Handle all types that implement the generic ICollection<T>
// interface.
if (type.GetTypeInfo().GetInterface(typeof(ICollection <>).Name) != null)
{
argType = new CollectionOfTArgumentType(type);
return(true);
}
// Specially handle a few well-known generic types.
if (type.GetTypeInfo().IsGenericType)
{
var genericTy = type.GetGenericTypeDefinition();
if (genericTy.IsEffectivelySameAs(typeof(KeyValuePair <,>)))
{
argType = new KeyValuePairArgumentType(type);
return(true);
}
else if (genericTy.IsEffectivelySameAs(typeof(CommandGroup <>)))
{
argType = new CommandGroupArgumentType(type);
return(true);
}
if (type.GetTypeInfo().GetInterface("ITuple") != null)
{
argType = new TupleArgumentType(type);
return(true);
}
}
// See if it's a nullable wrapper of a type we can handle.
var underlyingType = Nullable.GetUnderlyingType(type);
if (underlyingType != null)
{
return(TryGetType(underlyingType, out argType));
}
argType = null;
return(false);
}
/// <summary>
/// Tries to retrieve the registered, stock IArgumentType implementation
/// that describes the specified type.
/// </summary>
/// <param name="type">Type to look up.</param>
/// <param name="argType">On success, receives the object that
/// describes the specified type; receives null otherwise.</param>
/// <returns>True on success; false otherwise.</returns>
public static bool TryGetType(Type type, out IArgumentType argType)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
// See if it's a registered, well-known type.
if (TryGetBuiltInType(type, out argType))
{
return true;
}
// Or possibly a type that directly implements IArgumentType itself.
if (type.GetInterfaces().Contains(typeof(IArgumentType)))
{
var constructor = type.GetConstructor(new Type[] { });
if (constructor == null)
{
argType = null;
return false;
}
argType = (IArgumentType)constructor.Invoke(new object[] { });
return true;
}
// Specially handle all enum types.
if (type.IsEnum)
{
argType = EnumArgumentType.Create(type);
return true;
}
// And arrays.
if (type.IsArray)
{
argType = new ArrayArgumentType(type);
return true;
}
// Handle all types that implement the generic ICollection<T>
// interface.
if (type.GetInterface(typeof(ICollection<>).Name) != null)
{
argType = new CollectionOfTArgumentType(type);
return true;
}
// Specially handle KeyValuePair and Tuple types.
if (type.IsGenericType)
{
var genericTy = type.GetGenericTypeDefinition();
if (genericTy == typeof(KeyValuePair<,>))
{
argType = new KeyValuePairArgumentType(type);
return true;
}
if (type.GetInterface("ITuple") != null)
{
argType = new TupleArgumentType(type);
return true;
}
}
// See if it's a nullable wrapper of a type we can handle.
var underlyingType = Nullable.GetUnderlyingType(type);
if (underlyingType != null)
{
return TryGetType(underlyingType, out argType);
}
argType = null;
return false;
}
