ConcurrentHashMap Classe

Definizione

Spazio dei nomi:

Java.Util.Concurrent

Assembly:

Mono.Android.dll

Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti.

[Android.Runtime.Register("java/util/concurrent/ConcurrentHashMap", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "K", "V" })]
public class ConcurrentHashMap : Java.Util.AbstractMap, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable, Java.Util.Concurrent.IConcurrentMap

[<Android.Runtime.Register("java/util/concurrent/ConcurrentHashMap", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "K", "V" })>]
type ConcurrentHashMap = class
    inherit AbstractMap
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface IConcurrentMap
    interface IMap

Ereditarietà

Object

Object

AbstractMap

ConcurrentHashMap

Attributi

RegisterAttribute JavaTypeParametersAttribute

Implementazioni

IJavaObject IJavaPeerable ISerializable IConcurrentMap IMap IDisposable

Commenti

Tabella hash che supporta la concorrenza completa dei recupero e della concorrenza prevista elevata per gli aggiornamenti. Questa classe rispetta la stessa specifica funzionale di java.util.Hashtablee include versioni di metodi corrispondenti a ogni metodo di Hashtable. Tuttavia, anche se tutte le operazioni sono thread-safe, le operazioni <><di recupero non e em comportano il blocco e non è<<> disponibile alcun supporto em not/em>> per bloccare l'intera tabella in modo da impedire l'accesso a tutti. Questa classe è completamente interoperabile con Hashtable nei programmi che si basano sulla sicurezza del thread, ma non sui dettagli di sincronizzazione.

Le operazioni di recupero (incluso get) in genere non bloccano, quindi possono sovrapporsi alle operazioni di aggiornamento (incluse put e remove). I recupero riflettono i risultati delle operazioni di aggiornamento completate</em> più recenti <>che mantengono l'inizio. (Più formalmente, un'operazione di aggiornamento per una determinata chiave contiene una <relazione em-before</em>> con qualsiasi recupero (non null) per tale chiave che segnala il valore aggiornato. Per operazioni di aggregazione come putAll e clear, i recupero simultanei possono riflettere l'inserimento o la rimozione di solo alcune voci. Analogamente, iteratori, spliterator e enumeratori restituiscono elementi che riflettono lo stato della tabella hash a un certo punto o dopo la creazione dell'iteratore/enumerazione. <>><Non generano .java.util.ConcurrentModificationException ConcurrentModificationException Tuttavia, gli iteratori sono progettati per essere usati da un solo thread alla volta. Tenere presente che i risultati dei metodi di stato aggregati, tra sizecui , isEmptye containsValue sono in genere utili solo quando una mappa non esegue aggiornamenti simultanei in altri thread. In caso contrario, i risultati di questi metodi riflettono gli stati temporanei che possono essere adeguati per il monitoraggio o la stima, ma non per il controllo del programma.

La tabella viene espansa dinamicamente quando sono presenti troppe collisioni (ad esempio, chiavi con codici hash distinti ma rientrano nello stesso slot delle dimensioni della tabella), con l'effetto medio previsto di mantenere circa due bin per mapping (corrispondente a una soglia del fattore di carico di 0,75 per il ridimensionamento). Potrebbe esserci una varianza intorno a questa media man mano che vengono aggiunti e rimossi i mapping, ma in generale, questo mantiene un compromesso di tempo/spazio comunemente accettato per le tabelle hash. Tuttavia, il ridimensionamento di questo o qualsiasi altro tipo di tabella hash può essere un'operazione relativamente lenta. Quando possibile, è consigliabile fornire una stima delle dimensioni come argomento del costruttore facoltativo initialCapacity . Un argomento costruttore facoltativo aggiuntivo loadFactor consente di personalizzare ulteriormente la capacità iniziale della tabella specificando la densità di tabella da usare per calcolare la quantità di spazio da allocare per il numero specificato di elementi. Inoltre, per la compatibilità con le versioni precedenti di questa classe, i costruttori possono facoltativamente specificare un hint concurrencyLevel aggiuntivo per il ridimensionamento interno. Si noti che l'uso di molte chiavi con esattamente lo stesso hashCode() è un modo sicuro per rallentare le prestazioni di qualsiasi tabella hash. Per migliorare l'impatto, quando le chiavi sono Comparable, questa classe può usare l'ordine di confronto tra le chiavi per interrompere i legami.

