protected override IHandleObject CreateValueFromKey(NativeFormatObjectKey key)
            {
                Handle           handle    = key.Handle;
                NativeFormatType container = key.Container;

                object item;

                switch (handle.HandleType)
                {
                case HandleType.TypeDefinition:
                    item = new NativeFormatType(_metadataUnit, handle.ToTypeDefinitionHandle(_metadataReader));
                    break;

                case HandleType.Method:
                    item = new NativeFormatMethod(container, handle.ToMethodHandle(_metadataReader));
                    break;

                case HandleType.Field:
                    item = new NativeFormatField(container, handle.ToFieldHandle(_metadataReader));
                    break;

                case HandleType.TypeReference:
                    item = _metadataUnit.ResolveTypeReference(handle.ToTypeReferenceHandle(_metadataReader));
                    break;

                case HandleType.MemberReference:
                    item = _metadataUnit.ResolveMemberReference(handle.ToMemberReferenceHandle(_metadataReader));
                    break;

                case HandleType.QualifiedMethod:
                    item = _metadataUnit.ResolveQualifiedMethod(handle.ToQualifiedMethodHandle(_metadataReader));
                    break;

                case HandleType.QualifiedField:
                    item = _metadataUnit.ResolveQualifiedField(handle.ToQualifiedFieldHandle(_metadataReader));
                    break;

                case HandleType.ScopeReference:
                    item = _metadataUnit.ResolveAssemblyReference(handle.ToScopeReferenceHandle(_metadataReader));
                    break;

                case HandleType.ScopeDefinition:
                {
                    ScopeDefinition scope = handle.ToScopeDefinitionHandle(_metadataReader).GetScopeDefinition(_metadataReader);
                    item = _metadataUnit.GetModuleFromAssemblyName(scope.Name.GetConstantStringValue(_metadataReader).Value);
                }
                break;

                case HandleType.TypeSpecification:
                case HandleType.TypeInstantiationSignature:
                case HandleType.SZArraySignature:
                case HandleType.ArraySignature:
                case HandleType.PointerSignature:
                case HandleType.ByReferenceSignature:
                case HandleType.TypeVariableSignature:
                case HandleType.MethodTypeVariableSignature:
                {
                    NativeFormatSignatureParser parser = new NativeFormatSignatureParser(_metadataUnit, handle, _metadataReader);

                    item = parser.ParseTypeSignature();
                }
                break;

                case HandleType.MethodInstantiation:
                    item = _metadataUnit.ResolveMethodInstantiation(handle.ToMethodInstantiationHandle(_metadataReader));
                    break;

                // TODO: Resolve other tokens
                default:
                    throw new BadImageFormatException("Unknown metadata token type: " + handle.HandleType);
                }

                switch (handle.HandleType)
                {
                case HandleType.TypeDefinition:
                case HandleType.Field:
                case HandleType.Method:
                    // type/method/field definitions directly correspond to their target item.
                    return((IHandleObject)item);

                default:
                    // Everything else is some form of reference which cannot be self-describing
                    return(new NativeFormatObjectLookupWrapper(handle, item, container));
                }
            }