public virtual bool IsSubclassOf(Type c)
{
TypeInfo resolvedC = c.GetTypeInfo();
TypeInfo p = this;
if (p.Equals(resolvedC))
{
return(false);
}
while (p != null)
{
if (p.Equals(resolvedC))
{
return(true);
}
Type b = p.BaseType;
if (b == null)
{
break;
}
p = b.GetTypeInfo();
}
return(false);
}
public virtual bool IsAssignableFrom(TypeInfo typeInfo)
{
if (typeInfo == null)
{
return(false);
}
if (this.Equals(typeInfo))
{
return(true);
}
// If c is a subclass of this class, then typeInfo can be cast to this type.
if (typeInfo.IsSubclassOf(this.AsType()))
{
return(true);
}
if (this.IsInterface)
{
foreach (Type implementedInterface in typeInfo.ImplementedInterfaces)
{
TypeInfo resolvedImplementedInterface = implementedInterface.GetTypeInfo();
if (resolvedImplementedInterface.Equals(this))
{
return(true);
}
}
return(false);
}
else if (IsGenericParameter)
{
Type[] constraints = GetGenericParameterConstraints();
for (int i = 0; i < constraints.Length; i++)
{
if (!constraints[i].GetTypeInfo().IsAssignableFrom(typeInfo))
{
return(false);
}
}
return(true);
}
return(false);
}
public static bool IsAssignableFrom(TypeInfo toTypeInfo, TypeInfo fromTypeInfo, FoundationTypes foundationTypes)
{
if (toTypeInfo == null)
throw new NullReferenceException();
if (fromTypeInfo == null)
return false; // It would be more appropriate to throw ArgumentNullException here, but returning "false" is the desktop-compat behavior.
if (fromTypeInfo.Equals(toTypeInfo))
return true;
if (toTypeInfo.IsGenericTypeDefinition)
{
// Asking whether something can cast to a generic type definition is arguably meaningless. The desktop CLR Reflection layer converts all
// generic type definitions to generic type instantiations closed over the formal generic type parameters. The .NET Native framework
// keeps the two separate. Fortunately, under either interpretation, returning "false" unless the two types are identical is still a
// defensible behavior. To avoid having the rest of the code deal with the differing interpretations, we'll short-circuit this now.
return false;
}
if (fromTypeInfo.IsGenericTypeDefinition)
{
// The desktop CLR Reflection layer converts all generic type definitions to generic type instantiations closed over the formal
// generic type parameters. The .NET Native framework keeps the two separate. For the purpose of IsAssignableFrom(),
// it makes sense to unify the two for the sake of backward compat. We'll just make the transform here so that the rest of code
// doesn't need to know about this quirk.
fromTypeInfo = fromTypeInfo.GetGenericTypeDefinition().MakeGenericType(fromTypeInfo.GenericTypeParameters).GetTypeInfo();
}
if (fromTypeInfo.CanCastTo(toTypeInfo, foundationTypes))
return true;
Type toType = toTypeInfo.AsType();
Type fromType = fromTypeInfo.AsType();
// Desktop compat: IsAssignableFrom() considers T as assignable to Nullable<T> (but does not check if T is a generic parameter.)
if (!fromType.IsGenericParameter)
{
Type nullableUnderlyingType = Nullable.GetUnderlyingType(toType);
if (nullableUnderlyingType != null && nullableUnderlyingType.Equals(fromType))
return true;
}
return false;
}
private static bool AreEquivalent(TypeInfo type, TypeInfo other)
{
// TODO: Unify NoPIA interfaces
// https://github.com/dotnet/corefx/issues/2101
return type.Equals(other);
}
// Method to compare two types pointers for type equality
// We cannot just compare the pointers as there can be duplicate type instances
// for cloned and constructed types.
static bool AreTypesEquivalentInternal(TypeInfo pType1, TypeInfo pType2)
{
if (!pType1.IsInstantiatedTypeInfo() && !pType2.IsInstantiatedTypeInfo())
return pType1.Equals(pType2);
if (pType1.IsGenericType && pType2.IsGenericType)
{
if (!pType1.GetGenericTypeDefinition().Equals(pType2.GetGenericTypeDefinition()))
return false;
Type[] args1 = pType1.GenericTypeArguments;
Type[] args2 = pType2.GenericTypeArguments;
Debug.Assert(args1.Length == args2.Length);
for (int i = 0; i < args1.Length; i++)
{
if (!AreTypesEquivalentInternal(args1[i].GetTypeInfo(), args2[i].GetTypeInfo()))
return false;
}
return true;
}
if (pType1.IsArray && pType2.IsArray)
{
if (pType1.GetArrayRank() != pType2.GetArrayRank())
return false;
return AreTypesEquivalentInternal(pType1.GetElementType().GetTypeInfo(), pType2.GetElementType().GetTypeInfo());
}
if (pType1.IsPointer && pType2.IsPointer)
{
return AreTypesEquivalentInternal(pType1.GetElementType().GetTypeInfo(), pType2.GetElementType().GetTypeInfo());
}
return false;
}
private int GetTypeId(TypeInfo ti)
{
if (ti.Equals(typeof(Int32).GetTypeInfo()))
{
return 0;
}
if (ti.Equals(typeof(float).GetTypeInfo()))
{
return 1;
}
if (ti.Equals(typeof(bool).GetTypeInfo()))
{
return 2;
}
if (ti.Equals(typeof(string).GetTypeInfo()))
{
return 3;
}
return 0;
}