VarHandle Classe

Référence

Définition

Espace de noms:: Java.Lang.Invoke

Assembly:: Mono.Android.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

[Android.Runtime.Register("java/lang/invoke/VarHandle", ApiSince=33, DoNotGenerateAcw=true)]
public abstract class VarHandle : Java.Lang.Object

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

Héritage: Object

Object
VarHandle

Attributs: RegisterAttribute

Remarques

Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. L’accès à ces variables est pris en charge sous différents <modes< d’accès em>>, notamment l’accès en lecture/écriture brut, l’accès en lecture/écriture volatile et la comparaison et l’ensemble.

VarHandles est immuable et n’a pas d’état visible. VarHandles ne peut pas être sous-classé par l’utilisateur.

Un VarHandle a : <ul><li>a #varType variable type T, le type de chaque variable référencée par ce VarHandle ; et <li>une liste de #coordinateTypes coordinate typesCT1, CT2, ..., CTn, les types d’expressions <<de coordonnées em>> qui localisent conjointement une variable référencée par ce VarHandle. <Les types de variables et de coordonnées /ul> peuvent être primitifs ou références, et sont représentés par Class des objets. La liste des types de coordonnées peut être vide.

Les méthodes de fabrique qui produisent ou java.lang.invoke.MethodHandles.Lookup lookup varHandle documentent le type de variable pris en charge et la liste des types de coordonnées.

Chaque mode d’accès est associé à une <méthode</em en mode d’accès em>>, une méthode polymorphe de signature nommée pour le mode d’accès. Lorsqu’une méthode de mode d’accès est appelée sur une instance VarHandle, les arguments initiaux à l’appel sont des expressions de coordonnées qui indiquent précisément l’objet auquel la variable doit être accessible. Les arguments de fin à l’appel représentent des valeurs d’importance pour le mode d’accès. Par exemple, les différents modes d’accès compare-and-set ou compare-and-exchange nécessitent deux arguments de fin pour la valeur attendue de la variable et la nouvelle valeur.

L’arité et les types d’arguments à l’appel d’une méthode de mode d’accès ne sont pas vérifiés statiquement. Au lieu de cela, chaque méthode de mode d’accès spécifie une #accessModeType(AccessMode) access mode type, représentée en tant qu’instance de MethodType, qui sert de type de signature de méthode par rapport à laquelle les arguments sont vérifiés dynamiquement. Un type de mode d’accès donne des types de paramètres formels en termes de types de coordonnées d’une instance VarHandle et les types pour les valeurs d’importance pour le mode d’accès. Un type de mode d’accès donne également un type de retour, souvent en termes de type variable d’une instance VarHandle. Lorsqu’une méthode de mode d’accès est appelée sur une instance VarHandle, le descripteur de type symbolique sur le site d’appel, les types d’arguments d’exécution à l’appel et le type d’heure d’exécution de la valeur de retour doivent correspondre aux types donnés dans le type de mode d’accès. Une exception d’exécution est levée si la correspondance échoue.

Par exemple, la méthode #compareAndSet du mode d’accès spécifie que si son récepteur est une instance VarHandle avec des types CT1, ..., CTn de coordonnées et un type Tde variable, son type de mode d’accès est (CT1 c1, ..., CTn cn, T expectedValue, T newValue)boolean. Supposons qu’une instance VarHandle puisse accéder aux éléments de tableau et que ses types de coordonnées sont String[] et int pendant que son type de variable est String. Le type de mode d’accès pour compareAndSet cette instance VarHandle serait (String[] c1, int c2, String expectedValue, String newValue)boolean. Une telle instance VarHandle peut être produite par les éléments de MethodHandles#arrayElementVarHandle(Class) array factory method tableau et accéder comme suit :

{@code
            String[] sa = ...
            VarHandle avh = MethodHandles.arrayElementVarHandle(String[].class);
            boolean r = avh.compareAndSet(sa, 10, "expected", "new");
            }

