IAnnotatedElement Interface
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Representa um elemento anotado do programa atualmente em execução nesta VM.
[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
- Atributos
- Implementações
Comentários
Representa um elemento anotado do programa atualmente em execução nesta VM. Essa interface permite que as anotações sejam lidas com reflexão. Todas as anotações retornadas por métodos nessa interface são imutáveis e serializáveis. As matrizes retornadas por métodos dessa interface podem ser modificadas por chamadores sem afetar as matrizes retornadas a outros chamadores.
Observação do Android: métodos que retornam várias anotações de diferentes tipos, como #getAnnotations() e #getDeclaredAnnotations() podem ser afetados pela ordenação explícita de código de caractere de tipos de anotações especificados pelo formato DEX. Não há garantia de que anotações de tipos diferentes em um único elemento sejam retornadas na ordem em que são declaradas na origem.
Os #getAnnotationsByType(Class) métodos e os métodos #getDeclaredAnnotationsByType(Class) dão suporte a várias anotações do mesmo tipo em um elemento. Se o argumento para qualquer método for um tipo de anotação repetível (JLS 9.6), o método "analisará" uma anotação de contêiner (JLS 9.7), se estiver presente, e retornará quaisquer anotações dentro do contêiner. As anotações de contêiner podem ser geradas em tempo de compilação para encapsular várias anotações do tipo de argumento.
Os termos <em que eles>estão diretamente presentes</em>, <em>indiretamente presentes</em>, <em>presentes</em> e <em>associados</em> são usados em toda essa interface para descrever precisamente quais anotações são retornadas por métodos:
<ul>
<li> Uma anotação A está <presente></em diretamente em> um elemento E se E for anotado por A na origem original.
<li>Uma anotação A é <em>indiretamente presente</em> um elemento E se E for anotado por uma anotação de contêiner de A.
<li>Uma anotação A está presente em um elemento E se:
<ul>
<li>A está diretamente presente no E; ou
<li>Nenhuma anotação do tipo A está diretamente presente em E, e E é uma classe, e o tipo A é herdável, e A está presente na superclasse de E.
</ul>
<li>Uma anotação A está <associada></em> com um elemento E se for:
<ul>
<li>A está presente direta ou indiretamente no E; ou
<li>Nenhuma anotação do tipo de A está presente direta ou indiretamente em E, e E é uma classe, e o tipo de A é herdável e A está associado à superclasse de E.
</ul>
</ul>
A tabela a seguir resume quais tipos de métodos diferentes de presença de anotação nesta interface examinam.
<table class="plain">caption Visão geral do tipo de presença detectada por diferentes métodos< AnnotatedElement/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 th><scope="col">Signature</th th><scope="col">Directly Present</th th><scope="col"><>Indiretamente Presente</th 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 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><style="text-align:center">X</td><td></td></tr><tr><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>< style><=" 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></tr><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/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></tr></tbody></table>
Para uma invocação de get[Declared]AnnotationsByType( Class < T >), a ordem das anotações que estão presentes direta ou indiretamente em um elemento E é computada como se indiretamente apresentassem anotações em E diretamente presentes no E no lugar de sua anotação de contêiner, na ordem em que aparecem no elemento de valor da anotação do contêiner.
Há várias preocupações de compatibilidade para ter em mente se um tipo de anotação T é originalmente <em>não</em> repetível e posteriormente modificado para ser repetível.
O tipo de anotação que contém para T é TC.
<ul>
<li>Modificar T para ser repetível é compatível de origem e binário com usos existentes de T e com usos existentes de TC.
Ou seja, para compatibilidade de origem, o código-fonte com anotações do tipo T ou do tipo TC ainda será compilado. Para compatibilidade binária, arquivos de classe com anotações do tipo T ou do tipo TC (ou com outros tipos de usos do tipo T ou do tipo TC) serão vinculados à versão modificada do T se eles estiverem vinculados à versão anterior.
(Um TC do tipo de anotação pode servir informalmente como uma ação que contém o tipo de anotação antes de T ser modificado para ser formalmente repetível. Como alternativa, quando T se torna repetível, o TC pode ser introduzido como um novo tipo.)
<li>Se um tipo de anotação TC estiver presente em um elemento e T for modificado para ser repetível com TC como o tipo de anotação que contém, em seguida:
<ul>
<li>A alteração para T é compatível comportamentalmente com relação ao get[Declared]Annotation(Class<T>) (chamado com um argumento de T ou TC) e get[Declared]Annotations() aos métodos porque os resultados dos métodos não serão alterados devido ao TC se tornar o tipo de anotação que contém t.
<li>A alteração para T altera os resultados dos get[Declared]AnnotationsByType(Class<T>) métodos chamados com um argumento de T, pois esses métodos agora reconhecerão uma anotação do tipo TC como uma anotação de contêiner para T e o "procurarão" para expor anotações do tipo T.
</ul>
<li>Se uma anotação do tipo T estiver presente em um elemento e T se tornar repetível e mais anotações do tipo T forem adicionadas ao elemento:
<ul>
<li> A adição das anotações do tipo T é compatível com a origem e compatível com binários.
<li>A adição das anotações do tipo T altera os resultados dos get[Declared]Annotation(Class<T>) métodos e get[Declared]Annotations() métodos, pois esses métodos agora verão apenas uma anotação de contêiner no elemento e não verão uma anotação do tipo T.
<li>A adição das anotações do tipo T altera os resultados dos get[Declared]AnnotationsByType(Class<T>) métodos, pois seus resultados exporão as anotações adicionais do tipo T , enquanto anteriormente eles expuseram apenas uma única anotação do tipo T.
</ul>
</ul>
Se uma anotação retornada por um método nessa interface contiver (direta ou indiretamente) um Classmembro -valued referindo-se a uma classe que não está acessível nesta VM, tentar ler a classe chamando o método de retorno de classe relevante na anotação retornada resultará em um TypeNotPresentException.
Da mesma forma, a tentativa de ler um membro com valor de enumeração resultará em um EnumConstantNotPresentException se a constante de enumeração na anotação não estiver mais presente no tipo de enumeração.
Se um tipo de anotação T for (meta-)anotado com uma @Repeatable anotação cujo elemento de valor indica um tipo TC, mas TC não declarar um value() método com um tipo de retorno de T[], uma exceção de tipo java.lang.annotation.AnnotationFormatError será gerada.
Por fim, tentar ler um membro cuja definição evoluiu incompatibly resultará em um java.lang.annotation.AnnotationTypeMismatchException ou um java.lang.annotation.IncompleteAnnotationException.
Adicionado em 1.5.
Java documentação para java.lang.reflect.AnnotatedElement.
Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na Creative Commons 2.5.
Propriedades
| Nome | Description |
|---|---|
| Handle |
Obtém o valor JNI do objeto Android subjacente. (Herdado de IJavaObject) |
| JniIdentityHashCode |
Retorna o valor da |
| JniManagedPeerState |
Estado do par gerenciado. (Herdado de IJavaPeerable) |
| JniObjectReferenceControlBlock |
Representa um elemento anotado do programa atualmente em execução nesta VM. (Herdado de IJavaPeerable) |
| JniPeerMembers |
Acesso ao membro e suporte à invocação. (Herdado de IJavaPeerable) |
| PeerReference |
Retorna uma JniObjectReference das instâncias de objeto Java encapsuladas. (Herdado de IJavaPeerable) |
Métodos
| Nome | Description |
|---|---|
| Disposed() |
Chamado quando a instância foi descartada. (Herdado de IJavaPeerable) |
| DisposeUnlessReferenced() |
Se não houver referências pendentes a essa instância, então chamará |
| Finalized() |
Chamado quando a instância foi finalizada. (Herdado de IJavaPeerable) |
| GetAnnotation(Class) |
Retorna a anotação desse elemento para o tipo especificado se tal anotação estiver <presente></em>, caso contrário, nulo. |
| GetAnnotations() |
Retorna anotações que estão <presentes></em> neste elemento. |
| GetAnnotationsByType(Class) |
Retorna anotações que estão associadas<></em> com esse elemento. |
| GetDeclaredAnnotation(Class) |
Retorna a anotação desse elemento para o tipo especificado se essa anotação estiver <presente></em> diretamente, caso contrário, nulo. |
| GetDeclaredAnnotations() |
Retorna anotações que estão <>presentes</em> diretamente neste elemento. |
| GetDeclaredAnnotationsByType(Class) |
Retorna as anotações desse elemento para o tipo especificado se essas anotações estiverem <>diretamente presentes</em> ou <em>indiretamente presentes</em.> |
| IsAnnotationPresent(Class) |
Retornará true se uma anotação para o tipo especificado estiver <presente></em> neste elemento, caso contrário, false. |
| SetJniIdentityHashCode(Int32) |
Defina o valor retornado por |
| SetJniManagedPeerState(JniManagedPeerStates) |
Representa um elemento anotado do programa atualmente em execução nesta VM. (Herdado de IJavaPeerable) |
| SetPeerReference(JniObjectReference) |
Defina o valor retornado por |
| UnregisterFromRuntime() |
Cancele o registro dessa instância para que o runtime não a retorne de invocações futuras Java.Interop.JniRuntime+JniValueManager.PeekValue . (Herdado de IJavaPeerable) |
Métodos de Extensão
| Nome | Description |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Obtém o nome JNI do tipo da instância |
| JavaAs<TResult>(IJavaPeerable) |
Tente coagir a digitar |
| JavaCast<TResult>(IJavaObject) |
Executa uma conversão de tipo marcada por runtime do Android. |
| JavaCast<TResult>(IJavaObject) |
Representa um elemento anotado do programa atualmente em execução nesta VM. |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Tente coagir a digitar |