MethodHandles.Lookup Classe

Definizione

Spazio dei nomi:

Java.Lang.Invoke

Assembly:

Mono.Android.dll

Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso.

[Android.Runtime.Register("java/lang/invoke/MethodHandles$Lookup", ApiSince=26, DoNotGenerateAcw=true)]
public sealed class MethodHandles.Lookup : Java.Lang.Object

[<Android.Runtime.Register("java/lang/invoke/MethodHandles$Lookup", ApiSince=26, DoNotGenerateAcw=true)>]
type MethodHandles.Lookup = class
    inherit Object

Ereditarietà

Object

Object

MethodHandles.Lookup

Attributi

RegisterAttribute

Commenti

Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. Gli handle dei metodi non eseguono controlli di accesso quando vengono chiamati, ma invece quando vengono creati. È pertanto necessario applicare restrizioni di accesso al metodo quando viene creato un handle di metodo. La classe chiamante in base alla quale vengono applicate tali restrizioni è nota come classe di ricerca #lookupClass.

Una classe di ricerca che deve creare handle di metodo chiamerà #lookup MethodHandles.lookup per creare una factory per se stessa. Quando viene creato l'oggetto Lookup factory, l'identità della classe di ricerca viene determinata e archiviata in modo sicuro nell'oggetto Lookup . La classe di ricerca (o i relativi delegati) può quindi usare i metodi factory nell'oggetto per creare handle dei metodi per i membri controllati dall'accesso Lookup . Include tutti i metodi, i costruttori e i campi consentiti per la classe di ricerca, anche quelli privati.

<h1"lookups"Lookup Factory Methods</h1>> I metodi factory di un Lookup oggetto corrispondono a tutti i principali casi d'uso> per metodi, costruttori e campi. Ogni handle di metodo creato da un metodo factory è l'equivalente funzionale di un determinato <comportamento< em>bytecode/em>. I comportamenti bytecode sono descritti nella sezione 5.4.3.5 della specifica della macchina virtuale Java. Ecco un riepilogo della corrispondenza tra questi metodi factory e il comportamento gestito dal metodo risultante: <table border=1 cellpadding=5 summary="lookup method behaviors><"tr><th>"equiv>"lookup expression<<>>/th member</th bytecode comportamento/>><th bytecode comportamento><</th/tr td/td td/trd><><>java.lang.invoke.MethodHandles.Lookup#findGetter lookup.findGetter(C.class,"f",FT.class)<><>FT f;<><>(T) this.f;<><><<>>>static<<java.lang.invoke.MethodHandles.Lookup#findStaticGetter lookup.findStaticGetter(C.class,"f",FT.class)tr><td/td br<><><>FT f;><static><<>><><><java.lang.invoke.MethodHandles.Lookup#findStaticSetter lookup.findStaticSetter(C.class,"f",FT.class)<>java.lang.invoke.MethodHandles.Lookup#findSetter lookup.findSetter(C.class,"f",FT.class)<>>C.f = arg;<>><this.f = x;><FT f;FT f;(T) C.f;>><<<<<>>><<>/td td/tr td/tr td/td td/td td/tr td/tr td/td td br/td td/tr tr><><>>java.lang.invoke.MethodHandles.Lookup#findVirtual lookup.findVirtual(C.class,"m",MT)<><><<><>T m(A*);<>java.lang.invoke.MethodHandles.Lookup#findSpecial lookup.findSpecial(C.class,"m",MT,this.class)(T) this.m(arg*);><<><><>T m(A*);><><java.lang.invoke.MethodHandles.Lookup#findStatic lookup.findStatic(C.class,"m",MT)>>(T) C.m(arg*);><<>T m(A*);<><>>static<<<<(T) super.m(arg*);>>><<<td/td td/td td/td/tr td/td td br/td td td/tr tr><>>java.lang.invoke.MethodHandles.Lookup#findConstructor lookup.findConstructor(C.class,MT)<<td/<><>C(A*);td td/><td td>new C(arg*);</><td/tr><tdjava.lang.invoke.MethodHandles.Lookup#unreflectGetter lookup.unreflectGetter(aField)<>></<>td td>(static)?<br><FT f;/td td></td>><(FT) aField.get(thisOrNull);</tr>><<td/td><td><>java.lang.invoke.MethodHandles.Lookup#unreflectSetter lookup.unreflectSetter(aField)static()?<br><FT f;/td td></td>><aField.set(thisOrNull, arg);</tr>><<td/td><td><>java.lang.invoke.MethodHandles.Lookup#unreflect lookup.unreflect(aMethod)static()?<><br>T m(A*);</td td>(T) aMethod.invoke(thisOrNull, arg*);</td/<<>>tr<>td<>>>><C(A*);<<>>java.lang.invoke.MethodHandles.Lookup#unreflectConstructor lookup.unreflectConstructor(aConstructor)<<(C) aConstructor.newInstance(arg*);/td/tr><trjava.lang.invoke.MethodHandles.Lookup#unreflect lookup.unreflect(aMethod)<<>> td/<>>statictd td()?<br><T m(A*);/td td/td>><(T) aMethod.invoke(thisOrNull, arg*);<></tr></table>

