IAnnotatedElement Interfaz

Definición

Espacio de nombres:

Java.Lang.Reflect

Ensamblado:

Mono.Android.dll

Representa un elemento anotado del programa que se ejecuta actualmente en esta máquina virtual.

[Android.Runtime.Register("java/lang/reflect/AnnotatedElement", "", "Java.Lang.Reflect.IAnnotatedElementInvoker")]
public interface IAnnotatedElement : Android.Runtime.IJavaObject, IDisposable, Java.Interop.IJavaPeerable

[<Android.Runtime.Register("java/lang/reflect/AnnotatedElement", "", "Java.Lang.Reflect.IAnnotatedElementInvoker")>]
type IAnnotatedElement = interface
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Derivado

Java.Lang.Class

Java.Lang.Package

Java.Lang.Reflect.AccessibleObject

Java.Lang.Reflect.Constructor

Java.Lang.Reflect.Executable

Java.Lang.Reflect.IGenericDeclaration

Java.Lang.Reflect.Method

Java.Lang.Reflect.Parameter

Java.Lang.Reflect.RecordComponent

Atributos

RegisterAttribute

Implementaciones

IJavaObject IJavaPeerable IDisposable

Comentarios

Representa un elemento anotado del programa que se ejecuta actualmente en esta máquina virtual. Esta interfaz permite que las anotaciones se lean de forma reflexiva. Todas las anotaciones devueltas por métodos de esta interfaz son inmutables y serializables. Los autores de llamadas pueden modificar las matrices devueltas por métodos de esta interfaz sin afectar a las matrices devueltas a otros autores de llamadas.

Nota de Android: métodos que devuelven varias anotaciones de diferentes tipos, como #getAnnotations() y #getDeclaredAnnotations() pueden verse afectadas por la ordenación explícita de códigos de caracteres de los tipos de anotaciones especificados por el formato DEX. No se garantiza que las anotaciones de diferentes tipos en un solo elemento se devuelvan en el orden en que se declaran en el origen.

Los #getAnnotationsByType(Class) métodos y #getDeclaredAnnotationsByType(Class) admiten varias anotaciones del mismo tipo en un elemento . Si el argumento para cualquiera de los métodos es un tipo de anotación repetible (JLS 9.6), el método "buscará" una anotación de contenedor (JLS 9.7), si está presente y devolverá cualquier anotación dentro del contenedor. Las anotaciones de contenedor se pueden generar en tiempo de compilación para encapsular varias anotaciones del tipo de argumento.

Los términos <em directamente>presentes</em>, <em>indirectamente present</em>, <em>present</em>, y <em>associated</em> se usan a lo largo de esta interfaz para describir exactamente qué anotaciones se devuelven por métodos:

<ul>

<li> An annotation A is <em>directly present</em> on an element E if E is annotated by A in the original source.

<li>Una anotación A está <>presente</em> indirectamente en un elemento E si E está anotada por una anotación contenedora de A.

<li>Una anotación A está presente en un elemento E si:

<ul>

<li>A está directamente presente en E; o

<li>No hay anotación del tipo de A directamente presente en E, y E es una clase, y el tipo A se puede heredar, y A está presente en la superclase de E.

</ul>

<li>An annotation A is <em>associated</em> with an element E if either:

<ul>

<li>A está presente directa o indirectamente en E; o

<li>No se puede heredar ninguna anotación del tipo de A directamente o indirectamente en E, y E es una clase, y el tipo de A se puede heredar, y A está asociado a la superclase de E.

</ul>

</ul>

En la tabla siguiente se resume el tipo de presencia de anotaciones diferentes métodos de esta interfaz.

