MethodHandle Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos.
[Android.Runtime.Register("java/lang/invoke/MethodHandle", ApiSince=26, DoNotGenerateAcw=true)]
public abstract class MethodHandle : Java.Lang.Object[<Android.Runtime.Register("java/lang/invoke/MethodHandle", ApiSince=26, DoNotGenerateAcw=true)>]
type MethodHandle = class
inherit Object- Herencia
- Atributos
Comentarios
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. Estas transformaciones son bastante generales e incluyen patrones como #asType conversión, #bindTo inserción, java.lang.invoke.MethodHandles#dropArguments eliminación y java.lang.invoke.MethodHandles#filterArguments sustitución.
<h1>Los identificadores de método/<h1> son dinámicos y fuertemente tipados según su parámetro y tipos de valor devuelto. No se distinguen por el nombre ni por la clase de definición de sus métodos subyacentes. Se debe invocar un identificador de método mediante un descriptor de tipo simbólico que coincida con el propio descriptor de tipo de #type del método.
Cada método controla su descriptor de tipo a través del descriptor de #type type acceso. Este descriptor de tipo es un java.lang.invoke.MethodType MethodType objeto, cuya estructura es una serie de clases, una de las cuales es el tipo de valor devuelto del método (o void.class si no existe).
El tipo de un identificador de método controla los tipos de invocaciones que acepta y los tipos de transformaciones que se aplican a él.
Un identificador de método contiene un par de métodos de invocador especiales denominados #invokeExact invokeExact y #invoke invoke. Ambos métodos de invocador proporcionan acceso directo al método subyacente, constructor, campo u otra operación del controlador del método, tal y como modifican las transformaciones de argumentos y valores devueltos. Ambos invocadores aceptan llamadas que coinciden exactamente con el propio tipo del identificador del método. El invocador sin formato, inexacto también acepta un intervalo de otros tipos de llamadas.
Los identificadores de método son inmutables y no tienen ningún estado visible. Por supuesto, se pueden enlazar a métodos subyacentes o datos que muestran el estado. Con respecto al modelo de memoria de Java, cualquier identificador de método se comportará como si todos sus campos (internos) sean variables finales. Esto significa que cualquier identificador de método visible para la aplicación siempre estará totalmente formado. Esto es cierto incluso si el identificador del método se publica a través de una variable compartida en una carrera de datos.
El usuario no puede clasificar los identificadores de método. Las implementaciones pueden (o no) crear subclases internas de las que pueden estar visibles a través de MethodHandle la java.lang.Object#getClass Object.getClass operación. El programador no debe extraer conclusiones sobre un identificador de método de su clase específica, ya que la jerarquía de clases de identificador de método (si existe) puede cambiar de vez en cuando o entre implementaciones de diferentes proveedores.
<h1>Método handle compilation</h1> A Java método call expression naming invokeExact or invoke can invoke a method handle from Java source code. Desde el punto de vista del código fuente, estos métodos pueden tomar cualquier argumento y su resultado se puede convertir a cualquier tipo de valor devuelto. Formalmente, esto se logra al proporcionar a los métodos invocadores tipos devueltos Object y argumentos de aridad Object variable, pero tienen una calidad adicional denominada <polimorfismo> de firma em</em> que conecta esta libertad de invocación directamente a la pila de ejecución de JVM.
Como es habitual con los métodos virtuales, las llamadas de nivel de origen a invokeExact y invoke se compilan en una invokevirtual instrucción. Más inusualmente, el compilador debe registrar los tipos de argumento reales y puede que no realice conversiones de invocación de método en los argumentos. En su lugar, debe insertarlos en la pila según sus propios tipos no convertidos. El propio objeto de identificador de método se inserta en la pila antes de los argumentos. A continuación, el compilador llama al identificador de método con un descriptor de tipo simbólico que describe el argumento y los tipos devueltos.
Para emitir un descriptor de tipo simbólico completo, el compilador también debe determinar el tipo de valor devuelto. Esto se basa en una conversión en la expresión de invocación de método, si hay una, o si Object la invocación es una expresión o si void la invocación es una instrucción . La conversión puede ser de un tipo primitivo (pero no void).
Como caso de esquina, a un argumento sin null difusión se le asigna un descriptor de tipo simbólico de java.lang.Void. La ambigüedad con el tipo Void es inofensiva, ya que no hay referencias de tipo Void excepto la referencia nula.
<h1>Método identificador invocation</h1> La primera vez que se ejecuta una invokevirtual instrucción está vinculada, resolviendo simbólicamente los nombres en la instrucción y comprobando que la llamada al método es estáticamente legal. Esto es cierto en las llamadas a invokeExact y invoke. En este caso, el descriptor de tipo simbólico emitido por el compilador se comprueba si hay sintaxis correcta y los nombres que contiene se resuelven. Por lo tanto, una invokevirtual instrucción que invoca un identificador de método siempre se vinculará, siempre que el descriptor de tipo simbólico tenga un formato sintáctico y existan los tipos.
invokevirtual Cuando se ejecuta después de la vinculación, la JVM comprueba primero el tipo del método receptor para asegurarse de que coincide con el descriptor de tipo simbólico. Si se produce un error en la coincidencia de tipo, significa que el método que invoca el autor de la llamada no está presente en el identificador de método individual que se invoca.
En el caso de invokeExact, el descriptor de tipo de la invocación (después de resolver nombres de tipo simbólico) debe coincidir exactamente con el tipo de método del identificador de método receptor. En el caso de un descriptor de tipo sin formato, inexacto invoke, el descriptor de tipo resuelto debe ser un argumento válido para el método del #asType asType receptor. Por lo tanto, simple invoke es más permisivo que invokeExact.
Después de la coincidencia de tipos, una llamada a directamente invokeExact e invoque inmediatamente el método subyacente del identificador del método (u otro comportamiento, como puede ser el caso).
Una llamada a plain invoke funciona igual que una llamada a invokeExact, si el descriptor de tipo simbólico especificado por el llamador coincide exactamente con el tipo propio del identificador del método. Si hay un error de coincidencia de tipos, invoke intenta ajustar el tipo del identificador del método receptor, como si fuera una llamada a #asType asType, para obtener un identificador M2de método invocable exactamente . Esto permite una negociación más eficaz del tipo de método entre el autor de la llamada y el destinatario.
(<em>Note:</em> El identificador M2 del método ajustado no es directamente observable, y las implementaciones no son necesarias para materializarlo).
<h1>Comprobación de< invocación/h1> En programas típicos, la coincidencia de tipos de identificador de método normalmente se realizará correctamente. Pero si se produce un error en una coincidencia, la JVM iniciará un WrongMethodTypeException, directamente (en el caso de invokeExact) o indirectamente como si se hubiera producido un error en la llamada ( asType en el caso de invoke).
Por lo tanto, un error de coincidencia de tipo de método que podría aparecer como un error de vinculación en un programa con tipo estático puede aparecer como dinámico WrongMethodTypeException en un programa que usa identificadores de método.
Dado que los tipos de método contienen objetos "activos", Class la coincidencia de tipos de método tiene en cuenta los nombres de tipos y los cargadores de clases. Por lo tanto, incluso si se crea un identificador M de método en un cargador L1 de clases y se usa en otro L2, las llamadas de identificador de método son seguras para tipos, ya que el descriptor de tipo simbólico del autor de la llamada, tal como se resuelve en L2, coincide con el descriptor de tipo simbólico del método de llamada original, como se resuelve en L1. La resolución de L1 se produce cuando M se crea y se asigna su tipo, mientras que la resolución en L2 se produce cuando la invokevirtual instrucción está vinculada.
Aparte de la comprobación de descriptores de tipo, la capacidad de un identificador de método para llamar a su método subyacente no está restringida. Si un identificador de método se forma en un método no público por una clase que tiene acceso a ese método, cualquier llamador que reciba una referencia a él puede usar el identificador resultante en cualquier lugar.
A diferencia de Core Reflection API, donde se comprueba el acceso cada vez que se invoca un método reflectante, el método controla la comprobación de acceso cuando se crea el identificador de método. En el caso de (consulte a continuación), la comprobación de acceso se realiza como parte de la vinculación de ldc la entrada del grupo de constantes subyacente al identificador del método constante.
Por lo tanto, los identificadores de los métodos no públicos o los métodos de clases no públicas deben mantenerse en secreto. No deben pasarse al código que no es de confianza a menos que su uso del código que no sea de confianza sea inofensivo.
<h1>Método handle creation</h1> Java código puede crear un identificador de método que acceda directamente a cualquier método, constructor o campo al que se pueda acceder a ese código. Esto se hace a través de una API reflectante basada en funcionalidad denominada java.lang.invoke.MethodHandles.Lookup MethodHandles.Lookup Por ejemplo, se puede obtener un identificador de método estático de java.lang.invoke.MethodHandles.Lookup#findStatic Lookup.findStatic. También hay métodos de conversión de objetos core Reflection API, como java.lang.invoke.MethodHandles.Lookup#unreflect Lookup.unreflect.
Al igual que las clases y las cadenas, los identificadores de método que corresponden a campos, métodos y constructores accesibles también se pueden representar directamente en el grupo de constantes de un archivo de clase como constantes que se van a cargar mediante ldc códigos de bytes. Un nuevo tipo de entrada de grupo de constantes, , CONSTANT_MethodHandlehace referencia directamente a una entrada asociada CONSTANT_Methodrefal grupo de constantes , CONSTANT_InterfaceMethodrefo CONSTANT_Fieldref . (Para obtener información completa sobre las constantes de identificador de método, consulte las secciones 4.4.8 y 5.4.3.5 de la especificación de máquina virtual de Java).
Los identificadores de método generados por búsquedas o cargas constantes de métodos o constructores con el bit modificador de arity variable (0x0080) tienen una aridad de variable correspondiente, como si se definieran con la ayuda de #asVarargsCollector asVarargsCollector.
Una referencia de método puede hacer referencia a un método estático o no estático. En el caso no estático, el tipo de identificador de método incluye un argumento de receptor explícito, antepuesto antes de cualquier otro argumento. En el tipo del identificador del método, el argumento receptor inicial se escribe según la clase en la que se solicitó inicialmente el método. (Por ejemplo, si se obtiene un identificador de método no estático a través ldcde , el tipo del receptor es la clase denominada en la entrada del grupo de constantes).
Las constantes de identificador de método están sujetas a las mismas instrucciones de acceso en tiempo de vínculo comprueban sus instrucciones de código de bytes correspondientes y la ldc instrucción producirá errores de vinculación correspondientes si los comportamientos de código de bytes generarían estos errores.
Como corolario de esto, el acceso a los miembros protegidos se restringe solo a los receptores de la clase de acceso, o a una de sus subclases, y la clase de acceso debe ser, a su vez, una subclase (o elemento relacionado del paquete) de la clase de definición del miembro protegido. Si una referencia de método hace referencia a un campo o método no estático protegido de una clase fuera del paquete actual, el argumento receptor se restringirá al tipo de la clase de acceso.
Cuando se invoca un identificador de método a un método virtual, el método siempre se busca en el receptor (es decir, el primer argumento).
También se puede crear un identificador de método no virtual para una implementación de método virtual específica. No realizan búsquedas virtuales basadas en el tipo de receptor. Este identificador de método simula el efecto de una invokespecial instrucción en el mismo método.
<h1>Ejemplos de uso</h1> Estos son algunos ejemplos de uso: <blockquote>
{@code
Object x, y; String s; int i;
MethodType mt; MethodHandle mh;
MethodHandles.Lookup lookup = MethodHandles.lookup();
// mt is (char,char)String
mt = MethodType.methodType(String.class, char.class, char.class);
mh = lookup.findVirtual(String.class, "replace", mt);
s = (String) mh.invokeExact("daddy",'d','n');
// invokeExact(Ljava/lang/String;CC)Ljava/lang/String;
assertEquals(s, "nanny");
// weakly typed invocation (using MHs.invoke)
s = (String) mh.invokeWithArguments("sappy", 'p', 'v');
assertEquals(s, "savvy");
// mt is (Object[])List
mt = MethodType.methodType(java.util.List.class, Object[].class);
mh = lookup.findStatic(java.util.Arrays.class, "asList", mt);
assert(mh.isVarargsCollector());
x = mh.invoke("one", "two");
// invoke(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
assertEquals(x, java.util.Arrays.asList("one","two"));
// mt is (Object,Object,Object)Object
mt = MethodType.genericMethodType(3);
mh = mh.asType(mt);
x = mh.invokeExact((Object)1, (Object)2, (Object)3);
// invokeExact(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
assertEquals(x, java.util.Arrays.asList(1,2,3));
// mt is ()int
mt = MethodType.methodType(int.class);
mh = lookup.findVirtual(java.util.List.class, "size", mt);
i = (int) mh.invokeExact(java.util.Arrays.asList(1,2,3));
// invokeExact(Ljava/util/List;)I
assert(i == 3);
mt = MethodType.methodType(void.class, String.class);
mh = lookup.findVirtual(java.io.PrintStream.class, "println", mt);
mh.invokeExact(System.out, "Hello, world.");
// invokeExact(Ljava/io/PrintStream;Ljava/lang/String;)V
}
</blockquote> Cada una de las llamadas anteriores a invokeExact o sin formato invoke genera una única instrucción invokevirtual con el descriptor de tipo simbólico indicado en el comentario siguiente. En estos ejemplos, se supone que el método assertEquals auxiliar es un método que llama java.util.Objects#equals(Object,Object) Objects.equals a en sus argumentos y afirma que el resultado es true.
<h1>Exceptions/h1< Los métodos>invokeExact y invoke se declaran para iniciar java.lang.Throwable Throwable, que es decir, no hay ninguna restricción estática sobre lo que puede producir un identificador de método. Dado que la JVM no distingue entre excepciones activadas y desactivadas (excepto por su clase, por supuesto), no hay ningún efecto particular en la forma de código de bytes de la ascribir excepciones comprobadas a las invocaciones de identificador de método. Pero en Java código fuente, los métodos que realizan llamadas de identificador de método deben iniciar Throwableexplícitamente o, de lo contrario, deben detectar todos los iniciables localmente, volver a iniciar solo aquellos que son legales en el contexto y ajustar los que son ilegales.
<h1>"sigpoly">Polimorfismo< de firma/h1> El comportamiento inusual de compilación y vinculación de invokeExact y simple invoke se hace referencia al término <polimorfismo>/em< de firma em>. Tal como se define en la especificación del lenguaje Java, un método polimórfico de firma es uno que puede funcionar con cualquiera de una amplia gama de firmas de llamada y tipos de valor devuelto.
En el código fuente, se compilará una llamada a un método polimórfico de firma, independientemente del descriptor de tipo simbólico solicitado. Como de costumbre, el compilador de Java emite una invokevirtual instrucción con el descriptor de tipo simbólico especificado en el método con nombre. La parte inusual es que el descriptor de tipo simbólico se deriva del argumento real y los tipos devueltos, no de la declaración del método.
Cuando JVM procesa el código de bytes que contiene llamadas polimórficas de firma, vinculará correctamente cualquier llamada, independientemente de su descriptor de tipo simbólico. (Para conservar la seguridad de tipos, la JVM protegerá dichas llamadas con comprobaciones de tipos dinámicas adecuadas, como se describe en otra parte).
Los generadores de código de bytes, incluido el back-end del compilador, deben emitir descriptores de tipos simbólicos no transformados para estos métodos. Las herramientas que determinan la vinculación simbólica son necesarias para aceptar estos descriptores no transformados, sin notificar errores de vinculación.
<h1>Interoperation between method handles and the Core Reflection API/h1< Using factory methods in the > APIjava.lang.invoke.MethodHandles.Lookup Lookup, any class member represent by a Core Reflection API object can be converted to a conductly equivalente method handle. Por ejemplo, un reflectante java.lang.reflect.Method Method se puede convertir en un identificador de método mediante java.lang.invoke.MethodHandles.Lookup#unreflect Lookup.unreflect. Los identificadores de método resultantes suelen proporcionar acceso más directo y eficaz a los miembros de clase subyacentes.
Como caso especial, cuando core Reflection API se usa para ver los métodos polimórficos de firma o sin invokeExact formato en esta clase, aparecen como métodos invoke no polimórficos normales. Su apariencia reflectante, tal como la ve java.lang.Class#getDeclaredMethod Class.getDeclaredMethod, no se ve afectada por su estado especial en esta API. Por ejemplo, java.lang.reflect.Method#getModifiers Method.getModifiers notificará exactamente esos bits modificadores necesarios para cualquier método declarado de forma similar, incluidos en este caso native y varargs bits.
Al igual que con cualquier método reflejado, estos métodos (cuando se reflejan) se pueden invocar a través java.lang.reflect.Method#invoke java.lang.reflect.Method.invokede . Sin embargo, estas llamadas reflectantes no dan lugar a invocaciones de identificador de método. Esta llamada, si se pasa el argumento necesario (uno único, de tipo Object[]), omitirá el argumento y producirá una UnsupportedOperationExceptionexcepción .
Dado que invokevirtual las instrucciones pueden invocar de forma nativa los identificadores de método en cualquier descriptor de tipo simbólico, esta vista reflectante entra en conflicto con la presentación normal de estos métodos a través de códigos de bytes. Por lo tanto, estos dos métodos nativos, cuando se ven de forma reflexiva por Class.getDeclaredMethod, solo pueden considerarse como marcadores de posición.
Para obtener un método de invocador para un descriptor de tipo determinado, use java.lang.invoke.MethodHandles#exactInvoker MethodHandles.exactInvokero java.lang.invoke.MethodHandles#invoker MethodHandles.invoker. La java.lang.invoke.MethodHandles.Lookup#findVirtual Lookup.findVirtual API también puede devolver un identificador de método para llamar invokeExact a o sin formato invokepara cualquier descriptor de tipo especificado.
<h1>Interoperation between method handles and Java generics</h1> A method handle can be obtained on a method, constructor or field which is declare with Java generic types. Al igual que con Core Reflection API, el tipo del identificador de método se construirá a partir de la eliminación del tipo de nivel de origen. Cuando se invoca un identificador de método, los tipos de sus argumentos o el tipo de conversión de valor devuelto pueden ser tipos genéricos o instancias de tipo. Si esto ocurre, el compilador reemplazará esos tipos por sus borrados cuando construya el descriptor de tipo simbólico para la invokevirtual instrucción.
Los identificadores de método no representan sus tipos similares a funciones en términos de tipos parametrizados (genéricos) Java, ya que hay tres errores de coincidencia entre tipos similares a funciones y tipos de Java parametrizados. <Ul><li>Los tipos de método abarcan todas las aridades posibles, desde ningún argumento hasta el número máximo de argumentos permitidos. Los genéricos no son variádicos, por lo que no pueden representar esto.<Los tipos de método /li><>pueden especificar argumentos de tipos primitivos, que Java tipos genéricos no pueden oscilar.</li li><>Las funciones de orden superior sobre los identificadores de método (combinadores) suelen ser genéricas en una amplia gama de tipos de función, incluidas las de varias aridades. Es imposible representar dicha genérica con un parámetro de tipo Java.</li></ul>
<h1>"maxarity">Arity limits</h1> La JVM impone a todos los métodos y constructores de cualquier tipo un límite absoluto de 255 argumentos apilados. Este límite puede parecer más restrictivo en determinados casos: <ul><li>A long o double recuentos de argumentos (con fines de límites de aridad) como dos ranuras de argumento.
<li>Un método no estático consume un argumento adicional para el objeto en el que se llama al método .
<li>Un constructor consume un argumento adicional para el objeto que se está construyendo.
<li>Desde un identificador de método' el método s invoke (u otro método polimórfico de firma) no es virtual, consume un argumento adicional para el propio identificador del método, además de cualquier objeto receptor no virtual.
</ul> Estos límites implican que no se pueden crear determinados identificadores de método, únicamente debido al límite de JVM en argumentos apilados. Por ejemplo, si un método JVM estático acepta exactamente 255 argumentos, no se puede crear un identificador de método para él. Los intentos de crear identificadores de método con tipos de método imposibles conducen a .IllegalArgumentException En concreto, un identificador de método' el tipo s no debe tener una aridad del máximo exacto 255.
Java documentación para java.lang.invoke.MethodHandle.
Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.
Constructores
| Nombre | Description |
|---|---|
| MethodHandle(IntPtr, JniHandleOwnership) |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. |
Propiedades
| Nombre | Description |
|---|---|
| Class |
Devuelve la clase en tiempo de ejecución de este |
| Handle |
Identificador de la instancia de Android subyacente. (Heredado de Object) |
| IsVarargsCollector |
Determina si este identificador de método admite llamadas de aridad de variables #asVarargsCollector. |
| JniIdentityHashCode |
Obtiene el código hash de identidad asignado a este Java del mismo nivel por el tiempo de ejecución de interoperabilidad. (Heredado de Object) |
| JniManagedPeerState |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| JniPeerMembers |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. |
| PeerReference |
Obtiene la referencia de objeto JNI para este Java del mismo nivel. (Heredado de Object) |
| ThresholdClass |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. |
| ThresholdType |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. |
Métodos
| Nombre | Description |
|---|---|
| AsCollector(Class, Int32) |
Convierte un <identificador de método em>array-collecting</em> , que acepta un número determinado de argumentos posicionales finales y los recopila en un argumento de matriz. |
| AsCollector(Int32, Class, Int32) |
Convierte un <identificador de método em>array-collecting</em> , que acepta un número determinado de argumentos posicionales a partir de una posición determinada y los recopila en un argumento de matriz. |
| AsFixedArity() |
Hace que un <identificador de método em>sea arity</em> fijo, que de lo contrario es equivalente al identificador del método actual. |
| AsSpreader(Class, Int32) |
Convierte un <identificador de método em>array-spreading</em> , que acepta un argumento de matriz final y propaga sus elementos como argumentos posicionales. |
| AsSpreader(Int32, Class, Int32) |
Convierte un <identificador de método em>array-spreading</em> , que acepta un argumento de matriz en una posición determinada y propaga sus elementos como argumentos posicionales en lugar de la matriz. |
| AsType(MethodType) |
Genera un identificador de método de adaptador que adapta el tipo del identificador de método actual a un nuevo tipo. |
| AsVarargsCollector(Class) |
Convierte una <arity>/em< adaptador de variable em>que es capaz de aceptar cualquier número de argumentos posicionales finales y recopilarlos en un argumento de matriz. |
| BindTo(Object) |
Enlaza un valor |
| Clone() |
Crea y devuelve una copia de este objeto. (Heredado de Object) |
| Construct(JniObjectReference, JniObjectReferenceOptions) |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| Dispose() |
Libera los recursos mantenidos por este Java del mismo nivel. (Heredado de Object) |
| Dispose(Boolean) |
Libera los recursos mantenidos por este Java del mismo nivel. (Heredado de Object) |
| DisposeUnlessReferenced() |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| Equals(Object) |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| Equals(Object) |
Indica si algún otro objeto es "igual a" este. (Heredado de Object) |
| GetHashCode() |
Devuelve un valor de código hash para el objeto . (Heredado de Object) |
| Invoke(Object[]) |
Invoca el identificador de método, lo que permite cualquier descriptor de tipo de llamada y, opcionalmente, realiza conversiones en argumentos y valores devueltos. |
| InvokeExact(Object[]) |
Invoca el identificador de método, lo que permite cualquier descriptor de tipo de llamada, pero requiere una coincidencia exacta de tipo. |
| InvokeWithArguments(IList<Object>) |
Realiza una invocación de aridad variable, pasando los argumentos de la matriz dada al identificador de método, como si a través de una inexacta |
| InvokeWithArguments(Object[]) |
Realiza una invocación de aridad variable, pasando los argumentos de la lista dada al identificador de método, como si a través de una inexacta |
| JavaFinalize() |
Obsoletos.
Lo llama el recolector de elementos no utilizados en un objeto cuando la recolección de elementos no utilizados determina que no hay más referencias al objeto . (Heredado de Object) |
| Notify() |
Activa un único subproceso que está esperando en el monitor de este objeto. (Heredado de Object) |
| NotifyAll() |
Activa todos los subprocesos que están esperando en el monitor de este objeto. (Heredado de Object) |
| SetHandle(IntPtr, JniHandleOwnership) |
Establece la propiedad Handle. (Heredado de Object) |
| SetPeerReference(JniObjectReference, JniObjectReferenceOptions) |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| ToArray<T>() |
Crea una matriz administrada a partir de este contenedor de matriz Java. (Heredado de Object) |
| ToString() |
Devuelve una representación de cadena del objeto . (Heredado de Object) |
| Type() |
Informa del tipo de este identificador de método. |
| UnregisterFromRuntime() |
Anula el registro de este Java del mismo nivel del tiempo de ejecución de interoperabilidad. (Heredado de Object) |
| Wait() |
Hace que el subproceso actual espere hasta que se despierte, normalmente por ser em notificado/em< o >em<interrumpido>/em<.><> (Heredado de Object) |
| Wait(Int64, Int32) |
Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object) |
| Wait(Int64) |
Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object) |
| WithVarargs(Boolean) |
Adapta este identificador de método para que sea #asVarargsCollector aridad variable si la marca booleana es true, en caso contrario, #asFixedArity aridad fija. |
Implementaciones de interfaz explícitas
| Nombre | Description |
|---|---|
| IJavaPeerable.Disposed() |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| IJavaPeerable.Finalized() |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| IJavaPeerable.JniObjectReferenceControlBlock |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. (Heredado de JavaObject) |
Métodos de extensión
| Nombre | Description |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Obtiene el nombre JNI del tipo de la instancia |
| JavaAs<TResult>(IJavaPeerable) |
Intente coerción |
| JavaCast<TResult>(IJavaObject) |
Realiza una conversión de tipos comprobados en tiempo de ejecución de Android. |
| JavaCast<TResult>(IJavaObject) |
Un identificador de método es una referencia de tipo ejecutable directa a un método subyacente, constructor, campo o operación similar de bajo nivel, con transformaciones opcionales de argumentos o valores devueltos. |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Intente coerción |