In questo caso, il tipo C è la classe o l'interfaccia da cercare per un membro, documentata come parametro denominato refc nei metodi di ricerca. Il tipo di metodo è composto dal tipo MTT restituito e dalla sequenza di tipi A*di argomento . Il costruttore ha anche una sequenza di tipi A* di argomenti e viene considerato restituire l'oggetto appena creato di tipo C. Sia MT che il tipo di FT campo sono documentati come parametro denominato type. Il parametro this formale è l'oggetto self-reference di tipo C; se presente, è sempre l'argomento principale della chiamata dell'handle del metodo. Nel caso di alcuni protected membri, this potrebbe essere limitato al tipo alla classe di ricerca. Vedere di seguito. Il nome arg corrisponde a tutti gli altri argomenti di handle del metodo. Negli esempi di codice per l'API Reflection core il nome thisOrNull è un riferimento Null se il metodo o il campo a cui si accede è statico e this in caso contrario. I nomi aMethod, aFielde aConstructor si trovano per oggetti riflettenti corrispondenti ai membri specificati.

Nei casi in cui il membro specificato è di arity variabile (ad esempio, un metodo o un costruttore) l'handle del metodo restituito sarà anche della variabile MethodHandle#asVarargsCollector arity. In tutti gli altri casi, l'handle del metodo restituito sarà di arità fissa. <p style="font-size:smaller;"><em>Discussion:</em> L'equivalenza tra handle del metodo looked-up e membri della classe sottostanti e comportamenti di bytecode può suddividere in alcuni modi: <ul style="font-size:smaller;"><li>Se C non è accessibile simbolicamente dal caricatore della classe di ricerca, la ricerca può comunque avere esito positivo, anche quando non è presente alcuna espressione Java equivalente o costante bytecoded. <li>Analogamente, se T o MT non è accessibile simbolicamente dal caricatore della classe di ricerca, la ricerca può comunque avere esito positivo. Ad esempio, le ricerche MethodHandle.invokeExact e MethodHandle.invoke avranno sempre esito positivo, indipendentemente dal tipo richiesto. <li>Se è installato un responsabile della sicurezza, può impedire la ricerca in vari motivi (vedere di seguito). Al contrario, l'istruzione ldc su una CONSTANT_MethodHandle costante non è soggetta ai controlli di gestione della sicurezza. <li>Se il metodo looked-up ha un'arità molto grande, la creazione dell'handle del metodo potrebbe non riuscire, a causa del tipo di handle del metodo con troppi parametri. </ul>

<i controlli di accesso h1"Access check</h1>> vengono applicati nei metodi factory di Lookup, quando viene creato un handle di metodo.> Questa è una differenza fondamentale dall'API Reflection core, poiché java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke esegue il controllo di accesso su ogni chiamante, in ogni chiamata.