<table class="plain">caption Overview of kind of presence detected by different AnnotatedElement methods</caption><thead><tr>th colspan=2 scope="col"<method></th><colspan=4 scope="col">kind of Presence</th tr>th<>scope="col"<return Type></th><scope="col"><signature/th><scope="col">directly Present</><th scope="col"th scope="col"th scope="col"><>Indirectamente Present</th><scope="col">Present</th th><scope="col">Associated</th></thead><tbody><tr><td style="text-align:right">T</td><th scope="row" style="font-weight:normal; text-align:left">#getAnnotation(Class) getAnnotation(Class<T>)<td></td><><td td>< style="text-align:center">X</><td td></td></tr tr td><><style=" text-align:right">Annotation[]</td><th scope="row" style="font-weight:normal; text-align:left">#getAnnotations getAnnotations()<td></td><td td>< td td td><style="text-align:center">X</td td><></td>< tr td td><><style="text-align:right">T[]</td><th scope="row" style="font-weight:normal; text-align:left">#getAnnotationsByType(Class) getAnnotationsByType(Class<T>)<td></td><td><>< td></td td><td=" text-align:center">X</td></tr tr><><td style="text-align:right">T</td><th scope="row" style="font-weight:normal; text-align:left">#getDeclaredAnnotation(Class) getDeclaredAnnotation(Class<T>)<td style="text-align:center">X</td><td td></td><><>< td>< td/td td></tr td><><style="text-align:right">Annotation[]</td><th scope="row" style=" font-weight:normal; text-align:left">#getDeclaredAnnotations getDeclaredAnnotations()<td style="text-align:center">X</td td><></td td><></td><td></td></tr tr>td<><style="text-align:right">T[]</td><th scope="row" style="font-weight:normal; text-align:left">#getDeclaredAnnotationsByType(Class) getDeclaredAnnotationsByType(Class<T>)<td style="text-align:center">X</td td><style="text-align:center">X</td><td td>< td td td td><></td></tr></tbody></table>

Para una invocación de get[Declared]AnnotationsByType( Class < T >), el orden de las anotaciones que están directamente o indirectamente presentes en un elemento E se calcula como si las anotaciones presentes indirectamente en E estén directamente presentes en E en lugar de su anotación contenedora, en el orden en que aparecen en el elemento de valor de la anotación contenedora.

Hay varios problemas de compatibilidad que se deben tener en cuenta si un tipo de anotación T originalmente <no>< se>puede repetir y posteriormente se modifica para que se pueda repetir.

El tipo de anotación contenedor para T es TC.

<ul>

<li>modificar T para que se pueda repetir es el origen y el binario compatible con los usos existentes de T y con los usos existentes de TC.

Es decir, para la compatibilidad de código fuente, el código fuente con anotaciones de tipo T o de tipo TC seguirá compilando. Para la compatibilidad binaria, los archivos de clase con anotaciones de tipo T o de tipo TC (o con otros tipos de usos de tipo T o de tipo TC) se vincularán con la versión modificada de T si se vinculan con la versión anterior.

(Un tipo de anotación TC puede servir informalmente como una acción que contiene el tipo de anotación antes de que se modifique T para que se pueda repetir formalmente. Como alternativa, cuando T se realiza repetible, TC se puede introducir como un nuevo tipo).

<li>Si un tipo de anotación TC está presente en un elemento, y T se modifica para que se pueda repetir con TC como su tipo de anotación contenedora entonces:

<ul>

<li>El cambio a T es compatible con el comportamiento con respecto a get[Declared]Annotation(Class<T>) (llamado con un argumento de T o TC) y get[Declared]Annotations() los métodos porque los resultados de los métodos no cambiarán debido a que TC se convierte en el tipo de anotación contenedor para T.

<li>El cambio a T cambia los resultados de los métodos a los get[Declared]AnnotationsByType(Class<T>) que se llama con un argumento de T, ya que esos métodos ahora reconocerán una anotación de tipo TC como una anotación de contenedor para T y la "buscarán" para exponer anotaciones de tipo T.

</ul>

<li>Si hay una anotación de tipo T presente en un elemento y T se realiza repetible y se agregan más anotaciones de tipo T al elemento:

<ul>

<li> La adición de las anotaciones de tipo T es compatible con el origen y el binario.

<li>La adición de las anotaciones de tipo T cambia los resultados de los get[Declared]Annotation(Class<T>) métodos y get[Declared]Annotations() métodos, ya que esos métodos ahora solo verán una anotación de contenedor en el elemento y no verán una anotación de tipo T.

<li>La adición de las anotaciones de tipo T cambia los resultados de los get[Declared]AnnotationsByType(Class<T>) métodos, ya que sus resultados expondrán las anotaciones adicionales de tipo T , mientras que anteriormente solo expusieron una sola anotación de tipo T.

</ul>

</ul>

Si una anotación devuelta por un método de esta interfaz contiene (directa o indirectamente) un Classmiembro con valores que hace referencia a una clase que no es accesible en esta máquina virtual, si intenta leer la clase llamando al método de devolución de clase correspondiente en la anotación devuelta producirá un TypeNotPresentException.

