System.RuntimeTypeHandle.GetTypeHelper C# (CSharp) Method

        internal unsafe static IntPtr GetTypeHelper(IntPtr th, IntPtr pGenericArgs, int cGenericArgs, IntPtr pModifiers, int cModifiers)
        {
            RuntimeTypeHandle typeHandle = new RuntimeTypeHandle(th.ToPointer());
            Type type = typeHandle.GetRuntimeType();
            if (type == null)
                return th;

            if (cGenericArgs > 0)
            {
                Type[] genericArgs = new Type[cGenericArgs];
                void** arGenericArgs = (void**)pGenericArgs.ToPointer();
                for (int i = 0; i < genericArgs.Length; i++)
                {
                    RuntimeTypeHandle genericArg = new RuntimeTypeHandle((void*)Marshal.ReadIntPtr((IntPtr)arGenericArgs, i * sizeof(void*)));
                    genericArgs[i] = Type.GetTypeFromHandle(genericArg);
                    
                    if (genericArgs[i] == null)
                        return (IntPtr)0;
                }

                type = type.MakeGenericType(genericArgs);
            }

            if (cModifiers > 0)
            {
                int* arModifiers = (int*)pModifiers.ToPointer();
                for(int i = 0; i < cModifiers; i++)
                {
                    if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.Ptr)
                        type = type.MakePointerType();
                    
                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.ByRef)
                        type = type.MakeByRefType();

                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.SzArray)
                        type = type.MakeArrayType();

                    else
                        type = type.MakeArrayType(Marshal.ReadInt32((IntPtr)arModifiers, ++i * sizeof(int)));
                }
            }
            
            return type.GetTypeHandleInternal().Value;
        }

        private unsafe Type ConstructType(Func <AssemblyName, Assembly> assemblyResolver, Func <Assembly, string, bool, Type> typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
        {
            Assembly assembly     = null;
            string   assemblyName = this.GetAssemblyName();

            if (assemblyName.Length > 0)
            {
                assembly = TypeNameParser.ResolveAssembly(assemblyName, assemblyResolver, throwOnError, ref stackMark);
                if (assembly == null)
                {
                    return(null);
                }
            }
            string[] names = this.GetNames();
            if (names == null)
            {
                if (throwOnError)
                {
                    throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr"));
                }
                return(null);
            }
            else
            {
                Type type = TypeNameParser.ResolveType(assembly, names, typeResolver, throwOnError, ignoreCase, ref stackMark);
                if (type == null)
                {
                    return(null);
                }
                SafeTypeNameParserHandle[] typeArguments = this.GetTypeArguments();
                Type[] array = null;
                if (typeArguments != null)
                {
                    array = new Type[typeArguments.Length];
                    for (int i = 0; i < typeArguments.Length; i++)
                    {
                        using (TypeNameParser typeNameParser = new TypeNameParser(typeArguments[i]))
                        {
                            array[i] = typeNameParser.ConstructType(assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
                        }
                        if (array[i] == null)
                        {
                            return(null);
                        }
                    }
                }
                int[] modifiers = this.GetModifiers();
                fixed(int *ptr = modifiers)
                {
                    IntPtr pModifiers = new IntPtr((void *)ptr);

                    return(RuntimeTypeHandle.GetTypeHelper(type, array, pModifiers, (modifiers == null) ? 0 : modifiers.Length));
                }
            }
        }