Tutti i controlli di accesso iniziano da un Lookup oggetto, che confronta la classe di ricerca registrata rispetto a tutte le richieste per creare handle di metodo. Un singolo Lookup oggetto può essere usato per creare un numero qualsiasi di handle di metodi di controllo di accesso, tutti controllati su una singola classe di ricerca.

Un Lookup oggetto può essere condiviso con altro codice attendibile, ad esempio un protocollo metaobject. Un oggetto condiviso Lookup delega la funzionalità per creare handle di metodo sui membri privati della classe di ricerca. Anche se il codice con privilegi usa l'oggetto, il Lookup controllo di accesso è limitato ai privilegi della classe di ricerca originale.

Una ricerca può non riuscire, perché la classe contenente non è accessibile alla classe di ricerca o perché il membro della classe desiderato non è mancante o perché il membro della classe desiderato non è accessibile alla classe di ricerca o perché l'oggetto di ricerca non è attendibile abbastanza attendibile per accedere al membro. In uno di questi casi verrà generato un ReflectiveOperationException oggetto dalla ricerca tentata. La classe esatta sarà una delle seguenti: ul>li NoSuchMethodException — se un metodo è richiesto ma non esiste <li>NoSuchFieldException — se un campo è richiesto ma non esiste <li>IllegalAccessException — se il membro esiste ma un controllo <di accesso non riesce>/ul<<>

In generale, le condizioni in cui un handle di metodo può essere cercato per un metodo M non sono più restrittive delle condizioni in cui la classe di ricerca potrebbe aver compilato, verificato e risolto una chiamata a M. Se la JVM genera eccezioni come NoSuchMethodError, la ricerca di un handle di metodo genererà un'eccezione selezionata corrispondente, ad esempio NoSuchMethodException. E l'effetto di richiamare l'handle del metodo risultante dalla ricerca è esattamente equivalente all'esecuzione della chiamata compilata, verificata e risolta a M. Lo stesso punto è vero di campi e costruttori. <p style="font-size:smaller;"><em>Discussion:</em> Access controlla solo i metodi denominati e riflessi, i costruttori e i campi. Altri metodi di gestione dei metodi, ad esempio MethodHandle#asType MethodHandle.asType, non richiedono controlli di accesso e vengono usati in modo indipendente da qualsiasi Lookup oggetto.

Se il membro desiderato è protected, si applicano le normali regole JVM, incluso il requisito che la classe di ricerca deve trovarsi nello stesso pacchetto del membro desiderato oppure deve ereditare tale membro. Vedere la specifica della macchina virtuale Java, le sezioni 4.9.2, 5.4.3.5 e 6.4. Inoltre, se il membro desiderato è un campo o un metodo non statico in un pacchetto diverso, l'handle del metodo risultante può essere applicato solo agli oggetti della classe di ricerca o a una delle relative sottoclassi. Questo requisito viene applicato restringendo il tipo del parametro iniziale this da C (che sarà necessariamente una superclasse della classe di ricerca) alla classe di ricerca stessa.

La JVM impone un requisito simile all'istruzione invokespecial , che l'argomento ricevitore deve corrispondere sia al metodo <risolto em>che</em> alla classe corrente. Anche in questo caso, questo requisito viene applicato restringendo il tipo del parametro iniziale all'handle del metodo risultante. Vedere la specifica della macchina virtuale Java, sezione 4.10.1.9.

La JVM rappresenta i costruttori e i blocchi inizializzatori statici come metodi interni con nomi speciali ("<init>" e "<clinit>"). La sintassi interna delle istruzioni di chiamata consente loro di fare riferimento a metodi interni come se fossero metodi normali, ma il verificatore di bytecode JVM li rifiuta. Una ricerca di tale metodo interno produrrà un NoSuchMethodExceptionoggetto .

