System.Reflection.MetadataImport.Enum C# (CSharp) Method

        public unsafe void Enum(int type, int parent, int* result, int count) 
        { 
            _Enum(m_metadataImport2, out MetadataArgs.Skip, type, parent, result, count);
        }
        public int EnumCount(int type, int parent) 

        public sealed override Type[] GetForwardedTypes()
        {
            List <Type>      types      = new List <Type>();
            List <Exception> exceptions = new List <Exception>();

            MetadataImport scope = GetManifestModule(GetNativeHandle()).MetadataImport;

            scope.Enum(MetadataTokenType.ExportedType, 0, out MetadataEnumResult enumResult);
            RuntimeAssembly runtimeAssembly = this;
            QCallAssembly   pAssembly       = new QCallAssembly(ref runtimeAssembly);

            for (int i = 0; i < enumResult.Length; i++)
            {
                MetadataToken       mdtExternalType = enumResult[i];
                Type?               type            = null;
                Exception?          exception       = null;
                ObjectHandleOnStack pType           = ObjectHandleOnStack.Create(ref type);
                try
                {
                    GetForwardedType(pAssembly, mdtExternalType, pType);
                    if (type == null)
                    {
                        continue;  // mdtExternalType was not a forwarder entry.
                    }
                }
                catch (Exception e)
                {
                    type      = null;
                    exception = e;
                }

                Debug.Assert((type != null) != (exception != null)); // Exactly one of these must be non-null.

                if (type != null)
                {
                    types.Add(type);
                    AddPublicNestedTypes(type, types, exceptions);
                }
                else
                {
                    exceptions.Add(exception !);
                }
            }

            if (exceptions.Count != 0)
            {
                int numTypes      = types.Count;
                int numExceptions = exceptions.Count;
                types.AddRange(new Type[numExceptions]);            // add one null Type for each exception.
                exceptions.InsertRange(0, new Exception[numTypes]); // align the Exceptions with the null Types.
                throw new ReflectionTypeLoadException(types.ToArray(), exceptions.ToArray());
            }

            return(types.ToArray());
        }