IMetaDataImport

Actualización: noviembre 2007

Proporciona métodos para importar y manipular los metadatos existentes desde un archivo portable ejecutable (PE) u otro origen, como una biblioteca de tipos o un archivo binario de metadatos independiente en tiempo de ejecución.

interface IMetaDataImport : IUnknown {
        
    HRESULT CloseEnum (
        HCORENUM hEnum
    );
        
    HRESULT CountEnum (
        HCORENUM    hEnum, 
        ULONG       *pulCount
    );
        
    HRESULT EnumCustomAttributes ( 
        HCORENUM    *phEnum,
        mdToken     tk, 
        mdToken     tkType, 
        mdCustomAttribute rCustomAttributes[], 
        ULONG       cMax,
        ULONG       *pcCustomAttributes
    );
        
    HRESULT EnumEvents ( 
        HCORENUM    *phEnum, 
        mdTypeDef   td, 
        mdEvent     rEvents[], 
        ULONG       cMax,
        ULONG       *pcEvents
    );
        
    HRESULT EnumFields ( 
        HCORENUM    *phEnum, 
        mdTypeDef   cl, 
        mdFieldDef  rFields[], 
        ULONG       cMax, 
        ULONG       *pcTokens
    );
        
    HRESULT EnumFieldsWithName (
        HCORENUM    *phEnum, 
        mdTypeDef   cl, 
        LPCWSTR     szName, 
        mdFieldDef  rFields[], 
        ULONG       cMax, 
        ULONG       *pcTokens 
    );
        
    HRESULT EnumInterfaceImpls (
        HCORENUM        *phEnum, 
        mdTypeDef       td,
        mdInterfaceImpl rImpls[], 
        ULONG           cMax,
        ULONG*          pcImpls
    );
        
    HRESULT EnumMemberRefs (
        HCORENUM    *phEnum, 
        mdToken     tkParent, 
        mdMemberRef rMemberRefs[], 
        ULONG       cMax, 
        ULONG       *pcTokens
    );
        
    HRESULT EnumMembers ( 
        HCORENUM    *phEnum, 
        mdTypeDef   cl, 
        mdToken     rMembers[], 
        ULONG       cMax, 
        ULONG       *pcTokens
    );
        
    HRESULT EnumMembersWithName (
        HCORENUM    *phEnum, 
        mdTypeDef   cl, 
        LPCWSTR     szName, 
        mdToken     rMembers[], 
        ULONG       cMax, 
        ULONG       *pcTokens
    );
        
    HRESULT EnumMethodImpls (
        HCORENUM    *phEnum, 
        mdTypeDef   td, 
        mdToken     rMethodBody[], 
        mdToken     rMethodDecl[], 
        ULONG       cMax, 
        ULONG       *pcTokens
    );
        
    HRESULT EnumMethods (
        HCORENUM    *phEnum, 
        mdTypeDef   cl, 
        mdMethodDef rMethods[], 
        ULONG       cMax, 
        ULONG       *pcTokens
    );
        
    HRESULT EnumMethodSemantics (
        HCORENUM    *phEnum,
        mdMethodDef mb, 
        mdToken     rEventProp[], 
        ULONG       cMax,
        ULONG       *pcEventProp
    );
        
    HRESULT EnumMethodsWithName (
        HCORENUM    *phEnum,
        mdTypeDef   cl,
        LPCWSTR     szName,
        mdMethodDef rMethods[],
        ULONG       cMax,
        ULONG       *pcTokens
    );
        
    HRESULT EnumModuleRefs (
        HCORENUM    *phEnum,
        mdModuleRef rModuleRefs[],
        ULONG       cMax,
        ULONG       *pcModuleRefs
    );
        
    HRESULT EnumParams (
        HCORENUM    *phEnum,
        mdMethodDef mb,
        mdParamDef  rParams[],
        ULONG       cMax,
        ULONG       *pcTokens
    );
        