In alcuni casi, l'accesso tra le classi annidate viene ottenuto dal compilatore Java creando un metodo wrapper per accedere a un metodo privato di un'altra classe nella stessa dichiarazione di primo livello. Ad esempio, una classe C.D annidata può accedere ai membri privati all'interno di altre classi correlate, Cad esempio , C.D.Eo C.B, ma il compilatore Java potrebbe dover generare metodi wrapper in tali classi correlate. In questi casi, un Lookup oggetto su C.E non sarebbe in grado di tali membri privati. Una soluzione alternativa per questa limitazione è il Lookup#in Lookup.in metodo, che può trasformare una ricerca in C.E una delle altre classi, senza privilegi speciali.

Gli accessi consentiti a un determinato oggetto di ricerca possono essere limitati, in base al relativo set di #lookupModes lookupModes, a un subset di membri normalmente accessibili alla classe di ricerca. Ad esempio, il #publicLookup publicLookup metodo produce un oggetto di ricerca che è consentito solo per accedere ai membri pubblici nelle classi pubbliche. Il metodo #lookup lookup sensibile del chiamante produce un oggetto di ricerca con funzionalità complete relative alla relativa classe chiamante, per emulare tutti i comportamenti bytecode supportati. Inoltre, il Lookup#in Lookup.in metodo può produrre un oggetto di ricerca con meno modalità di accesso rispetto all'oggetto di ricerca originale.

<p style="font-size:smaller;"> privacc"em>Discussione dell'accesso>< privato:</em> Si dice che una ricerca ha <>accesso< privato/em> se le relative modalità di ricerca #lookupModes includono la possibilità di accedere ai private membri. Come documentato nei metodi pertinenti altrove, solo le ricerche con accesso privato dispongono delle funzionalità seguenti: <ul style="font-size:smaller;"><li access private fields, metodi e costruttori della classe di ricerca li>create method handle che richiamano metodi sensibili del chiamante, ad esempio<Class.forName li>create method handle che Lookup#findSpecial emulate invokespecial le istruzioni <>li evitare i controlli di accesso ai pacchetti per le classi accessibili alla classe><<> di ricerca li create Lookup#in delegated lookup objects che hanno accesso privato ad altre classi all'interno dello stesso membro <del pacchetto /ul><p style="font-size: più piccolo;"> Ognuna di queste autorizzazioni è una conseguenza del fatto che un oggetto di ricerca con accesso privato può essere tracciato in modo sicuro in una classe di origine, i cui comportamenti bytecode e le autorizzazioni di accesso al linguaggio Java possono essere determinati e emulati in modo affidabile tramite handle di metodo.

<h1"secmgr">Interazioni di Gestione< sicurezza/h1>> Anche se le istruzioni di bytecode possono fare riferimento solo alle classi in un caricatore di classi correlate, questa API può cercare metodi in qualsiasi classe, purché sia disponibile un riferimento al relativo Class oggetto. Tali riferimenti tra caricatori sono anche possibili con l'API Reflection core e sono impossibili da eseguire per bytecode istruzioni, ad esempio invokestatic o getfield. È disponibile un'API di gestione sicurezza java.lang.SecurityManager per consentire alle applicazioni di controllare tali riferimenti tra caricatori. Questi controlli si applicano sia all'API che all'API MethodHandles.Lookup Reflection Core (come trovato in java.lang.Class Class).