Del mismo modo, al intentar leer un miembro con valores de enumeración, se producirá una EnumConstantNotPresentException excepción si la constante de enumeración de la anotación ya no está presente en el tipo de enumeración.

Si un tipo de anotación T es (meta-)anotado con una @Repeatable anotación cuyo elemento de valor indica un tipo TC, pero TC no declara un value() método con un tipo devuelto de T[], se produce una excepción de tipo java.lang.annotation.AnnotationFormatError .

Por último, si intenta leer un miembro cuya definición ha evolucionado de forma incompatibilidad, se producirá una java.lang.annotation.AnnotationTypeMismatchException excepción o .java.lang.annotation.IncompleteAnnotationException

Agregado en 1.5.

Java documentación para java.lang.reflect.AnnotatedElement.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Propiedades

Nombre	Description
Handle	Obtiene el valor JNI del objeto Android subyacente. (Heredado de IJavaObject)
JniIdentityHashCode	Devuelve el valor de java.lang.System.identityHashCode() para la instancia ajustada. (Heredado de IJavaPeerable)
JniManagedPeerState	Estado del mismo nivel administrado. (Heredado de IJavaPeerable)
JniPeerMembers	Compatibilidad con la invocación y el acceso de miembros. (Heredado de IJavaPeerable)
PeerReference	Devuelve un JniObjectReference de la instancia de objeto Java ajustada. (Heredado de IJavaPeerable)

Métodos

Nombre	Description
Disposed()	Se llama cuando se ha eliminado la instancia. (Heredado de IJavaPeerable)
DisposeUnlessReferenced()	Si no hay referencias pendientes a esta instancia, llama a Dispose(); de lo contrario, no hace nada. (Heredado de IJavaPeerable)
Finalized()	Se llama cuando se ha finalizado la instancia. (Heredado de IJavaPeerable)
GetAnnotation(Class)	Devuelve la anotación de este elemento para el tipo especificado si dicha anotación es <em>present</em>, else null.
GetAnnotations()	Devuelve anotaciones que son <em>present</em> en este elemento.
GetAnnotationsByType(Class)	Devuelve anotaciones que están <asociadas> a em</em> con este elemento.
GetDeclaredAnnotation(Class)	Devuelve la anotación de este elemento para el tipo especificado si dicha anotación es <em>directamente presente</em>, else null.
GetDeclaredAnnotations()	Devuelve anotaciones que están <directamente>presentes</em> en este elemento.
GetDeclaredAnnotationsByType(Class)	Devuelve las anotaciones de este elemento para el tipo especificado si dichas anotaciones están <>directamente presentes</em> o <em>indirectamente presentes</em>.
IsAnnotationPresent(Class)	Devuelve true si una anotación para el tipo especificado es <em>present</em> en este elemento; de lo contrario, false.
SetJniIdentityHashCode(Int32)	Establezca el valor devuelto por JniIdentityHashCode. (Heredado de IJavaPeerable)
SetJniManagedPeerState(JniManagedPeerStates)	Representa un elemento anotado del programa que se ejecuta actualmente en esta máquina virtual. (Heredado de IJavaPeerable)
SetPeerReference(JniObjectReference)	Establezca el valor devuelto por PeerReference. (Heredado de IJavaPeerable)
UnregisterFromRuntime()	Anule el registro de esta instancia para que el entorno de ejecución no lo devuelva de invocaciones futuras Java.Interop.JniRuntime+JniValueManager.PeekValue . (Heredado de IJavaPeerable)

Métodos de extensión

Nombre	Description
GetJniTypeName(IJavaPeerable)	Obtiene el nombre JNI del tipo de la instancia self.
JavaAs<TResult>(IJavaPeerable)	Intente coerción self para escribir TResult, comprobando que la coerción es válida en el lado de Java.
JavaCast<TResult>(IJavaObject)	Realiza una conversión de tipos comprobados en tiempo de ejecución de Android.
JavaCast<TResult>(IJavaObject)	Representa un elemento anotado del programa que se ejecuta actualmente en esta máquina virtual.
TryJavaCast<TResult>(IJavaPeerable, TResult)	Intente coerción self para escribir TResult, comprobando que la coerción es válida en el lado de Java.