È Set possibile creare una proiezione di un oggetto ConcurrentHashMap (usando #newKeySet() o #newKeySet(int)) o visualizzare (usando #keySet(Object) quando sono di interesse solo le chiavi e i valori mappati sono (ad esempio temporanei) non usati o accettano tutti lo stesso valore di mapping.

Un oggetto ConcurrentHashMap può essere usato come mappa di frequenza scalabile (una forma di istogramma o multiset) usando java.util.concurrent.atomic.LongAdder valori e inizializzazione tramite #computeIfAbsent computeIfAbsent. Ad esempio, per aggiungere un conteggio a un ConcurrentHashMap<String,LongAdder> freqsoggetto , è possibile usare freqs.computeIfAbsent(key, k -> new LongAdder()).increment();

Questa classe e le relative viste e iteratori implementano tutti i <>metodi facoltativi</em> delle Map interfacce e Iterator .

Analogamente HashtableHashMapa , questa classe non <<consente>di>null usare come chiave o valore.

ConcurrentHashMaps supporta un set di operazioni bulk sequenziali e parallele che, a differenza della maggior Stream parte dei metodi, sono progettate per essere sicure e spesso applicate anche con mappe che vengono aggiornate simultaneamente da altri thread, ad esempio quando si calcola un riepilogo snapshot dei valori in un registro condiviso. Esistono tre tipi di operazione, ognuno con quattro forme, accettando funzioni con chiavi, valori, voci e (chiave, valore) coppie come argomenti e/o valori restituiti. Poiché gli elementi di un oggetto ConcurrentHashMap non vengono ordinati in alcun modo specifico e possono essere elaborati in ordini diversi in esecuzioni parallele diverse, la correttezza delle funzioni fornite non deve dipendere da alcun ordinamento o da altri oggetti o valori che possono cambiare temporaneamente durante il calcolo; e ad eccezione delle azioni forEach, dovrebbero essere idealmente senza effetto collaterale. Le operazioni bulk sugli Map.Entry oggetti non supportano il metodo setValue.

<ul><li>forEach: esegue una determinata azione su ogni elemento. Un modulo variante applica una determinata trasformazione per ogni elemento prima di eseguire l'azione.

<li>search: restituisce il primo risultato non Null disponibile dell'applicazione di una determinata funzione per ogni elemento; ignorando un'ulteriore ricerca quando viene trovato un risultato.

<li>reduce: accumula ogni elemento. La funzione di riduzione fornita non può basarsi sull'ordinamento (più formalmente, deve essere sia associativo che commutativo). Sono disponibili cinque varianti:

<ul>

<li>Plain riduzioni. Non esiste una forma di questo metodo per gli argomenti della funzione (chiave, valore) perché non esiste alcun tipo restituito corrispondente.

<li>Riduzioni mappate che accumulano i risultati di una determinata funzione applicata a ogni elemento.

<li>Riduzioni ai valori scalari double, longs e ints, utilizzando un determinato valore di base.

</ul></ul>

Queste operazioni bulk accettano un parallelismThreshold argomento. I metodi proseguono in sequenza se si stima che le dimensioni correnti della mappa siano inferiori alla soglia specificata. L'uso di Long.MAX_VALUE un valore elimina tutto il parallelismo. L'uso di un valore di 1 restituisce un parallelismo massimo partizionando in sottoattività sufficienti per utilizzare completamente l'oggetto ForkJoinPool#commonPool() usato per tutti i calcoli paralleli. In genere, si sceglie inizialmente uno di questi valori estremi e quindi si misurano le prestazioni dell'uso tra valori che comproseguono il sovraccarico rispetto alla velocità effettiva.

Le proprietà di concorrenza delle operazioni bulk seguono quelle di ConcurrentHashMap: tutti i risultati non Null restituiti da get(key) e i metodi di accesso correlati presentano una relazione che precede l'inserimento o l'aggiornamento associato. Il risultato di qualsiasi operazione bulk riflette la composizione di queste relazioni per elemento (ma non è necessariamente atomico rispetto alla mappa nel suo complesso, a meno che non sia in qualche modo noto come quiescente). Viceversa, poiché le chiavi e i valori nella mappa non sono mai Null, Null funge da indicatore atomico affidabile della mancanza corrente di qualsiasi risultato. Per mantenere questa proprietà, Null funge da base implicita per tutte le operazioni di riduzione non scalari. Per le versioni double, long e int, la base deve essere quella che, se combinata con qualsiasi altro valore, restituisce tale altro valore (più formalmente, deve essere l'elemento Identity per la riduzione). Le riduzioni più comuni hanno queste proprietà; Ad esempio, il calcolo di una somma con base 0 o minima con base MAX_VALUE.

Le funzioni di ricerca e trasformazione fornite come argomenti devono restituire in modo analogo Null per indicare la mancanza di alcun risultato (nel qual caso non viene usato). Nel caso di riduzioni mappate, ciò consente anche alle trasformazioni di fungere da filtri, restituendo null (o, nel caso delle specializzazioni primitive, la base di identità) se l'elemento non deve essere combinato. È possibile creare trasformazioni composte e filtri componendoli manualmente in questa regola "Null significa che non c'è nulla adesso" prima di usarli nelle operazioni di ricerca o riduzione.

I metodi che accettano e/o restituiscono argomenti Entry mantengono le associazioni chiave-valore. Possono essere utili, ad esempio, quando si trova la chiave per il valore più elevato. Si noti che è possibile specificare gli argomenti "plain" Entry usando new AbstractMap.SimpleEntry(k,v).

Le operazioni bulk possono essere completate bruscamente, generando un'eccezione rilevata nell'applicazione di una funzione fornita. Tenere presente che quando si gestiscono tali eccezioni che altre funzioni in esecuzione simultanea potrebbero anche avere generato eccezioni o se non si fosse verificata la prima eccezione.

Le velocità per le forme parallele rispetto alle forme sequenziali sono comuni, ma non sono garantite. Le operazioni parallele che coinvolgono brevi funzioni su mappe di piccole dimensioni possono essere eseguite più lentamente rispetto alle forme sequenziali se il lavoro sottostante per parallelizzare il calcolo è più costoso del calcolo stesso. Analogamente, la parallelizzazione potrebbe non portare a un parallelismo molto effettivo se tutti i processori sono impegnati a eseguire attività non correlate.

Tutti gli argomenti di tutti i metodi dell'attività devono essere diversi da Null.

Questa classe è un membro di Java Collections Framework.

Aggiunto nella versione 1.5.

Documentazione java per java.util.concurrent.ConcurrentHashMap.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal Android e usato in base ai termini descritti in 2.5 Attribution License Creative Commons 2.5 Attribution License.

Costruttori

ConcurrentHashMap()	Crea una nuova mappa vuota con le dimensioni predefinite della tabella (16).
ConcurrentHashMap(IDictionary)	Crea una nuova mappa con gli stessi mapping della mappa specificata.
ConcurrentHashMap(Int32)	Crea una nuova mappa vuota con dimensioni iniziali della tabella che ospitano il numero specificato di elementi senza la necessità di ridimensionare dinamicamente.
ConcurrentHashMap(Int32, Single)	Crea una nuova mappa vuota con una dimensione iniziale della tabella in base al numero specificato di elementi () e alla densità iniziale della tabella (initialCapacityloadFactor).
ConcurrentHashMap(Int32, Single, Int32)	Crea una nuova mappa vuota con una dimensione iniziale della tabella in base al numero specificato di elementi (), la densità iniziale della tabella (initialCapacity) e il numero di thread di aggiornamento simultaneo (loadFactorconcurrencyLevel).
ConcurrentHashMap(IntPtr, JniHandleOwnership)	Costruttore usato durante la creazione di rappresentazioni gestite di oggetti JNI; chiamato dal runtime.

Proprietà

Class	Restituisce la classe di runtime di questo Objectoggetto . (Ereditato da Object)
Handle	Handle all'istanza di Android sottostante. (Ereditato da Object)
IsEmpty	Da aggiungere (Ereditato da AbstractMap)
JniIdentityHashCode	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
JniPeerMembers	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti.
PeerReference	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.

Metodi

Clear()	Da aggiungere (Ereditato da AbstractMap)
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Compute(Object, IBiFunction)	Tenta di calcolare un mapping per la chiave specificata e il relativo valore mappato corrente (o null se non è presente alcun mapping corrente).
ComputeIfAbsent(Object, IFunction)	Se la chiave specificata non è già associata a un valore, tenta di calcolare il relativo valore usando la funzione di mapping specificata e immetterla in questa mappa a meno nullche .
ComputeIfPresent(Object, IBiFunction)	Se il valore per la chiave specificata è presente, tenta di calcolare un nuovo mapping dato la chiave e il relativo valore mappato corrente.
Contains(Object)	Verifica se alcune chiavi vengono mappate al valore specificato in questa tabella.
ContainsKey(Object)	Da aggiungere (Ereditato da AbstractMap)
ContainsValue(Object)	Da aggiungere (Ereditato da AbstractMap)
Dispose()	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
Dispose(Boolean)	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
Elements()	Restituisce un'enumerazione dei valori in questa tabella.
EntrySet()	Restituisce una Set visualizzazione dei mapping contenuti in questa mappa.
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
ForEach(IBiConsumer)	Esegue l'azione specificata per ogni (chiave, valore).
ForEach(Int64, IBiConsumer)	Esegue l'azione specificata per ogni (chiave, valore).
ForEach(Int64, IBiFunction, IConsumer)	Esegue l'azione specificata per ogni trasformazione non Null di ogni (chiave, valore).
ForEachEntry(Int64, IConsumer)	Esegue l'azione specificata per ogni voce.
ForEachEntry(Int64, IFunction, IConsumer)	Esegue l'azione specificata per ogni trasformazione non Null di ogni voce.
ForEachKey(Int64, IConsumer)	Esegue l'azione specificata per ogni chiave.
ForEachKey(Int64, IFunction, IConsumer)	Esegue l'azione specificata per ogni trasformazione non Null di ogni chiave.
ForEachValue(Int64, IConsumer)	Esegue l'azione specificata per ogni valore.
ForEachValue(Int64, IFunction, IConsumer)	Esegue l'azione specificata per ogni trasformazione non Null di ogni valore.
Get(Object)	Da aggiungere (Ereditato da AbstractMap)
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
GetOrDefault(Object, Object)	Restituisce il valore a cui viene eseguito il mapping della chiave specificata oppure il valore predefinito specificato se questa mappa non contiene alcun mapping per la chiave.
JavaFinalize()	Chiamato dal Garbage Collector in un oggetto quando Garbage Collection determina che non sono presenti più riferimenti all'oggetto. (Ereditato da Object)
Keys()	Restituisce un'enumerazione delle chiavi in questa tabella.
KeySet()	Da aggiungere (Ereditato da AbstractMap)
MappingCount()	Restituisce il numero di mapping.
Merge(Object, Object, IBiFunction)	Se la chiave specificata non è già associata a un valore (non null), lo associa al valore specificato.
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)
Put(Object, Object)	Da aggiungere (Ereditato da AbstractMap)
PutAll(IDictionary)	Da aggiungere (Ereditato da AbstractMap)
PutIfAbsent(Object, Object)	Da aggiungere
Reduce(Int64, IBiFunction, IBiFunction)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le coppie (chiave, valore) usando il reducer specificato per combinare i valori o Null se nessuno.
ReduceEntries(Int64, IBiFunction)	Restituisce il risultato dell'accumulazione di tutte le voci usando il reducer specificato per combinare valori o Null se nessuno.
ReduceEntries(Int64, IFunction, IBiFunction)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le voci usando il reducer specificato per combinare i valori o null se nessuno.
ReduceEntriesToDouble(Int64, IToDoubleFunction, Double, IDoubleBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le voci usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceEntriesToInt(Int64, IToIntFunction, Int32, IIntBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le voci usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceEntriesToLong(Int64, IToLongFunction, Int64, ILongBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le voci usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceKeys(Int64, IBiFunction)	Restituisce il risultato dell'accumulazione di tutte le chiavi usando il reducer specificato per combinare i valori o null se nessuno.
ReduceKeys(Int64, IFunction, IBiFunction)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le chiavi usando il reducer specificato per combinare i valori o null se nessuno.
ReduceKeysToDouble(Int64, IToDoubleFunction, Double, IDoubleBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le chiavi usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceKeysToInt(Int64, IToIntFunction, Int32, IIntBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le chiavi usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceKeysToLong(Int64, IToLongFunction, Int64, ILongBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le chiavi usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceToDouble(Int64, IToDoubleBiFunction, Double, IDoubleBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le coppie (chiave, valore) usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceToInt(Int64, IToIntBiFunction, Int32, IIntBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le coppie (chiave, valore) usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceToLong(Int64, IToLongBiFunction, Int64, ILongBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutte le coppie (chiave, valore) usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceValues(Int64, IBiFunction)	Restituisce il risultato dell'accumulazione di tutti i valori usando il reducer specificato per combinare i valori o null se nessuno.
ReduceValues(Int64, IFunction, IBiFunction)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutti i valori usando il reducer specificato per combinare i valori o null se nessuno.
ReduceValuesToDouble(Int64, IToDoubleFunction, Double, IDoubleBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutti i valori usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceValuesToInt(Int64, IToIntFunction, Int32, IIntBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutti i valori usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
ReduceValuesToLong(Int64, IToLongFunction, Int64, ILongBinaryOperator)	Restituisce il risultato dell'accumulazione della trasformazione specificata di tutti i valori usando il reducer specificato per combinare i valori e la base specificata come valore di identità.
Remove(Object)	Da aggiungere (Ereditato da AbstractMap)
Remove(Object, Object)	Da aggiungere
Replace(Object, Object)	Da aggiungere
Replace(Object, Object, Object)	Da aggiungere
ReplaceAll(IBiFunction)	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti.
Search(Int64, IBiFunction)	Restituisce un risultato non Null dall'applicazione della funzione di ricerca specificata in ogni (chiave, valore) o Null se non è presente alcuno.
SearchEntries(Int64, IFunction)	Restituisce un risultato non Null dall'applicazione della funzione di ricerca specificata in ogni voce o null se non è presente alcuno.
SearchKeys(Int64, IFunction)	Restituisce un risultato diverso da Null dall'applicazione della funzione di ricerca specificata in ogni chiave o null se nessuno.
SearchValues(Int64, IFunction)	Restituisce un risultato non null dall'applicazione della funzione di ricerca specificata in ogni valore o null se non è presente alcun valore.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
Size()	Da aggiungere (Ereditato da AbstractMap)
ToArray<T>()	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
ToString()	Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
Values()	Da aggiungere (Ereditato da AbstractMap)
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()	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
IJavaPeerable.Finalized()	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione dei tipi controllati dal runtime Android.
JavaCast<TResult>(IJavaObject)	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti.
GetJniTypeName(IJavaPeerable)	Tabella hash che supporta la concorrenza completa di recupero e concorrenza elevata prevista per gli aggiornamenti.