Se è presente un responsabile della sicurezza, le ricerche dei membri sono soggette a controlli aggiuntivi. Da una a tre chiamate vengono effettuate al responsabile della sicurezza. Una di queste chiamate può rifiutare l'accesso generando un java.lang.SecurityException SecurityExceptionoggetto . Definire smgr come gestione sicurezza, come classe di ricerca dell'oggetto di ricerca corrente, lookcrefc come classe contenente in cui viene cercato il membro e defc come classe in cui è stato definito il membro. Il valore lookc è definito come <em>not present</em> se l'oggetto di ricerca corrente non ha accesso privato. Le chiamate vengono effettuate in base alle regole seguenti: <ul><li><b Passaggio 1:</b>> Se lookc non è presente o se il caricatore della classe non è uguale a o un predecessore del caricatore di classe di refc, viene SecurityManager#checkPackageAccess smgr.checkPackageAccess(refcPkg) chiamato, dove refcPkg è il pacchetto di refc. <li><b Passaggio 2:</b>> Se il membro recuperato non è pubblico e lookc non è presente, viene SecurityManager#checkPermission smgr.checkPermission chiamato conRuntimePermission("accessDeclaredMembers"). <li><b Passaggio 3:</b>> Se il membro recuperato non è pubblico e se non è presente e se lookcdefc e refc sono diversi, viene SecurityManager#checkPackageAccess smgr.checkPackageAccess(defcPkg) chiamato, dove defcPkg è il pacchetto di defc. <I controlli di sicurezza /ul> vengono eseguiti dopo il passaggio di altri controlli di accesso. Di conseguenza, le regole precedenti presuppongono un membro pubblico oppure che viene eseguito l'accesso da una classe di ricerca con diritti di accesso al membro.

<h1"callens">Metodi sensibili< chiamante/h1>> Un numero ridotto di metodi Java ha una proprietà speciale denominata riservatezza del chiamante. Un <metodo em>caller-sensitive</em> può comportarsi in modo diverso a seconda dell'identità del chiamante immediato.

Se viene richiesto un handle di metodo per un metodo sensibile al chiamante, le regole generali per i comportamenti bytecode si applicano, ma tengono conto della classe di ricerca in modo speciale. L'handle del metodo risultante si comporta come se fosse chiamato da un'istruzione contenuta nella classe di ricerca, in modo che il metodo sensibile al chiamante rilevi la classe di ricerca. Al contrario, il richiamatore dell'handle del metodo viene ignorato. Pertanto, nel caso di metodi sensibili al chiamante, le diverse classi di ricerca possono dare origine a handle di metodi diversi.

Nei casi in cui l'oggetto di ricerca è #publicLookup publicLookup()o un altro oggetto di ricerca senza accesso privato, la classe di ricerca viene ignorata. In questi casi, non è possibile creare alcun handle di metodo sensibile al chiamante, l'accesso è vietato e la ricerca ha esito negativo con un IllegalAccessExceptionoggetto . <p style="font-size:smaller;"><em>Discussion:</em> Ad esempio, il metodo java.lang.Class#forName(String) Class.forName(x) sensibile al chiamante può restituire classi variabili o generare eccezioni diverse, a seconda del caricatore di classe della classe che lo chiama. Una ricerca pubblica di Class.forName avrà esito negativo, perché non esiste alcun modo ragionevole per determinare il comportamento bytecode. <p style="font-size:smaller;"> Se un metodo di cache dell'applicazione gestisce i metodi per la condivisione ampia, deve usarli publicLookup() per crearli. Se è presente una ricerca di Class.forName, avrà esito negativo e l'applicazione deve intraprendere un'azione appropriata in questo caso. Potrebbe essere che una ricerca successiva, forse durante la chiamata di un metodo bootstrap, può incorporare l'identità specifica del chiamante, rendendo il metodo accessibile. <p style="font-size:smaller;"> La funzione è sensibile al chiamante in modo che sia possibile avere una base MethodHandles.lookup sicura per le ricerche. Quasi tutti gli altri metodi nell'API JSR 292 si basano su oggetti di ricerca per controllare le richieste di accesso.

Documentazione Java per java.lang.invoke.MethodHandles.Lookup.

Le parti di questa pagina sono modifiche in base al lavoro creato e condiviso dal Android Open Source e usato in base ai termini descritti nella .

Campi

Package	Obsoleti. Maschera a bit singolo che rappresenta package l'accesso (accesso predefinito), che può contribuire al risultato di #lookupModes lookupModes.
Private	Obsoleti. Maschera a bit singolo che rappresenta private l'accesso, che può contribuire al risultato di #lookupModes lookupModes.
Protected	Obsoleti. Maschera a bit singolo che rappresenta protected l'accesso, che può contribuire al risultato di #lookupModes lookupModes.
Public	Obsoleti. Maschera a bit singolo che rappresenta public l'accesso, che può contribuire al risultato di #lookupModes lookupModes.