Les modes d’accès contrôlent l’atomicité et les propriétés de cohérence. <Les accès em>Plain/em> Read (get) et write (set) sont garantis comme atomiques au niveau du bit uniquement pour les références et pour les valeurs primitives d’au plus 32 bits, et n’imposent aucune contrainte de classement observable par rapport aux threads autres que le thread en cours< d’exécution. <les opérations em>Opaque</em> sont atomiques au niveau du bit et sont ordonnées de manière cohérente en ce qui concerne les accès à la même variable. En plus d’obéir aux propriétés opaques, <les>lectures en mode Em Acquire</em> et leurs accès suivants sont classés après les <écritures en mode em>Release</em> correspondantes et leurs accès précédents. En plus d’obéir aux propriétés Acquire et Release, toutes les <opérations em>Volatile</em> sont totalement ordonnées par rapport aux autres.

Les modes d’accès sont regroupés dans les catégories suivantes : <les modes d’accès en lecture ul><li>qui obtiennent la valeur d’une variable sous les effets de classement de mémoire spécifiés. L’ensemble des méthodes de mode d’accès correspondantes appartenant à ce groupe se compose des méthodes #get get, #getVolatile getVolatile, #getAcquire getAcquire, #getOpaque getOpaque. <modes d’accès en écriture li>qui définissent la valeur d’une variable sous les effets de classement de mémoire spécifiés. L’ensemble des méthodes de mode d’accès correspondantes appartenant à ce groupe se compose des méthodes #set set, #setVolatile setVolatile, #setRelease setRelease, #setOpaque setOpaque. <modes d’accès à la mise à jour atomique li>qui, par exemple, comparent et définissent de manière atomique la valeur d’une variable sous les effets de classement de mémoire spécifiés. L’ensemble des méthodes de mode d’accès correspondantes appartenant à ce groupe se compose des méthodes #compareAndSet compareAndSet, , #weakCompareAndSetPlain weakCompareAndSetPlain, #weakCompareAndSet weakCompareAndSet#weakCompareAndSetAcquire weakCompareAndSetAcquire, #weakCompareAndSetRelease weakCompareAndSetRelease, #compareAndExchangeAcquire compareAndExchangeAcquire, #compareAndExchange compareAndExchange, #compareAndExchangeRelease compareAndExchangeRelease, , . #getAndSetRelease getAndSetRelease#getAndSet getAndSet#getAndSetAcquire getAndSetAcquire <modes d’accès à la mise à jour atomique li>numeric qui, par exemple, obtiennent et définissent atomiquement avec la valeur d’une variable sous les effets de classement de mémoire spécifiés. L’ensemble de méthodes de mode d’accès correspondantes appartenant à ce groupe se compose des méthodes #getAndAdd getAndAdd, #getAndAddAcquire getAndAddAcquire, , #getAndAddRelease getAndAddReleasedes <modes d’accès à la mise à jour atomique li>qui, par exemple, obtiennent atomiquement et bit OU la valeur d’une variable sous les effets d’ordre de mémoire spécifiés. L’ensemble de méthodes de mode d’accès correspondantes appartenant à ce groupe se compose des méthodes #getAndBitwiseOr getAndBitwiseOr, , #getAndBitwiseOrAcquire getAndBitwiseOrAcquire, #getAndBitwiseAnd getAndBitwiseAnd#getAndBitwiseOrRelease getAndBitwiseOrRelease, #getAndBitwiseAndAcquire getAndBitwiseAndAcquire, #getAndBitwiseAndRelease getAndBitwiseAndRelease, , #getAndBitwiseXor getAndBitwiseXor, , . #getAndBitwiseXorRelease getAndBitwiseXorRelease#getAndBitwiseXorAcquire getAndBitwiseXorAcquire </ul>

