/// <summary>
/// Enumerate all type definitions within a given namespace.
/// </summary>
/// <param name="metadataUnit">Metadata unit containing the namespace</param>
/// <param name="metadataReader">Metadata reader for the scope metadata</param>
/// <param name="namespaceDefinitionHandle">Namespace to enumerate</param>
private IEnumerable <MetadataType> GetTypesInNamespace(
NativeFormatMetadataUnit metadataUnit,
MetadataReader metadataReader,
NamespaceDefinitionHandle namespaceDefinitionHandle)
{
NamespaceDefinition namespaceDefinition = metadataReader.GetNamespaceDefinition(namespaceDefinitionHandle);
// First, enumerate all types (including nested) in the current namespace
foreach (TypeDefinitionHandle namespaceTypeHandle in namespaceDefinition.TypeDefinitions)
{
yield return((MetadataType)metadataUnit.GetType(namespaceTypeHandle));
foreach (MetadataType nestedType in GetNestedTypes(metadataUnit, metadataReader, namespaceTypeHandle))
{
yield return(nestedType);
}
}
// Second, recurse into nested namespaces
foreach (NamespaceDefinitionHandle nestedNamespace in namespaceDefinition.NamespaceDefinitions)
{
foreach (MetadataType type in GetTypesInNamespace(metadataUnit, metadataReader, nestedNamespace))
{
yield return(type);
}
}
}
private MetadataType InitializeBaseType()
{
var baseTypeHandle = _typeDefinition.BaseType;
if (baseTypeHandle.IsNull(MetadataReader))
{
_baseType = null;
return(null);
}
var type = _metadataUnit.GetType(baseTypeHandle) as MetadataType;
if (type == null)
{
throw new BadImageFormatException();
}
_baseType = type;
return(type);
}
public MethodSignature ParseMethodSignature()
{
var methodSignature = _metadataReader.GetMethodSignature(_signatureHandle.ToMethodSignatureHandle(_metadataReader));
MethodSignatureFlags flags = 0;
if ((methodSignature.CallingConvention & System.Reflection.CallingConventions.HasThis) == 0)
{
flags |= MethodSignatureFlags.Static;
}
int arity = methodSignature.GenericParameterCount;
var parameterSignatureArray = methodSignature.Parameters;
int count = parameterSignatureArray.Count;
TypeDesc returnType = _metadataUnit.GetType(methodSignature.ReturnType);
TypeDesc[] parameters;
if (count > 0)
{
// Get all of the parameters.
parameters = new TypeDesc[count];
int i = 0;
foreach (Handle parameterHandle in parameterSignatureArray)
{
parameters[i] = _metadataUnit.GetType(parameterHandle);
i++;
}
}
else
{
parameters = TypeDesc.EmptyTypes;
}
return(new MethodSignature(flags, arity, returnType, parameters));
}
/// <summary>
/// Enumerate all nested types under a given owning type.
/// </summary>
/// <param name="metadataUnit">Metadata unit containing the type</param>
/// <param name="metadataReader">Metadata reader for the type metadata</param>
/// <param name="owningTypeHandle">Containing type to search for nested types</param>
private IEnumerable <MetadataType> GetNestedTypes(
NativeFormatMetadataUnit metadataUnit,
MetadataReader metadataReader,
TypeDefinitionHandle owningTypeHandle)
{
TypeDefinition owningType = metadataReader.GetTypeDefinition(owningTypeHandle);
foreach (TypeDefinitionHandle nestedTypeHandle in owningType.NestedTypes)
{
yield return((MetadataType)metadataUnit.GetType(nestedTypeHandle));
foreach (MetadataType nestedType in GetNestedTypes(metadataUnit, metadataReader, nestedTypeHandle))
{
yield return(nestedType);
}
}
}