public static Type MakeGenericType(Type baseType, Type[] types)
{
// emulate Nullable<T>
if (baseType == typeof(Nullable <>))
{
if (types.Length != 1)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.WrongNumberOfArguments);
}
var ret = NullableReflection.GetNullableTFromUnterlyingType(types[0]);
if (ret != null)
{
return(ret);
}
// can't create a nullable instance of non-predifined nullable,
// because of all the compiler-voodoo around Nullables.
return(null);
}
var expected = GetGenericArgumentCount(baseType);
if (types.Length != expected)
{
throw new ArgumentOutOfRangeException("types", string.Format("exected {0} generic arguments, got {1} for type {2}", expected, types.Length, baseType.FullName));
}
return(GenericInstanceFactory.GetOrMakeGenericInstanceType(baseType, types));
}
public static Type[] GetGenericArguments(Type type)
{
Type[] ret;
// generic instance proxy?
var genericTypeInfo = GenericInstanceFactory.GetGenericTypeInfo(type);
if (genericTypeInfo != null)
{
return((Type[])genericTypeInfo.AddOrGetGenericParameters(createTypeArray: true));
}
// Nullable<T>?
Type nullableUnderlying = NullableReflection.GetUnderlyingType(type);
if (nullableUnderlying != null)
{
return(new[] { nullableUnderlying });
}
// java generic type?
var javaTypeParam = type.GetTypeParameters();
if (javaTypeParam.Length != 0)
{
// java generic type. provide some emulation.
ret = new Type[javaTypeParam.Length];
for (int i = 0; i < javaTypeParam.Length; ++i)
{
ret[i] = typeof(object);
}
return(ret);
}
var info = GetOrCreateGenericsInfo(type);
if (info.GenericArgumentCount > 0)
{
// generic definition? We can only return the number of objects.
ret = new Type[info.GenericArgumentCount];
for (int i = 0; i < ret.Length; ++i)
{
ret[i] = typeof(object);
}
return(ret);
}
throw new InvalidOperationException("not a generic type: " + type.FullName);
}
private static GenericsInfo CreateGenericsInfo(Type type)
{
var info = new GenericsInfo();
if (NullableReflection.TreatAsSystemNullableT(type))
{
info.GenericArgumentCount = -1;
}
else if (GenericInstanceFactory.IsGenericInstanceType(type))
{
info.GenericArgumentCount = -1;
}
else
{
var annotation = type.GetAnnotation <ITypeReflectionInfo>(typeof(ITypeReflectionInfo));
var args = annotation != null?annotation.GenericArgumentCount() : 0;
if (args > 0)
{
var fieldNames = annotation.GenericArgumentsFields();
if (fieldNames.Length > 0)
{
var fields = type.JavaGetDeclaredFields();
info.GenericInstanceFields = fieldNames.Select(name =>
{
var field = fields.FirstOrDefault(f => f.Name == name);
field.IsAccessible = true;
return(field);
});
info.GenericInstanceFieldIsTypeArray = info.GenericInstanceFields.Length == 1 &&
info.GenericInstanceFields[0].Type == typeof(Type[]);
}
}
info.GenericArgumentCount = args == 0 ? -1 : args;
}
return(info);
}
public static bool IsGenericType(Type type)
{
// Java generic type?
// this call makes Json.NET deserialization about 2.5 times as slow.
// If Java generics have any meanings to us, we would need to cache the
// return value.
//bool hasTypeParameters = type.GetTypeParameters().Length > 0;
//if (hasTypeParameters) return true;
// Nullable<T>?
if (NullableReflection.TreatAsSystemNullableT(type))
{
return(true);
}
// generic proxy?
if (GenericInstanceFactory.IsGenericInstanceType(type))
{
return(true);
}
// .NET generic type definition?
return(IsGenericTypeDefinition(type));
}
public static Type GetGenericTypeDefinition(Type type)
{
// emulate Nullable<T>
if (NullableReflection.TreatAsSystemNullableT(type))
{
return(typeof(Nullable <>));
}
// is generic proxy?
var ret = GenericInstanceFactory.GetGenericTypeDefinition(type);
if (ret != null)
{
return(ret);
}
// is generic type? just return itself.
if (!IsGenericType(type))
{
ThrowHelper.ThrowInvalidOperationException(ExceptionResource.NotAGenericType);
}
return(type);
}