Les méthodes de fabrique qui produisent ou java.lang.invoke.MethodHandles.Lookup lookup varHandle documentent l’ensemble des modes d’accès pris en charge, qui peuvent également inclure des restrictions de documentation basées sur le type de variable et si une variable est en lecture seule. Si un mode d’accès n’est pas pris en charge, la méthode de mode d’accès correspondante est levée lors de UnsupportedOperationExceptionl’appel. Les méthodes de fabrique doivent documenter les exceptions non déclarées supplémentaires qui peuvent être levées par des méthodes en mode d’accès. Le #get get mode d’accès est pris en charge pour toutes les instances VarHandle et la méthode correspondante ne lève jamais UnsupportedOperationException. Si un VarHandle fait référence à une variable en lecture seule (par exemple, un final champ), écrivez, mettez à jour atomique, mettez à jour atomique numérique et les modes d’accès aux mises à jour atomiques au niveau du bit ne sont pas pris en charge et les méthodes correspondantes lèvent UnsupportedOperationException. Les modes d’accès en lecture/écriture (s’ils sont pris en charge), à l’exception de get et set, fournissent un accès atomique pour les types de référence et tous les types primitifs. Sauf indication contraire dans la documentation d’une méthode de fabrique, les modes get d’accès et set (si pris en charge) fournissent un accès atomique pour les types de référence et tous les types primitifs, à l’exception des plateformes 32 bits et double à l’exception des long plateformes 32 bits.

Les modes d’accès remplacent tous les effets de classement de la mémoire spécifiés sur le site de déclaration d’une variable. Par exemple, un VarHandle accédant à un champ à l’aide du get mode d’accès accède au champ tel qu’il est spécifié>< par son mode< d’accès/em> même si ce champ est déclaré volatile. Lorsque l’accès mixte est effectué, des soins extrêmes doivent être pris, car le modèle de mémoire Java peut permettre des résultats surprenants.

Outre la prise en charge de l’accès aux variables sous différents modes d’accès, un ensemble de méthodes statiques, appelées méthodes de clôture de mémoire, est également fourni pour un contrôle précis de l’ordre de la mémoire.

La spécification du langage Java permet à d’autres threads d’observer les opérations comme si elles étaient exécutées dans des commandes différentes de celles qui sont apparentes dans le code source du programme, sous réserve de contraintes résultant, par exemple, de l’utilisation de verrous, volatile de champs ou de VarHandles. Les méthodes statiques, , #fullFence fullFence, #loadLoadFence loadLoadFence #acquireFence acquireFence#releaseFence releaseFenceet , peuvent #storeStoreFence storeStoreFenceégalement être utilisées pour imposer des contraintes. Leurs spécifications, comme c’est le cas pour certains modes d’accès, sont décrites en termes d’absence de « réorganisations » : effets de classement observables qui pourraient autrement se produire si la clôture n’était pas présente. Une formulation plus précise de la spécification des méthodes de mode d’accès et des méthodes de clôture de mémoire peut accompagner les futures mises à jour de la spécification du langage Java.

<h1>Compilation d’appel de méthodes< de mode d’accès/h1> Une expression d’appel de méthode Java qui nomme une méthode de mode d’accès peut appeler un VarHandle à partir du code source Java. Du point de vue du code source, ces méthodes peuvent prendre n’importe quel argument et leur résultat polymorphe (s’il est exprimé) peut être converti en n’importe quel type de retour. Formellement, cela s’effectue en donnant aux méthodes d’accès des arguments d’arité Object variable et Object aux types de retour (si le type de retour est polymorphe), mais ils ont une qualité supplémentaire appelée <em>signature polymorphisme</em> qui connecte cette liberté d’appel directement à la pile d’exécution JVM.

Comme d’habitude avec les méthodes virtuelles, les appels au niveau source pour accéder aux méthodes de mode d’accès sont compilés dans une invokevirtual instruction. Plus inhabituellement, le compilateur doit enregistrer les types d’arguments réels et peut ne pas effectuer de conversions d’appel de méthode sur les arguments. Au lieu de cela, il doit générer des instructions pour les envoyer (push) sur la pile en fonction de leurs propres types non convertis. L’objet VarHandle lui-même est envoyé (push) sur la pile avant les arguments. Le compilateur génère ensuite une invokevirtual instruction qui appelle la méthode du mode d’accès avec un descripteur de type symbolique qui décrit l’argument et les types de retour.

Pour émettre un descripteur de type symbolique complet, le compilateur doit également déterminer le type de retour (s’il est polymorphe). Cela est basé sur un cast sur l’expression d’appel de méthode, s’il en existe un ou si Object l’appel est une expression, ou si void l’appel est une instruction. Le cast peut être d’un type primitif (mais pas void).

