IAnnotatedElement Interfaccia
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Rappresenta un elemento annotato del programma attualmente in esecuzione in questa macchina virtuale.
[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- Derivato
- Attributi
- Implementazioni
Commenti
Rappresenta un elemento annotato del programma attualmente in esecuzione in questa macchina virtuale. Questa interfaccia consente la lettura riflettente delle annotazioni. Tutte le annotazioni restituite dai metodi in questa interfaccia non sono modificabili e serializzabili. Le matrici restituite dai metodi di questa interfaccia possono essere modificate dai chiamanti senza influire sulle matrici restituite ad altri chiamanti.
Nota Android: i metodi che restituiscono più annotazioni di tipi diversi, ad #getAnnotations() esempio e #getDeclaredAnnotations() possono essere interessati dall'ordinamento esplicito del codice carattere dei tipi di annotazioni specificati dal formato DEX. Non è garantito che vengano restituite annotazioni di tipi diversi in un singolo elemento nell'ordine in cui vengono dichiarate nell'origine.
I #getAnnotationsByType(Class) metodi e #getDeclaredAnnotationsByType(Class) supportano più annotazioni dello stesso tipo in un elemento . Se l'argomento di uno dei metodi è un tipo di annotazione ripetibile (JLS 9.6), il metodo "esaminerà" un'annotazione del contenitore (JLS 9.7), se presente e restituirà eventuali annotazioni all'interno del contenitore. Le annotazioni del contenitore possono essere generate in fase di compilazione per eseguire il wrapping di più annotazioni del tipo di argomento.
I termini <em>direttamente present</em>, <em>indirettamente present</em>, <em>present</em> e <em>associati</em> vengono usati in questa interfaccia per descrivere con precisione quali annotazioni vengono restituite dai metodi:
<ul>
<li> Un'annotazione A è <direttamente>presente</em> su un elemento E se E è annotato da A nell'origine originale.
<li>Un'annotazione A è <indirettamente>presente</em> su un elemento E se E è annotata da un'annotazione contenitore di A.
<li>Un'annotazione A è presente su un elemento E se:
<ul>
<li>A è presente direttamente su E; o
<li>No annotation of A 's type is directly present on E, and E is a class, and A 's type is inheritable, and A is present on the superclass of E.
</ul>
<li>Un'annotazione A è <em>associata</em> a un elemento E se:
<ul>
<li>A è direttamente o indirettamente presente su E; o
<li>Nessuna annotazione del tipo di A è direttamente o indirettamente presente su E ed E è una classe e il tipo di A è ereditabile e A è associato alla superclasse di E.
</ul>
</ul>
La tabella seguente riepiloga il tipo di presenza di annotazione diversi metodi in questa interfaccia.
<table class="plain">caption Overview of kind of presence detected by different AnnotatedElement methods</caption><thead><tr>th colspan=2 scope="col"<Method></th 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><scope="col"><>Indirettamente 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><><td style=" text-align:right">Annotation[]</td><th scope="row" style="font-weight:normal; text-align:left">#getAnnotations getAnnotations()<td></td><td td><>< style="text-align:center"X>/td<td></><>tr tr<><td style="text-align:right"><>T[]/td d<>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"td style="text-align:center">X#getDeclaredAnnotation(Class) getDeclaredAnnotation(Class<T>)/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><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 td><style="text-align:center">X</td td><td>< td><></td></tr></tbody></table>
Per una chiamata di get[Declared]AnnotationsByType( Class < T >), l'ordine delle annotazioni che sono direttamente o indirettamente presenti su un elemento E viene calcolato come se presenti indirettamente annotazioni suE al posto dell'annotazione contenitore, nell'ordine in cui appaiono nell'elemento valore dell'annotazione contenitore.
Esistono diversi problemi di compatibilità da tenere presente se un tipo di annotazione T è originariamente <ripetibile em>non</em> e successivamente modificato per essere ripetibile.
Il tipo di annotazione contenitore per T è TC.
<ul>
<li Modifying > to be repeatable is source and binary compatible with existing uses of T and with existing uses of TC.li Modifying T to be repeatable is source and binary compatible with existing uses of T and with existing uses of TC.
Ovvero, per la compatibilità con l'origine, il codice sorgente con annotazioni di tipo T o tc di tipo continuerà a essere compilato. Per la compatibilità binaria, i file di classe con annotazioni di tipo T o di tipo TC (o con altri tipi di usi di tipo T o TC di tipo) verranno collegati alla versione modificata di T se collegati alla versione precedente.
Un tipo di annotazione TC può essere utilizzato in modo informale come tipo di annotazione che agisce prima che T venga modificato per essere formalmente ripetibile. In alternativa, quando T è reso ripetibile, TC può essere introdotto come nuovo tipo.
<li>Se un tipo di annotazione TC è presente in un elemento e T viene modificato per essere ripetibile con TC come tipo di annotazione contenitore, allora:
<ul>
<li>La modifica a T è compatibile in modo comportamentale rispetto al get[Declared]Annotation(Class<T>) (chiamato con un argomento di T o TC) e get[Declared]Annotations() metodi perché i risultati dei metodi non cambieranno a causa di TC diventando il tipo di annotazione contenitore per T.
<li>La modifica a T modifica i risultati dei get[Declared]AnnotationsByType(Class<T>) metodi chiamati con un argomento T, perché tali metodi ora riconosceranno un'annotazione di tipo TC come annotazione contenitore per T e lo "esaminerà" per esporre annotazioni di tipo T.
</ul>
<li>Se un'annotazione di tipo T è presente in un elemento e T è resa ripetibile e più annotazioni di tipo T vengono aggiunte all'elemento:
<ul>
<li> L'aggiunta delle annotazioni di tipo T è compatibile con l'origine e la compatibilità binaria.
<li>L'aggiunta delle annotazioni di tipo T modifica i risultati dei metodi e get[Declared]Annotation(Class<T>) dei get[Declared]Annotations() metodi, perché tali metodi ora vedranno solo un'annotazione contenitore sull'elemento e non visualizzerà un'annotazione di tipo T.
<li>L'aggiunta delle annotazioni di tipo T modifica i risultati dei get[Declared]AnnotationsByType(Class<T>) metodi, perché i risultati esporranno le annotazioni aggiuntive di tipo T , mentre in precedenza esponevano solo una singola annotazione di tipo T.
</ul>
</ul>
Se un'annotazione restituita da un metodo in questa interfaccia contiene (direttamente o indirettamente) un Classmembro con valori -che fa riferimento a una classe non accessibile in questa macchina virtuale, il tentativo di leggere la classe chiamando il metodo di restituzione della classe pertinente nell'annotazione restituita genererà un oggetto TypeNotPresentException.
Analogamente, il tentativo di leggere un membro con valori di enumerazione genererà se EnumConstantNotPresentException la costante enumerazione nell'annotazione non è più presente nel tipo di enumerazione.
Se un tipo di annotazione T è (meta-)annotato con un'annotazione @Repeatable il cui elemento valore indica un tipo TC, ma TC non dichiara un value() metodo con un tipo restituito T[], viene generata un'eccezione di tipo java.lang.annotation.AnnotationFormatError .
Infine, il tentativo di leggere un membro la cui definizione si è evoluta incompatibly comporterà un oggetto o un java.lang.annotation.AnnotationTypeMismatchException oggetto java.lang.annotation.IncompleteAnnotationException.
Aggiunto nella versione 1.5.
per java.lang.reflect.AnnotatedElement.
Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.
Proprietà
| Nome | Descrizione |
|---|---|
| Handle |
Ottiene il valore JNI dell'oggetto Android sottostante. (Ereditato da IJavaObject) |
| JniIdentityHashCode |
Restituisce il valore di |
| JniManagedPeerState |
Stato del peer gestito. (Ereditato da IJavaPeerable) |
| JniPeerMembers |
Supporto per l'accesso ai membri e la chiamata. (Ereditato da IJavaPeerable) |
| PeerReference |
Restituisce un JniObjectReference oggetto dell'istanza dell'oggetto di cui è stato eseguito il wrapping Java. (Ereditato da IJavaPeerable) |
Metodi
| Nome | Descrizione |
|---|---|
| Disposed() |
Chiamato quando l'istanza è stata eliminata. (Ereditato da IJavaPeerable) |
| DisposeUnlessReferenced() |
Se non sono presenti riferimenti in sospeso a questa istanza, chiama |
| Finalized() |
Chiamato quando l'istanza è stata finalizzata. (Ereditato da IJavaPeerable) |
| GetAnnotation(Class) |
Restituisce l'annotazione di questo elemento per il tipo specificato se tale annotazione è <em>present</em>, else null. |
| GetAnnotations() |
Restituisce annotazioni che sono <em>present</em> su questo elemento. |
| GetAnnotationsByType(Class) |
Restituisce annotazioni <associate>/em< a> questo elemento. |
| GetDeclaredAnnotation(Class) |
Restituisce l'annotazione di questo elemento per il tipo specificato se tale annotazione è <>direttamente presente</em>, altrimenti null. |
| GetDeclaredAnnotations() |
Restituisce annotazioni che sono <presenti></em> direttamente su questo elemento. |
| GetDeclaredAnnotationsByType(Class) |
Restituisce le annotazioni di questo elemento per il tipo specificato se tali annotazioni sono <>direttamente presenti</em> o <em>indirettamente presenti</em>. |
| IsAnnotationPresent(Class) |
Restituisce true se un'annotazione per il tipo specificato è <em>present</em> su questo elemento, altrimenti false. |
| SetJniIdentityHashCode(Int32) |
Impostare il valore restituito da |
| SetJniManagedPeerState(JniManagedPeerStates) |
Rappresenta un elemento annotato del programma attualmente in esecuzione in questa macchina virtuale. (Ereditato da IJavaPeerable) |
| SetPeerReference(JniObjectReference) |
Impostare il valore restituito da |
| UnregisterFromRuntime() |
Annullare la registrazione di questa istanza in modo che il runtime non lo restituisca dalle chiamate future Java.Interop.JniRuntime+JniValueManager.PeekValue . (Ereditato da IJavaPeerable) |
Metodi di estensione
| Nome | Descrizione |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Ottiene il nome JNI del tipo dell'istanza |
| JavaAs<TResult>(IJavaPeerable) |
Provare a digitare |
| JavaCast<TResult>(IJavaObject) |
Esegue una conversione del tipo di tipo controllato dal runtime Android. |
| JavaCast<TResult>(IJavaObject) |
Rappresenta un elemento annotato del programma attualmente in esecuzione in questa macchina virtuale. |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Provare a digitare |