    HRESULT EnumPermissionSets
        HCORENUM    *phEnum, 
        mdToken     tk, 
        DWORD       dwActions,
        mdPermission rPermission[],
        ULONG       cMax,
       ULONG       *pcTokens
    );
        
    HRESULT EnumProperties (
        HCORENUM    *phEnum,
        mdTypeDef   td,
        mdProperty  rProperties[],
        ULONG       cMax,
        ULONG       *pcProperties
    );
        
    HRESULT EnumSignatures (
        HCORENUM    *phEnum,
        mdSignature rSignatures[],
        ULONG       cMax,
        ULONG       *pcSignatures
    );
        
    HRESULT EnumTypeDefs (
        HCORENUM    *phEnum, 
        mdTypeDef   rTypeDefs[],
        ULONG       cMax, 
        ULONG       *pcTypeDefs
    );
        
    HRESULT EnumTypeRefs (
        HCORENUM    *phEnum, 
        mdTypeRef   rTypeRefs[],
        ULONG       cMax, 
        ULONG       *pcTypeRefs
    );
        
    HRESULT EnumTypeSpecs (
        HCORENUM    *phEnum,
        mdTypeSpec  rTypeSpecs[],
        ULONG       cMax,
        ULONG       *pcTypeSpecs
    );
        
    HRESULT EnumUnresolvedMethods (
        HCORENUM    *phEnum,
        mdToken     rMethods[],
        ULONG       cMax,
        ULONG       *pcTokens
        );
        
    HRESULT EnumUserStrings (
        HCORENUM    *phEnum,
        mdString    rStrings[],
                ULONG       cMax,
        ULONG       *pcStrings
    );
        
    HRESULT FindField (
        mdTypeDef   td,
        LPCWSTR     szName,
        PCCOR_SIGNATURE pvSigBlob,
        ULONG       cbSigBlob,
        mdFieldDef  *pmb
    );
        
    HRESULT FindMember (
        mdTypeDef   td,
        LPCWSTR     szName, 
        PCCOR_SIGNATURE pvSigBlob, 
        ULONG       cbSigBlob, 
        mdToken     *pmb
    );
        
    HRESULT FindMemberRef (
        mdTypeRef   td,
        LPCWSTR     szName, 
        PCCOR_SIGNATURE pvSigBlob, 
        ULONG       cbSigBlob, 
        mdMemberRef     *pmr
    );
        
    HRESULT FindMethod (
        mdTypeDef   td,
        LPCWSTR     szName, 
        PCCOR_SIGNATURE pvSigBlob, 
        ULONG       cbSigBlob, 
        mdMethodDef     *pmb
    );
        
    HRESULT FindTypeDefByName
        LPCWSTR     szTypeDef,
        mdToken     tkEnclosingClass,
        mdTypeDef   *ptd
    );
        
    HRESULT FindTypeRef (
        mdToken     tkResolutionScope,
        LPCWSTR     szName,
        mdTypeRef   *ptr
    );
        
    HRESULT GetClassLayout ( 
        mdTypeDef   td, 
        DWORD       *pdwPackSize,
        COR_FIELD_OFFSET rFieldOffset[],
        ULONG       cMax,
        ULONG       *pcFieldOffset,
        ULONG       *pulClassSize
    );
        
    HRESULT GetCustomAttributeByName (
        mdToken     tkObj,
        LPCWSTR     szName,
        const void  **ppData,
        ULONG       *pcbData
    );
        
    HRESULT GetCustomAttributeProps (
        mdCustomAttribute cv,
        mdToken     *ptkObj,
        mdToken     *ptkType,
        void const  **ppBlob,
        ULONG       *pcbSize
    );
        
    HRESULT GetEventProps (
        mdEvent     ev,
        mdTypeDef   *pClass, 
        LPCWSTR     szEvent, 
        ULONG       cchEvent, 
        ULONG       *pchEvent, 
        DWORD       *pdwEventFlags,
        mdToken     *ptkEventType,
        mdMethodDef *pmdAddOn, 
        mdMethodDef *pmdRemoveOn, 
        mdMethodDef *pmdFire, 
        mdMethodDef rmdOtherMethod[], 
        ULONG       cMax,
        ULONG       *pcOtherMethod
    );
        
    HRESULT GetFieldMarshal (
        mdToken     tk, 
        PCCOR_SIGNATURE *ppvNativeType,
        ULONG       *pcbNativeType 
    );
        
    HRESULT GetFieldProps (
        mdFieldDef  mb, 
        mdTypeDef   *pClass,
        LPWSTR      szField,
        ULONG       cchField, 
        ULONG       *pchField,
        DWORD       *pdwAttr,
        PCCOR_SIGNATURE *ppvSigBlob, 
        ULONG       *pcbSigBlob, 
        DWORD       *pdwCPlusTypeFlag, 
        UVCP_CONSTANT *ppValue,
        ULONG       *pcchValue
    );
        
    HRESULT GetInterfaceImplProps (
        mdInterfaceImpl iiImpl,
        mdTypeDef   *pClass,
        mdToken     *ptkIface)
    );
        
    HRESULT GetMemberProps (
        mdToken     mb, 
        mdTypeDef   *pClass,
        LPWSTR      szMember, 
        ULONG       cchMember, 
        ULONG       *pchMember, 
        DWORD       *pdwAttr,
        PCCOR_SIGNATURE *ppvSigBlob, 
        ULONG       *pcbSigBlob, 
        ULONG       *pulCodeRVA, 
        DWORD       *pdwImplFlags, 
        DWORD       *pdwCPlusTypeFlag, 
        UVCP_CONSTANT *ppValue,
        ULONG       *pcchValue
    );

    HRESULT GetMemberRefProps (
        mdMemberRef mr, 
        mdToken     *ptk, 
        LPWSTR      szMember, 
        ULONG       cchMember, 
        ULONG       *pchMember, 
        PCCOR_SIGNATURE *ppvSigBlob, 
        ULONG       *pbSig 
    );

    HRESULT GetMethodProps (
        mdMethodDef mb, 
        mdTypeDef   *pClass, 
        LPWSTR      szMethod, 
        ULONG       cchMethod, 
        ULONG       *pchMethod,
        DWORD       *pdwAttr, 
        PCCOR_SIGNATURE *ppvSigBlob, 
        ULONG       *pcbSigBlob, 
        ULONG       *pulCodeRVA, 
        DWORD       *pdwImplFlags
    );
        
    HRESULT GetMethodSemantics (
        mdMethodDef mb,
        mdToken     tkEventProp,
        DWORD       *pdwSemanticsFlags
    );
                
    HRESULT GetModuleFromScope (
        mdModule    *pmd
    );
        
    HRESULT GetModuleRefProps (
        mdModuleRef mur,
        LPWSTR      szName, 
        ULONG       cchName, 
        ULONG       *pchName 
    );
        
    HRESULT GetNameFromToken (
        mdToken     tk,
        MDUTF8CSTR  *pszUtf8NamePtr
    );
        
    HRESULT GetNativeCallConvFromSig (
        void const  *pvSig,
        ULONG       cbSig,
        ULONG       *pCallConv
    );
        
    HRESULT GetNestedClassProps (
        mdTypeDef   tdNestedClass,
        mdTypeDef   *ptdEnclosingClass
    );
        
    HRESULT GetParamForMethodIndex (
        mdMethodDef md,
        ULONG       ulParamSeq,
        mdParamDef  *ppd
    );

    HRESULT GetParamProps (
        mdParamDef  tk,
        mdMethodDef *pmd,
        ULONG       *pulSequence,
        LPWSTR      szName,
        ULONG       cchName,
        ULONG       *pchName,
        DWORD       *pdwAttr,
        DWORD       *pdwCPlusTypeFlag,
        UVCP_CONSTANT *ppValue,
        ULONG       *pcchValue
    );
        
    HRESULT GetPermissionSetProps (
        mdPermission pm,
        DWORD       *pdwAction, 
        void const  **ppvPermission, 
        ULONG       *pcbPermission
    );
        
    HRESULT GetPinvokeMap (
        mdToken     tk,
        DWORD       *pdwMappingFlags,
        LPWSTR      szImportName,
        ULONG       cchImportName,
        ULONG       *pchImportName,
        mdModuleRef *pmrImportDLL
    );
        
    HRESULT GetPropertyProps (
        mdProperty  prop,
        mdTypeDef   *pClass, 
        LPCWSTR     szProperty, 
        ULONG       cchProperty, 
        ULONG       *pchProperty, 
        DWORD       *pdwPropFlags, 
        PCCOR_SIGNATURE *ppvSig, 
        ULONG       *pbSig, 
        DWORD       *pdwCPlusTypeFlag, 
        UVCP_CONSTANT *ppDefaultValue,
        ULONG       *pcchDefaultValue,
        mdMethodDef *pmdSetter, 
        mdMethodDef *pmdGetter, 
        mdMethodDef rmdOtherMethod[],
        ULONG       cMax, 
        ULONG       *pcOtherMethod 
    );
        
    HRESULT GetRVA (
        mdToken     tk, 
        ULONG       *pulCodeRVA, 
        DWORD       *pdwImplFlags
    );
        
    HRESULT GetScopeProps (
        LPWSTR      szName,
        ULONG       cchName,
        ULONG       *pchName,
        GUID        *pmvid
    );
        
    HRESULT GetSigFromToken ( 
        mdSignature mdSig, 
        PCCOR_SIGNATURE *ppvSig, 
        ULONG       *pcbSig 
    );
        
    HRESULT GetTypeDefProps 
        mdTypeDef   td,
        LPWSTR      szTypeDef,
        ULONG       cchTypeDef,
        ULONG       *pchTypeDef,
        DWORD       *pdwTypeDefFlags,
        mdToken     *ptkExtends
    );
        
    HRESULT GetTypeRefProps (
        mdTypeRef   tr,
        mdToken     *ptkResolutionScope,
        LPWSTR      szName,
        ULONG       cchName,
        ULONG       *pchName
    );
        
    HRESULT GetTypeSpecFromToken ( 
        mdTypeSpec  typespec, 
        PCCOR_SIGNATURE *ppvSig, 
        ULONG       *pcbSig
    );
        
    HRESULT GetUserString (
        mdString    stk,
        LPWSTR      szString,
        ULONG       cchString,
        ULONG       *pchString
    );
        
    HRESULT IsGlobal (
        mdToken     pd,
        int         *pbGlobal
    );
        
    BOOL IsValidToken (
        mdToken     tk
    );

    HRESULT ResetEnum (
        HCORENUM    hEnum, 
        ULONG       ulPos
    );
        
    HRESULT ResolveTypeRef (
        mdTypeRef   tr,
        REFIID      riid,
        IUnknown    **ppIScope,
        mdTypeDef   *ptd
    );
        
};