En tant que cas d’angle, un argument noncasté null reçoit un descripteur de type symbolique de java.lang.Void. L’ambiguïté avec le type Void est inoffensive, car il n’existe aucune référence de type Void , sauf la référence Null.

<h1>"invoke">Perform invocation of access mode methods</h1> The first time an invokevirtual executed it is executed it is linked by symbolally resolving the names in the instruction and verifying that the method call is statically legal. Cela permet également d’appeler des méthodes de mode d’accès. Dans ce cas, le descripteur de type symbolique émis par le compilateur est vérifié pour une syntaxe correcte et les noms qu’il contient sont résolus. Ainsi, une invokevirtual instruction qui appelle une méthode de mode d’accès lie toujours, tant que le descripteur de type symbolique est syntactiquement bien formé et que les types existent.

Lorsque l’exécution invokevirtual est effectuée après la liaison, le type de mode d’accès de VarHandle reçu est d’abord vérifié par la machine virtuelle JVM pour s’assurer qu’elle correspond au descripteur de type symbolique. Si la correspondance de type échoue, cela signifie que la méthode du mode d’accès que l’appelant appelle n’est pas présente sur l’appel de varHandle individuel.

L’appel d’une méthode en mode d’accès se comporte comme s’il s’agit d’un appel de , où le handle de MethodHandle#invokeméthode de réception accepte l’instance VarHandle comme argument de début. Plus précisément, le code suivant, où {access-mode} correspond au nom de la méthode du mode d’accès :

{@code
            VarHandle vh = ..
            R r = (R) vh.{access-mode}(p1, p2, ..., pN);
            }

se comporte comme si :

{@code
            VarHandle vh = ..
            VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
            MethodHandle mh = MethodHandles.varHandleExactInvoker(
                                  am,
                                  vh.accessModeType(am));

            R r = (R) mh.invoke(vh, p1, p2, ..., pN)
            }

(les méthodes du mode d’accès modulo ne déclarent pas de levée de Throwable). Ceci équivaut à :

{@code
            MethodHandle mh = MethodHandles.lookup().findVirtual(
                                  VarHandle.class,
                                  "{access-mode}",
                                  MethodType.methodType(R, p1, p2, ..., pN));

            R r = (R) mh.invokeExact(vh, p1, p2, ..., pN)
            }

où le type de méthode souhaité est le descripteur de type symbolique et un MethodHandle#invokeExact est effectué, car avant l’appel de la cible, le handle applique des casts de référence selon les besoins et la zone, unbox ou les valeurs primitives larges, comme si par MethodHandle#asType asType (voir aussi MethodHandles#varHandleInvoker).

Plus concis, ce comportement équivaut à :

{@code
            VarHandle vh = ..
            VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
            MethodHandle mh = vh.toMethodHandle(am);

            R r = (R) mh.invoke(p1, p2, ..., pN)
            }

Dans ce cas, dans ce cas, le handle de méthode est lié à l’instance VarHandle.

<h1>Vérification de l’appel</h1> Dans les programmes classiques, la correspondance du type de mode d’accès VarHandle réussit généralement. Mais si une correspondance échoue, la machine virtuelle JVM lève un WrongMethodTypeException.

Ainsi, une incompatibilité de type de mode d’accès qui peut apparaître comme une erreur de liaison dans un programme typé statiquement peut apparaître comme une dynamique WrongMethodTypeException dans un programme qui utilise VarHandles.

Étant donné que les types de mode d’accès contiennent des objets « live », Class la correspondance des types de méthode prend en compte les noms de types et les chargeurs de classes. Ainsi, même si un VarHandle VH est créé dans un chargeur L1 de classe et utilisé dans un autre L2, les appels de méthode du mode d’accès VarHandle sont de type sécurisé, car le descripteur de type symbolique de l’appelant, tel qu’il est résolu, est mis en L2correspondance avec le descripteur de type symbolique de la méthode d’appel d’origine, comme résolu dans L1. La résolution L1 se produit lorsqu’elle VH est créée et ses types de mode d’accès sont affectés, tandis que la résolution L2 se produit lorsque l’instruction invokevirtual est liée.

