public static uint Read(this NativeReader reader, uint offset, out Handle handle)
 {
     uint rawValue;
     offset = reader.DecodeUnsigned(offset, out rawValue);
     handle = new Handle((HandleType)(byte)rawValue, (int)(rawValue >> 8));
     return offset;
 }

 private RuntimeFatMethodParameterInfo(MethodBase member, MethodHandle methodHandle, int position, ParameterHandle parameterHandle, MetadataReader reader, Handle typeHandle, TypeContext typeContext)
     : base(member, position, reader, typeHandle, typeContext)
 {
     _methodHandle = methodHandle;
     _parameterHandle = parameterHandle;
     _parameter = parameterHandle.GetParameter(reader);
 }

        // TODO
        // bool _hasModifiers;

        public NativeFormatSignatureParser(NativeFormatMetadataUnit metadataUnit, Handle signatureHandle, MetadataReader metadataReader)
        {
            _metadataUnit = metadataUnit;
            _signatureHandle = signatureHandle;
            _metadataReader = metadataReader;
            // _hasModifiers = false;
        }

 protected RuntimeMethodParameterInfo(MethodBase member, int position, MetadataReader reader, Handle typeHandle, TypeContext typeContext)
     : base(member, position)
 {
     Reader = reader;
     _typeHandle = typeHandle;
     _typeContext = typeContext;
 }

 public static bool GetAttributeTypeAndConstructor(this MetadataReader metadataReader, CustomAttributeHandle attributeHandle,
     out Handle attributeType, out Handle attributeCtor)
 {
     CustomAttribute attribute = metadataReader.GetCustomAttribute(attributeHandle);
     attributeCtor = attribute.Constructor;
     attributeType = attribute.GetAttributeTypeHandle(metadataReader);
     return true;
 }

        public static bool GetAttributeTypeNamespaceAndName(this MetadataReader metadataReader, Handle attributeType,
            out string namespaceString, out ConstantStringValueHandle nameHandle)
        {
            namespaceString = null;
            nameHandle = default(ConstantStringValueHandle);

            if (attributeType.HandleType == HandleType.TypeReference)
            {
                TypeReference typeRefRow = metadataReader.GetTypeReference(attributeType.ToTypeReferenceHandle(metadataReader));
                HandleType handleType = typeRefRow.ParentNamespaceOrType.HandleType;

                // Nested type?
                if (handleType == HandleType.TypeReference || handleType == HandleType.TypeDefinition)
                    return false;

                nameHandle = typeRefRow.TypeName;
                namespaceString = metadataReader.GetNamespaceName(typeRefRow.ParentNamespaceOrType.ToNamespaceReferenceHandle(metadataReader));
                return true;
            }
            else if (attributeType.HandleType == HandleType.TypeDefinition)
            {
                var def = metadataReader.GetTypeDefinition(attributeType.ToTypeDefinitionHandle(metadataReader));

                // Nested type?
                if (IsNested(def.Flags))
                    return false;

                nameHandle = def.Name;
                namespaceString = metadataReader.GetNamespaceName(def.NamespaceDefinition);
                return true;
            }
            else
            {
                // unsupported metadata
                return false;
            }
        }

        } // ToTypeReferenceHandle

        internal TypeSpecificationHandle ToTypeSpecificationHandle(Handle handle)
        {
            return new TypeSpecificationHandle(handle._value);
        } // ToTypeSpecificationHandle

        } // ToTypeInstantiationSignatureHandle

        internal TypeReferenceHandle ToTypeReferenceHandle(Handle handle)
        {
            return new TypeReferenceHandle(handle._value);
        } // ToTypeReferenceHandle

        } // ToTypeForwarderHandle

        internal TypeInstantiationSignatureHandle ToTypeInstantiationSignatureHandle(Handle handle)
        {
            return new TypeInstantiationSignatureHandle(handle._value);
        } // ToTypeInstantiationSignatureHandle

        } // ToMethodTypeVariableSignatureHandle

        internal NamedArgumentHandle ToNamedArgumentHandle(Handle handle)
        {
            return new NamedArgumentHandle(handle._value);
        } // ToNamedArgumentHandle

        } // Read

        public static uint Read(this NativeReader reader, uint offset, out Handle[] values)
        {
            uint count;
            offset = reader.DecodeUnsigned(offset, out count);
            if (count == 0)
            {
                values = s_emptyHandleArray;
            }
            else
            {
                values = new Handle[count];
                for (uint i = 0; i < count; ++i)
                {
                    Handle tmp;
                    offset = reader.Read(offset, out tmp);
                    values[i] = tmp;
                }
            }
            return offset;
        } // Read

        } // ToNamespaceReferenceHandle

        internal ParameterHandle ToParameterHandle(Handle handle)
        {
            return new ParameterHandle(handle._value);
        } // ToParameterHandle

        } // ToNamedArgumentHandle

        internal NamespaceDefinitionHandle ToNamespaceDefinitionHandle(Handle handle)
        {
            return new NamespaceDefinitionHandle(handle._value);
        } // ToNamespaceDefinitionHandle

        } // ToReturnTypeSignatureHandle

        internal SZArraySignatureHandle ToSZArraySignatureHandle(Handle handle)
        {
            return new SZArraySignatureHandle(handle._value);
        } // ToSZArraySignatureHandle

        } // ToQualifiedMethodHandle

        internal ReturnTypeSignatureHandle ToReturnTypeSignatureHandle(Handle handle)
        {
            return new ReturnTypeSignatureHandle(handle._value);
        } // ToReturnTypeSignatureHandle

        } // ToQualifiedFieldHandle

        internal QualifiedMethodHandle ToQualifiedMethodHandle(Handle handle)
        {
            return new QualifiedMethodHandle(handle._value);
        } // ToQualifiedMethodHandle

        } // ToPropertyHandle

        internal PropertySignatureHandle ToPropertySignatureHandle(Handle handle)
        {
            return new PropertySignatureHandle(handle._value);
        } // ToPropertySignatureHandle

        } // ToParameterTypeSignatureHandle

        internal PointerSignatureHandle ToPointerSignatureHandle(Handle handle)
        {
            return new PointerSignatureHandle(handle._value);
        } // ToPointerSignatureHandle

        } // ToParameterHandle

        internal ParameterTypeSignatureHandle ToParameterTypeSignatureHandle(Handle handle)
        {
            return new ParameterTypeSignatureHandle(handle._value);
        } // ToParameterTypeSignatureHandle

        } // ToTypeSpecificationHandle

        internal TypeVariableSignatureHandle ToTypeVariableSignatureHandle(Handle handle)
        {
            return new TypeVariableSignatureHandle(handle._value);
        } // ToTypeVariableSignatureHandle