Métodos

Método	Descripción
IMetaDataImport::CloseEnum (Método)	Cierra el enumerador con el identificador especificado.
IMetaDataImport::CountEnum (Método)	Obtiene el número de elementos del enumerador con el identificador especificado.
IMetaDataImport::EnumCustomAttributes (Método)	Enumera una lista de símbolos (tokens) de definición de atributos personalizados asociada al tipo o al miembro especificado.
IMetaDataImport::EnumEvents (Método)	Enumera los símbolos (token) de definición de eventos para el símbolo (token) de TypeDef especificado.
IMetaDataImport::EnumFields (Método)	Enumera los símbolos (token) de FieldDef para el tipo al que hace referencia el símbolo (token) de TypeDef especificado.
IMetaDataImport::EnumFieldsWithName (Método)	Enumera los símbolos (token) de FieldDef del tipo especificado con el nombre especificado.
IMetaDataImport::EnumInterfaceImpls (Método)	Enumera los símbolos (token) de MethodDef que representan implementaciones de interfaz.
IMetaDataImport::EnumMemberRefs (Método)	Enumera los símbolos (token) de MemberRef que representan miembros del tipo especificado.
IMetaDataImport::EnumMembers (Método)	Enumera los símbolos (token) de MemberDef que representan miembros del tipo especificado.
IMetaDataImport::EnumMembersWithName (Método)	Enumera los símbolos (token) de MemberDef que representan miembros del tipo especificado con el nombre especificado.
IMetaDataImport::EnumMethodImpls (Método)	Enumera los símbolos (token) de MethodBody y MethodDeclaration que representan métodos del tipo especificado.
IMetaDataImport::EnumMethods (Método)	Enumera los símbolos (token) de MethodDef que representan métodos del tipo especificado.
IMetaDataImport::EnumMethodSemantics (Método)	Enumera las propiedades y los eventos del cambio de propiedad con los que está relacionado el método especificado.
IMetaDataImport::EnumMethodsWithName (Método)	Enumera los métodos con el nombre especificado y que son definidos por el tipo al que hace referencia el símbolo (token) de TypeDef especificado.
IMetaDataImport::EnumModuleRefs (Método)	Enumera los símbolos (token) de ModuleRef que representan los módulos importados.
IMetaDataImport::EnumParams (Método)	Enumera los símbolos (token) de ParamDef que representan los parámetros del método al que hace referencia el símbolo (token) de MethodDef especificado.
IMetaDataImport::EnumPermissionSets (Método)	Enumera los permisos para los objetos en un ámbito de metadatos especificado.
IMetaDataImport::EnumProperties (Método)	Enumera los símbolos (token) de PropertyDef que representan las propiedades del tipo al que hace referencia el símbolo (token) de TypeDef especificado.
IMetaDataImport::EnumSignatures (Método)	Enumera los símbolos (token) de Signature que representan las firmas independientes del ámbito actual.
IMetaDataImport::EnumTypeDefs (Método)	Enumera los símbolos (token) de TypeDef que representan todos los tipos del ámbito actual.
IMetaDataImport::EnumTypeRefs (Método)	Enumera los símbolos (token) de TypeRef definidos en el ámbito de metadatos actual.
IMetaDataImport::EnumTypeSpecs (Método)	Enumera los símbolos (token) de TypeSpec definidos en el ámbito de metadatos actual.
IMetaDataImport::EnumUnresolvedMethods (Método)	Enumera los símbolos (token) de MemberDef que representan los métodos no resueltos en el ámbito de metadatos actual.
IMetaDataImport::EnumUserStrings (Método)	Enumera los símbolos (token) de String que representan las cadenas incluidas en el código en el ámbito de metadatos actual.
IMetaDataImport::FindField (Método)	Obtiene el símbolo (token) de FieldDef para el campo que es miembro del tipo especificado, y que tiene el nombre y la firma de metadatos especificados.
IMetaDataImport::FindMember (Método)	Obtiene un puntero al símbolo (token) de MemberDef para el miembro definido por el tipo especificado con el nombre y la firma de metadatos especificados.
IMetaDataImport::FindMemberRef (Método)	Obtiene un puntero al símbolo (token) de MemberRef para el miembro definido por el tipo especificado con el nombre y la firma de metadatos especificados.
IMetaDataImport::FindMethod (Método)	Obtiene un puntero al símbolo (token) de MemberDef para el método definido por el tipo especificado con el nombre y la firma de metadatos especificados.
IMetaDataImport::FindTypeDefByName (Método)	Obtiene un puntero al símbolo (token) de metadatos de TypeDef para el tipo con el nombre especificado.
IMetaDataImport::FindTypeRef (Método)	Obtiene un puntero al símbolo (token) de metadatos de TypeRef que hace referencia al tipo en el ámbito de búsqueda especificado con el nombre especificado.
IMetaDataImport::GetClassLayout (Método)	Obtiene información de diseño para la clase a la que hace referencia el símbolo (token) de TypeDef especificado.
IMetaDataImport::GetCustomAttributeByName (Método)	Obtiene el valor del atributo personalizado, dado su nombre.
IMetaDataImport::GetCustomAttributeProps (Método)	Obtiene el valor del atributo personalizado, dado su símbolo de metadatos.
IMetaDataImport::GetEventProps (Método)	Obtiene información de metadatos (incluidos el tipo declarativo, los métodos Add y Remove para los delegados, y los indicadores y otros datos asociados) para el evento representado por el símbolo (token) de evento especificado.
IMetaDataImport::GetFieldMarshal (Método)	Obtiene un puntero al tipo nativo y no administrado del campo representado por el símbolo (token) de metadatos de Field.
IMetaDataImport::GetFieldProps (Método)	Obtiene los metadatos asociados al campo al que hace referencia el símbolo (token) de FieldDef especificado.
IMetaDataImport::GetInterfaceImplProps (Método)	Obtiene un puntero a los símbolos (tokens) de metadatos para el tipo que implementa el método especificado y para la interfaz que declara dicho método.
IMetaDataImport::GetMemberProps (Método)	Obtiene información de metadatos (incluidos el nombre, la firma binaria y la dirección virtual relativa) del miembro de tipo al que hace referencia el símbolo (token) de metadatos especificado.
IMetaDataImport::GetMemberRefProps (Método)	Obtiene los metadatos asociados al miembro al que hace referencia el símbolo (token) especificado.
IMetaDataImport::GetMethodProps (Método)	Obtiene los metadatos asociados al método al que hace referencia el símbolo (token) de MethodDef especificado.
IMetaDataImport::GetMethodSemantics (Método)	Obtiene un puntero a la relación entre el método al que hace referencia el símbolo (token) de MethodDef especificado y la propiedad y el evento emparejados a los que hace referencia el símbolo (token) de EventProp especificado.
IMetaDataImport::GetModuleFromScope (Método)	Obtiene un puntero al símbolo (token) de metadatos para el módulo al que se hace referencia en el ámbito de metadatos actual.
IMetaDataImport::GetModuleRefProps (Método)	Obtiene el nombre del módulo al que hace referencia el símbolo (token) de metadatos especificado.
IMetaDataImport::GetNameFromToken (Método)	Obtiene el nombre UTF-8 del objeto al que hace referencia el símbolo (token) de metadatos especificado.
IMetaDataImport::GetNativeCallConvFromSig (Método)	Obtiene la convención nativa de llamadas para el método representado por el puntero de firma especificado.
IMetaDataImport::GetNestedClassProps (Método)	Obtiene el símbolo (token) de TypeDef para el tipo primario envolvente del tipo anidado especificado.
IMetaDataImport::GetParamForMethodIndex (Método)	Obtiene un puntero al símbolo (token) que representa el parámetro de la posición ordinal especificada en la secuencia de parámetros de método para el método representado por el símbolo (token) de MethodDef especificado.
IMetaDataImport::GetParamProps (Método)	Obtiene los valores de metadatos para el parámetro al que hace referencia el símbolo (token) de ParamDef especificado.
IMetaDataImport::GetPermissionSetProps (Método)	Obtiene los metadatos asociados a la clase System.Security.PermissionSet representada por el símbolo (token) de Permission especificado.
IMetaDataImport::GetPinvokeMap (Método)	Obtiene un símbolo (token) de ModuleRef para representar el ensamblado de destino de una llamada PInvoke.
IMetaDataImport::GetPropertyProps (Método)	Obtiene los metadatos asociados a la propiedad que representa el símbolo (token) especificado.
IMetaDataImport::GetRVA (Método)	Obtiene el desplazamiento de la dirección virtual relativa del objeto de código representado por el símbolo (token) especificado.
IMetaDataImport::GetScopeProps (Método)	Obtiene el nombre y, opcionalmente, el identificador de versión del ensamblado o módulo en el ámbito de metadatos actual.
IMetaDataImport::GetSigFromToken (Método)	Obtiene la firma de metadatos binaria asociada al símbolo (token) especificado.
IMetaDataImport::GetTypeDefProps (Método)	Devuelve información de metadatos para el tipo representado por el símbolo (token) de TypeDef especificado.
IMetaDataImport::GetTypeRefProps (Método)	Obtiene los metadatos asociados al tipo al que hace referencia el símbolo (token) de TypeRef especificado.
IMetaDataImport::GetTypeSpecFromToken (Método)	Obtiene la firma de metadatos binaria de la especificación de tipos representada por el símbolo (token) especificado.
IMetaDataImport::GetUserString (Método)	Obtiene la cadena literal representada por el símbolo (token) de metadatos especificado.
IMetaDataImport::IsGlobal (Método)	Obtiene un valor que indica si el campo, el método o el tipo representado por el símbolo (token) de metadatos especificado tiene ámbito global.
IMetaDataImport::IsValidToken (Método)	Obtiene un valor que indica si el símbolo (token) especificado contiene una referencia válida a un objeto de código.
IMetaDataImport::ResetEnum (Método)	Restablece el enumerador especificado a la posición especificada.
IMetaDataImport::ResolveTypeRef (Método)	Obtiene información de tipo para el tipo al que hace referencia el símbolo (token) de TypeRef especificado.

Comentarios

El diseño de la interfaz IMetaDataImport está pensado principalmente para su uso con herramientas y servicios que van a importar información de tipo (por ejemplo, herramientas de desarrollo) o que van a administrar componentes implementados (por ejemplo, servicios de resolución o activación). Los métodos de IMetaDataImport pertenecen a las categorías de tareas siguientes:

Enumerar colecciones de elementos en el ámbito de los metadatos.
Encontrar un elemento que tiene un conjunto de características específico.
Obtener las propiedades de un elemento especificado.
Los métodos Get están diseñados específicamente para devolver propiedades de un solo valor de un elemento de metadatos. Cuando la propiedad es una referencia a otro elemento, se devuelve un símbolo (token) para ese elemento. Cualquier tipo de entrada de puntero puede ser NULL para indicar que no se solicita ese valor concreto. Para obtener propiedades que sean esencialmente objetos de colección (por ejemplo, la colección de interfaces que una clase implementa), utilice los métodos de enumeración.