Outre les vérifications de descripteur de type, la capacité d’un VarHandles à accéder à ses variables est illimitée. Si un VarHandle est formé sur une variable non publique par une classe qui a accès à cette variable, le VarHandle résultant peut être utilisé à n’importe quel endroit par n’importe quel appelant qui reçoit une référence à celle-ci.

Contrairement à l’API Core Reflection, où l’accès est vérifié chaque fois qu’une méthode réfléchissante est appelée, la vérification de l’accès VarHandle est effectuée lors de la création de VarHandle. Par conséquent, VarHandles vers des variables non publiques ou des variables dans des classes non publiques doit généralement être gardé secret. Ils ne doivent pas être passés à du code non approuvé, sauf si leur utilisation à partir du code non approuvé serait inoffensive.

<Le code Java h1>varHandle</h1> peut créer un VarHandle qui accède directement à n’importe quel champ accessible à ce code. Cela s’effectue via une API réfléchissante basée sur les capacités appelée java.lang.invoke.MethodHandles.Lookup MethodHandles.Lookup. Par exemple, un VarHandle pour un champ non statique peut être obtenu à partir de java.lang.invoke.MethodHandles.Lookup#findVarHandle Lookup.findVarHandle. Il existe également une méthode de conversion à partir d’objets d’API Core Reflection, java.lang.invoke.MethodHandles.Lookup#unreflectVarHandle Lookup.unreflectVarHandle.

L’accès aux membres de champ protégés est limité aux destinataires uniquement de la classe d’accès, ou à l’une de ses sous-classes, et la classe d’accès doit à son tour être une sous-classe (ou frère de package) de la classe de définition du membre protégé. Si un VarHandle fait référence à un champ non statique protégé d’une classe déclarante en dehors du package actuel, l’argument de récepteur est limité au type de la classe d’accès.

<h1>Interoperation entre VarHandles et l’API< Core Reflection/h1> À l’aide de méthodes de fabrique dans l’API java.lang.invoke.MethodHandles.Lookup Lookup , tout champ représenté par un objet API Core Reflection peut être converti en varHandle équivalent comportemental. Par exemple, une réflexion java.lang.reflect.Field Field peut être convertie en varHandle à l’aide java.lang.invoke.MethodHandles.Lookup#unreflectVarHandle Lookup.unreflectVarHandlede . Les VarHandles résultants fournissent généralement un accès plus direct et efficace aux champs sous-jacents.

En tant que cas particulier, lorsque l’API Core Reflection est utilisée pour afficher les méthodes de mode d’accès polymorphe de signature dans cette classe, elles apparaissent comme des méthodes non polymorphes ordinaires. Leur apparence réfléchissante, telle qu’elle est vue par java.lang.Class#getDeclaredMethod Class.getDeclaredMethod, n’est pas affectée par leur statut spécial dans cette API. Par exemple, java.lang.reflect.Method#getModifiers Method.getModifiers signale exactement ces bits de modificateur requis pour toute méthode déclarée de la même façon, y compris dans ce cas native et varargs les bits.

Comme avec n’importe quelle méthode réfléchie, ces méthodes (lorsqu’elles sont reflétées) peuvent être appelées directement via , via java.lang.reflect.Method#invoke java.lang.reflect.Method.invokeJNI ou indirectement via java.lang.invoke.MethodHandles.Lookup#unreflect Lookup.unreflect. Toutefois, ces appels réfléchissants n’entraînent pas d’appel de méthode d’accès. Un tel appel, s’il est passé l’argument requis (un seul, de type Object[]), ignore l’argument et lève un UnsupportedOperationException.

Étant donné que invokevirtual les instructions peuvent appeler en mode natif les méthodes du mode d’accès VarHandle sous n’importe quel descripteur de type symbolique, cette vue réfléchissante est en conflit avec la présentation normale de ces méthodes via des bytecodes. Ainsi, ces méthodes natives, lorsqu’elles sont réfléchies par Class.getDeclaredMethod, peuvent être considérées comme des espaces réservés uniquement.