Proprietà

Class	Restituisce la classe di runtime di questo Objectoggetto . (Ereditato da Object)
Handle	Handle all'istanza di Android sottostante. (Ereditato da Object)
JniIdentityHashCode	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
JniPeerMembers	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso.
PeerReference	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object)
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object)

Metodi

Bind(Object, String, MethodType)	Produce un handle di metodo con associazione anticipata per un metodo non statico.
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Dispose()	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
Dispose(Boolean)	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
FindConstructor(Class, MethodType)	Produce un handle di metodo che crea un oggetto e lo inizializza usando il costruttore del tipo specificato.
FindGetter(Class, String, Class)	Produce un handle di metodo che consente l'accesso in lettura a un campo non statico.
FindSetter(Class, String, Class)	Produce un handle di metodo che consente l'accesso in scrittura a un campo non statico.
FindSpecial(Class, String, MethodType, Class)	Produce un handle di metodo con associazione anticipata per un metodo virtuale.
FindStatic(Class, String, MethodType)	Produce un handle di metodo per un metodo statico.
FindStaticGetter(Class, String, Class)	Produce un handle di metodo che consente l'accesso in lettura a un campo statico.
FindStaticSetter(Class, String, Class)	Produce un handle di metodo che consente l'accesso in scrittura a un campo statico.
FindStaticVarHandle(Class, String, Class)	Produce un oggetto VarHandle che concede l'accesso a un campo name statico di tipo type dichiarato in una classe di tipo decl.
FindVarHandle(Class, String, Class)	Produce un oggetto VarHandle che concede l'accesso a un campo name non statico di tipo type dichiarato in una classe di tipo recv.
FindVirtual(Class, String, MethodType)	Produce un handle di metodo per un metodo virtuale.
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
In(Class)	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso.
JavaFinalize()	Chiamato dal Garbage Collector in un oggetto quando Garbage Collection determina che non sono presenti più riferimenti all'oggetto. (Ereditato da Object)
LookupClass()	Indica la classe che esegue la ricerca.
LookupModes()	Indica quali classi di protezione di accesso di membri questo oggetto di ricerca può produrre.
Notify()	Riattiva un singolo thread in attesa del monitoraggio dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitoraggio dell'oggetto. (Ereditato da Object)
RevealDirect(MethodHandle)	Crea un handle di metodo diretto creato da questo oggetto di ricerca o uno simile.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
ToArray<T>()	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
ToString()	Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object)
Unreflect(Method)	Crea un handle di metodo diretto su m, se la classe di ricerca ha l'autorizzazione.
UnreflectConstructor(Constructor)	Produce un handle di metodo per un costruttore riflesso.
UnreflectGetter(Field)	Produce un handle di metodo che consente l'accesso in lettura a un campo riflesso.
UnreflectSetter(Field)	Produce un handle di metodo che consente l'accesso in scrittura a un campo riflesso.
UnreflectSpecial(Method, Class)	Produce un handle di metodo per un metodo riflesso.
UnreflectVarHandle(Field)	Produce un oggetto VarHandle che concede l'accesso a un campo f riflesso di tipo T dichiarato in una classe di tipo R.
UnregisterFromRuntime()	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
Wait()	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere eseguendo>una notifica</em o <em interrotto</>em>>.< (Ereditato da Object)
Wait(Int64)	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere <>eseguendo una notifica</em o <em interrotto/>>em>o fino a quando non è trascorsa< una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere <>eseguendo una notifica</em o <em interrotto/>>em>o fino a quando non è trascorsa< una determinata quantità di tempo reale. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
IJavaPeerable.Finalized()	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione dei tipi controllati dal runtime Android.
JavaCast<TResult>(IJavaObject)	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso.
GetJniTypeName(IJavaPeerable)	Un <oggetto< di ricerca em/em>> è una factory per la creazione di handle dei metodi, quando la creazione richiede il controllo di accesso.