Pour obtenir une méthode d’appelant pour un type de mode d’accès particulier, utilisez java.lang.invoke.MethodHandles#varHandleExactInvoker ou java.lang.invoke.MethodHandles#varHandleInvoker. L’API java.lang.invoke.MethodHandles.Lookup#findVirtual Lookup.findVirtual est également en mesure de retourner un handle de méthode pour appeler une méthode de mode d’accès pour n’importe quel type de mode d’accès spécifié et est équivalente au comportement à java.lang.invoke.MethodHandles#varHandleInvoker.

<L’interopérabilité h1>entre VarHandles et les génériques< Java/h1> A VarHandle peut être obtenue pour une variable, telle qu’un champ, déclaré avec des types génériques Java. Comme avec l’API Core Reflection, le type de variable varHandle sera construit à partir de l’effacement du type de niveau source. Lorsqu’une méthode de mode d’accès VarHandle est appelée, les types de ses arguments ou le type de conversion de valeur de retour peuvent être des types génériques ou des instances de type. Si cela se produit, le compilateur remplace ces types par leurs effacements lorsqu’il construit le descripteur de type symbolique pour l’instruction invokevirtual .

Ajouté dans 9.

Documentation Java pour java.lang.invoke.VarHandle.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

Constructeurs

VarHandle(IntPtr, JniHandleOwnership)

Propriétés

Class	Retourne la classe runtime de ce `Object`. (Hérité de Object)
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
JniIdentityHashCode	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
JniPeerMembers	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
PeerReference	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
ThresholdClass	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
ThresholdType	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.

Méthodes

AccessModeType(VarHandle+AccessMode)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
AcquireFence()	Garantit que les charges avant la clôture ne seront pas réorganisées avec des charges et des magasins après la clôture.
Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
CompareAndExchange(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
CompareAndExchangeAcquire(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
CompareAndExchangeRelease(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
CompareAndSet(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
CoordinateTypes()	Retourne les types de coordonnées de ce VarHandle.
Dispose()	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
Dispose(Boolean)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
FullFence()	Garantit que les charges et les magasins avant la clôture ne seront pas réorganisées avec des charges et des magasins après la clôture.
Get(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAcquire(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndAdd(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndAddAcquire(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndAddRelease(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseAnd(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseAndAcquire(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseAndRelease(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseOr(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseOrAcquire(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseOrRelease(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseXor(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseXorAcquire(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndBitwiseXorRelease(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndSet(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndSetAcquire(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetAndSetRelease(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetHashCode()	Retourne une valeur de code de hachage pour l'objet. (Hérité de Object)
GetOpaque(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetVolatile(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
IsAccessModeSupported(VarHandle+AccessMode)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
LoadLoadFence()	Garantit que les charges avant la clôture ne seront pas réorganisées avec des charges après la clôture.
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
ReleaseFence()	Garantit que les chargements et les magasins avant la clôture ne seront pas réorganisé avec les magasins après la clôture.
Set(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
SetOpaque(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
SetRelease(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
SetVolatile(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
StoreStoreFence()	Garantit que les magasins avant la clôture ne seront pas réorganisé avec des magasins après la clôture.
ToArray<T>()	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
ToMethodHandle(VarHandle+AccessMode)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
ToString()	Retourne une représentation de chaîne de l'objet. (Hérité de Object)
UnregisterFromRuntime()	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
VarType()	Retourne le type de variable des variables référencées par ce VarHandle.
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou> <em>interrompu</em>.<> (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
WeakCompareAndSet(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
WeakCompareAndSetAcquire(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
WeakCompareAndSetPlain(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
WeakCompareAndSetRelease(Object[])	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.

Implémentations d’interfaces explicites

IJavaPeerable.Disposed()	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
IJavaPeerable.DisposeUnlessReferenced()	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
IJavaPeerable.Finalized()	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
IJavaPeerable.JniManagedPeerState	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas. (Hérité de Object)

Méthodes d’extension

JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.
GetJniTypeName(IJavaPeerable)	Un VarHandle est une référence fortement typée dynamiquement à une variable ou à une famille de variables définie de manière paramétrique, y compris des champs statiques, des champs non statiques, des éléments de tableau ou des composants d’une structure de données hors tas.

S’applique à

Partager via