CountedCompleter 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í.
con ForkJoinTask una acción de finalización realizada cuando se desencadena y no hay acciones pendientes restantes.
[Android.Runtime.Register("java/util/concurrent/CountedCompleter", ApiSince=24, DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public abstract class CountedCompleter : Java.Util.Concurrent.ForkJoinTask[<Android.Runtime.Register("java/util/concurrent/CountedCompleter", ApiSince=24, DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
type CountedCompleter = class
inherit ForkJoinTask- Herencia
- Atributos
Comentarios
con ForkJoinTask una acción de finalización realizada cuando se desencadena y no hay acciones pendientes restantes. CountedCompleters son en general más sólidos en presencia de puestos de subtarea y bloqueo que otras formas de ForkJoinTasks, pero son menos intuitivos para programar. Los usos de CountedCompleter son similares a los de otros componentes basados en finalización (como java.nio.channels.CompletionHandler), excepto que puede ser necesario realizar varias <finalizaciones pendientes></em> para desencadenar la acción #onCompletion(CountedCompleter)de finalización , no solo una. A menos que se inicialice de lo contrario, el #getPendingCount recuento pendiente comienza en cero, pero puede cambiarse (de forma atómica) mediante métodos #setPendingCount, #addToPendingCounty #compareAndSetPendingCount. Tras la invocación de , si el recuento de #tryCompleteacciones pendientes es distinto de cero, se decrementa; de lo contrario, se realiza la acción de finalización y, si este completador tiene un completador, el proceso continúa con su completador. Como es el caso de los componentes de sincronización relacionados, como Phaser y Semaphore, estos métodos afectan solo a los recuentos internos; no establecen ningún mantenimiento interno adicional. En concreto, no se mantienen las identidades de las tareas pendientes. Como se muestra a continuación, puede crear subclases que registren algunas o todas las tareas pendientes o sus resultados cuando sea necesario. Como se muestra a continuación, también se proporcionan métodos de utilidad que admiten la personalización de recorridos de finalización. Sin embargo, dado que CountedCompleters solo proporciona mecanismos de sincronización básicos, puede resultar útil crear subclases abstractas adicionales que mantengan vínculos, campos y métodos de soporte técnico adicionales adecuados para un conjunto de usos relacionados.
Una clase CountedCompleter concreta debe definir el método #compute, que debe en la mayoría de los casos (como se muestra a continuación), invocar tryComplete() una vez antes de devolver. La clase también puede invalidar opcionalmente el método #onCompletion(CountedCompleter) para realizar una acción tras la finalización normal y el método #onExceptionalCompletion(Throwable, CountedCompleter) para realizar una acción en cualquier excepción.
CountedCompleters suele no dar resultados, en cuyo caso se declaran normalmente como CountedCompleter<Void>y siempre devolverán null como valor de resultado. En otros casos, debe invalidar el método #getRawResult para proporcionar un resultado de join(), invoke()los métodos relacionados y . En general, este método debe devolver el valor de un campo (o una función de uno o varios campos) del objeto CountedCompleter que contiene el resultado tras la finalización. El método #setRawResult de forma predeterminada no desempeña ningún rol en CountedCompleters. Es posible, pero rara vez aplicable, invalidar este método para mantener otros objetos o campos que contengan datos de resultados.
Un CountedCompleter que no tiene un completor (es decir, uno para el que #getCompleter devuelve null) se puede usar como forkJoinTask normal con esta funcionalidad agregada. Sin embargo, cualquier completador que, a su vez, tiene otro completor solo sirve como asistente interno para otros cálculos, por lo que su propio estado de tarea (como se indica en métodos como ForkJoinTask#isDone) es arbitrario; este estado solo cambia tras invocaciones explícitas de #complete, ForkJoinTask#cancelForkJoinTask#completeExceptionally(Throwable) o tras la finalización excepcional del método compute. Tras una finalización excepcional, la excepción se puede retransmitir al completador de una tarea (y su completador, etc.), si existe una y no se ha completado de otro modo. Del mismo modo, la cancelación de un countedCompleter interno solo tiene un efecto local en ese completador, por lo que no suele ser útil.
<b>Usos de ejemplo.</b>
<b>Descomposición recursiva en paralelo.</b> CountedCompleters se puede organizar en árboles similares a los usados con RecursiveActions, aunque las construcciones implicadas en su configuración suelen variar. Aquí, el completador de cada tarea es su elemento primario en el árbol de cálculo. Aunque implican un poco más de contabilidad, CountedCompleters puede ser mejores opciones al aplicar una operación posiblemente lenta (que no se puede subdividir aún más) a cada elemento de una matriz o colección; especialmente cuando la operación tarda mucho tiempo en completarse para algunos elementos que otros, ya sea debido a una variación intrínseca (por ejemplo, E/S) o efectos auxiliares, como la recolección de elementos no utilizados. Dado que CountedCompleters proporciona sus propias continuaciones, otras tareas no necesitan bloquear la espera para realizarlas.
Por ejemplo, esta es una versión inicial de un método de utilidad que usa la descomposición de división por dos recursivas para dividir el trabajo en partes únicas (tareas hoja). Incluso cuando el trabajo se divide en llamadas individuales, las técnicas basadas en árbol suelen ser preferibles para bifurcar directamente las tareas hoja, ya que reducen la comunicación entre subprocesos y mejoran el equilibrio de carga. En el caso recursivo, el segundo de cada par de subtareas para finalizar desencadena la finalización de su elemento primario (porque no se realiza ninguna combinación de resultados, la implementación predeterminada sin operación del método onCompletion no se invalida). El método de utilidad configura la tarea raíz e lo invoca (aquí, de forma implícita mediante ).ForkJoinPool#commonPool() Es sencillo y confiable (pero no óptimo) establecer siempre el recuento pendiente en el número de tareas secundarias y llamar tryComplete() inmediatamente antes de devolver.
{@code
public static <E> void forEach(E[] array, Consumer<E> action) {
class Task extends CountedCompleter<Void> {
final int lo, hi;
Task(Task parent, int lo, int hi) {
super(parent); this.lo = lo; this.hi = hi;
}
public void compute() {
if (hi - lo >= 2) {
int mid = (lo + hi) >>> 1;
// must set pending count before fork
setPendingCount(2);
new Task(this, mid, hi).fork(); // right child
new Task(this, lo, mid).fork(); // left child
}
else if (hi > lo)
action.accept(array[lo]);
tryComplete();
}
}
new Task(null, 0, array.length).invoke();
}}
Este diseño se puede mejorar al notar que, en el caso recursivo, la tarea no tiene nada que hacer después de bifurcar su tarea derecha, por lo que puede invocar directamente su tarea izquierda antes de volver. (Este es un análogo de la extracción de recursividad de cola). Además, cuando la última acción de una tarea es bifurcar o invocar una subtarea (una llamada de cola), la llamada a tryComplete() se puede optimizar, a costa de hacer que el recuento pendiente se vea "desactivado por uno".
{@code
public void compute() {
if (hi - lo >= 2) {
int mid = (lo + hi) >>> 1;
setPendingCount(1); // looks off by one, but correct!
new Task(this, mid, hi).fork(); // right child
new Task(this, lo, mid).compute(); // direct invoke
} else {
if (hi > lo)
action.accept(array[lo]);
tryComplete();
}
}}
Como optimización adicional, observe que la tarea izquierda ni siquiera existe. En lugar de crear uno nuevo, podemos seguir usando la tarea original y agregar un recuento pendiente para cada bifurcación. Además, dado que ninguna tarea de este árbol implementa un #onCompletion(CountedCompleter) método, tryComplete se puede reemplazar por #propagateCompletion.
{@code
public void compute() {
int n = hi - lo;
for (; n >= 2; n /= 2) {
addToPendingCount(1);
new Task(this, lo + n/2, lo + n).fork();
}
if (n > 0)
action.accept(array[lo]);
propagateCompletion();
}}
Cuando se pueden calcular previamente los recuentos pendientes, se pueden establecer en el constructor:
{@code
public static <E> void forEach(E[] array, Consumer<E> action) {
class Task extends CountedCompleter<Void> {
final int lo, hi;
Task(Task parent, int lo, int hi) {
super(parent, 31 - Integer.numberOfLeadingZeros(hi - lo));
this.lo = lo; this.hi = hi;
}
public void compute() {
for (int n = hi - lo; n >= 2; n /= 2)
new Task(this, lo + n/2, lo + n).fork();
action.accept(array[lo]);
propagateCompletion();
}
}
if (array.length > 0)
new Task(null, 0, array.length).invoke();
}}
Las optimizaciones adicionales de estas clases pueden implicar clases especializadas para pasos hoja, subdividir por ejemplo, cuatro, en lugar de dos por iteración, y usar un umbral adaptable en lugar de subdividir siempre a elementos únicos.
<b>Buscar.</b> Un árbol de CountedCompleters puede buscar un valor o una propiedad en diferentes partes de una estructura de datos y notificar un resultado en cuanto java.util.concurrent.atomic.AtomicReference AtomicReference se encuentre uno. Los demás pueden sondear el resultado para evitar el trabajo innecesario. (Además, puede #cancel cancelar otras tareas, pero normalmente es más sencillo y eficaz dejarles notar que el resultado se establece y, si es así, omite más el procesamiento). Ilustrando de nuevo con una matriz mediante particiones completas (de nuevo, en la práctica, las tareas hoja casi siempre procesarán más de un elemento):
{@code
class Searcher<E> extends CountedCompleter<E> {
final E[] array; final AtomicReference<E> result; final int lo, hi;
Searcher(CountedCompleter<?> p, E[] array, AtomicReference<E> result, int lo, int hi) {
super(p);
this.array = array; this.result = result; this.lo = lo; this.hi = hi;
}
public E getRawResult() { return result.get(); }
public void compute() { // similar to ForEach version 3
int l = lo, h = hi;
while (result.get() == null && h >= l) {
if (h - l >= 2) {
int mid = (l + h) >>> 1;
addToPendingCount(1);
new Searcher(this, array, result, mid, h).fork();
h = mid;
}
else {
E x = array[l];
if (matches(x) && result.compareAndSet(null, x))
quietlyCompleteRoot(); // root task is now joinable
break;
}
}
tryComplete(); // normally complete whether or not found
}
boolean matches(E e) { ... } // return true if found
public static <E> E search(E[] array) {
return new Searcher<E>(null, array, new AtomicReference<E>(), 0, array.length).invoke();
}
}}
En este ejemplo, así como otros en los que las tareas no tienen ningún otro efecto excepto para compareAndSet un resultado común, la invocación incondicional final de tryComplete podría hacerse condicional (if (result.get() == null) tryComplete();) porque no se requiere ningún mantenimiento adicional para administrar finalizaciones una vez completada la tarea raíz.
<b>Subtareas de grabación.</b> Tareas CountedCompleter que combinan resultados de varias subtareas normalmente necesitan tener acceso a estos resultados en el método #onCompletion(CountedCompleter). Como se muestra en la siguiente clase (que realiza una forma simplificada de asignación y reducción en la que las asignaciones y reducciones son de tipo E), una manera de hacerlo en los diseños de división y conquista es hacer que cada subtarea registre su elemento relacionado, de modo que se pueda tener acceso a él en el método onCompletion. Esta técnica se aplica a las reducciones en las que no importa el orden de combinación de resultados izquierdo y derecho; las reducciones ordenadas requieren designaciones explícitas de izquierda/derecha. También se pueden aplicar variantes de otras optimizaciones que se ven en los ejemplos anteriores.
{@code
class MyMapper<E> { E apply(E v) { ... } }
class MyReducer<E> { E apply(E x, E y) { ... } }
class MapReducer<E> extends CountedCompleter<E> {
final E[] array; final MyMapper<E> mapper;
final MyReducer<E> reducer; final int lo, hi;
MapReducer<E> sibling;
E result;
MapReducer(CountedCompleter<?> p, E[] array, MyMapper<E> mapper,
MyReducer<E> reducer, int lo, int hi) {
super(p);
this.array = array; this.mapper = mapper;
this.reducer = reducer; this.lo = lo; this.hi = hi;
}
public void compute() {
if (hi - lo >= 2) {
int mid = (lo + hi) >>> 1;
MapReducer<E> left = new MapReducer(this, array, mapper, reducer, lo, mid);
MapReducer<E> right = new MapReducer(this, array, mapper, reducer, mid, hi);
left.sibling = right;
right.sibling = left;
setPendingCount(1); // only right is pending
right.fork();
left.compute(); // directly execute left
}
else {
if (hi > lo)
result = mapper.apply(array[lo]);
tryComplete();
}
}
public void onCompletion(CountedCompleter<?> caller) {
if (caller != this) {
MapReducer<E> child = (MapReducer<E>)caller;
MapReducer<E> sib = child.sibling;
if (sib == null || sib.result == null)
result = child.result;
else
result = reducer.apply(child.result, sib.result);
}
}
public E getRawResult() { return result; }
public static <E> E mapReduce(E[] array, MyMapper<E> mapper, MyReducer<E> reducer) {
return new MapReducer<E>(null, array, mapper, reducer,
0, array.length).invoke();
}
}}
Aquí, el método onCompletion toma una forma común a muchos diseños de finalización que combinan resultados. Este método de estilo de devolución de llamada se desencadena una vez por tarea, en cualquiera de los dos contextos diferentes en los que el recuento pendiente es, o se convierte, cero: (1) por una tarea en sí, si su recuento pendiente es cero tras la invocación de tryComplete, o (2) por cualquiera de sus subtareas cuando completan y decreen el recuento pendiente en cero. El caller argumento distingue los casos. La mayoría de las veces, cuando el autor de la llamada es this, no es necesario realizar ninguna acción. De lo contrario, se puede usar el argumento llamador (normalmente a través de una conversión) para proporcionar un valor (o vínculos a otros valores) que se van a combinar. Suponiendo el uso adecuado de recuentos pendientes, las acciones dentro onCompletion se producen (una vez) tras la finalización de una tarea y sus subtareas. No se requiere ninguna sincronización adicional dentro de este método para garantizar la seguridad de subprocesos de los accesos a los campos de esta tarea u otras tareas completadas.
<b>Recorridos de finalización.</b> Si el uso onCompletion de para procesar finalizaciones es inaplicable o inconveniente, puede usar métodos #firstComplete y #nextComplete crear recorridos personalizados. Por ejemplo, para definir un MapReducer que solo divide las tareas a la derecha en forma del tercer ejemplo de ForEach, las finalizaciones deben reducirse de forma cooperativa a lo largo de vínculos de subtarea no agotados, que se pueden hacer de la siguiente manera:
{@code
class MapReducer<E> extends CountedCompleter<E> { // version 2
final E[] array; final MyMapper<E> mapper;
final MyReducer<E> reducer; final int lo, hi;
MapReducer<E> forks, next; // record subtask forks in list
E result;
MapReducer(CountedCompleter<?> p, E[] array, MyMapper<E> mapper,
MyReducer<E> reducer, int lo, int hi, MapReducer<E> next) {
super(p);
this.array = array; this.mapper = mapper;
this.reducer = reducer; this.lo = lo; this.hi = hi;
this.next = next;
}
public void compute() {
int l = lo, h = hi;
while (h - l >= 2) {
int mid = (l + h) >>> 1;
addToPendingCount(1);
(forks = new MapReducer(this, array, mapper, reducer, mid, h, forks)).fork();
h = mid;
}
if (h > l)
result = mapper.apply(array[l]);
// process completions by reducing along and advancing subtask links
for (CountedCompleter<?> c = firstComplete(); c != null; c = c.nextComplete()) {
for (MapReducer t = (MapReducer)c, s = t.forks; s != null; s = t.forks = s.next)
t.result = reducer.apply(t.result, s.result);
}
}
public E getRawResult() { return result; }
public static <E> E mapReduce(E[] array, MyMapper<E> mapper, MyReducer<E> reducer) {
return new MapReducer<E>(null, array, mapper, reducer,
0, array.length, null).invoke();
}
}}
<b>Desencadenadores.</b> Algunos CountedCompleters nunca se bifurcan, sino que sirven como bits de fontanería en otros diseños; incluidos aquellos en los que la finalización de una o varias tareas asincrónicas desencadena otra tarea asincrónica. Por ejemplo:
{@code
class HeaderBuilder extends CountedCompleter<...> { ... }
class BodyBuilder extends CountedCompleter<...> { ... }
class PacketSender extends CountedCompleter<...> {
PacketSender(...) { super(null, 1); ... } // trigger on second completion
public void compute() { } // never called
public void onCompletion(CountedCompleter<?> caller) { sendPacket(); }
}
// sample use:
PacketSender p = new PacketSender();
new HeaderBuilder(p, ...).fork();
new BodyBuilder(p, ...).fork();}
Agregado en la versión 1.8.
Documentación de Java para java.util.concurrent.CountedCompleter.
Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el proyecto de código abierto de Android y se usan según los términos descritos en la licencia de atribución de Creative Commons 2.5.
Constructores
| CountedCompleter() |
Crea un nuevo CountedCompleter sin completador y un recuento inicial pendiente de cero. |
| CountedCompleter(CountedCompleter) |
Crea un nuevo CountedCompleter con el completador especificado y un recuento inicial pendiente de cero. |
| CountedCompleter(CountedCompleter, Int32) |
Crea un nuevo countedCompleter con el completador especificado y el recuento pendiente inicial. |
| CountedCompleter(IntPtr, JniHandleOwnership) |
con |
Propiedades
| Class |
Devuelve la clase en tiempo de ejecución de este |
| Completer |
Devuelve el completador establecido en el constructor de esta tarea, o |
| Exception |
Devuelve la excepción producida por el cálculo base, o si |
| ForkJoinTaskTag |
Devuelve la etiqueta de esta tarea. (Heredado de ForkJoinTask) |
| Handle |
Identificador de la instancia de Android subyacente. (Heredado de Object) |
| IsCancelled |
Devuelve |
| IsCompletedAbnormally |
Devuelve |
| IsCompletedNormally |
Devuelve |
| IsDone |
Devuelve |
| JniIdentityHashCode |
con |
| JniPeerMembers |
con |
| PeerReference |
con |
| PendingCount |
Devuelve el recuento pendiente actual. -o bien- Establece el recuento pendiente en el valor especificado. |
| RawRawResult |
Devuelve el resultado devuelto por Join(), incluso si esta tarea se completó de forma anómala o |
| RawResult |
Devuelve el resultado del cálculo. |
| Root |
Devuelve la raíz del cálculo actual; Yo. |
| ThresholdClass |
con |
| ThresholdType |
con |
Métodos
| AddToPendingCount(Int32) |
Agrega (de forma atómica) el valor especificado al recuento pendiente. |
| Cancel(Boolean) |
Intenta cancelar la ejecución de esta tarea. (Heredado de ForkJoinTask) |
| Clone() |
Crea y devuelve una copia de este objeto. (Heredado de Object) |
| CompareAndSetForkJoinTaskTag(Int16, Int16) |
Establece condicionalmente el valor de etiqueta de esta tarea de forma atómica. (Heredado de ForkJoinTask) |
| CompareAndSetPendingCount(Int32, Int32) |
Establece (de forma atómica) el recuento pendiente en el recuento especificado solo si actualmente contiene el valor esperado especificado. |
| Complete(Object) |
Independientemente del recuento pendiente, invoca |
| CompleteExceptionally(Throwable) |
Completa esta tarea de forma anómala y, si aún no se ha anulado o cancelado, hace que inicie la excepción dada en |
| Compute() |
El cálculo principal realizado por esta tarea. |
| DecrementPendingCountUnlessZero() |
Si el recuento pendiente es distinto de cero, (atómicamente) lo disminuye. |
| Dispose() |
con |
| Dispose(Boolean) |
con |
| Equals(Object) |
Indica si algún otro objeto es "igual a" este. (Heredado de Object) |
| Exec() |
Implementa convenciones de ejecución para CountedCompleters. |
| FirstComplete() |
Si el recuento pendiente de esta tarea es cero, devuelve esta tarea; de lo contrario, disminuye su recuento pendiente y devuelve |
| Fork() |
Organiza para ejecutar de forma asincrónica esta tarea en el grupo en el que se ejecuta la tarea actual, si procede, o usando si |
| Get() |
Espera si es necesario para que se complete el cálculo y, a continuación, recupera su resultado. (Heredado de ForkJoinTask) |
| Get(Int64, TimeUnit) |
Espera si es necesario para que el cálculo se complete como máximo y, a continuación, recupera su resultado, si está disponible. (Heredado de ForkJoinTask) |
| GetHashCode() |
Devuelve un valor de código hash del objeto. (Heredado de Object) |
| HelpComplete(Int32) |
Si esta tarea no se ha completado, intenta procesar como máximo el número dado de otras tareas sin procesar para las que esta tarea se encuentra en la ruta de acceso de finalización, si se sabe que existe alguna. |
| Invoke() |
Comienza a realizar esta tarea, espera su finalización si es necesario y devuelve su resultado, o inicia una (desactivada) |
| JavaFinalize() |
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) |
| Join() |
Devuelve el resultado del cálculo cuando #isDone se realiza. (Heredado de ForkJoinTask) |
| NextComplete() |
Si esta tarea no tiene un completador, invoca |
| 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) |
| OnCompletion(CountedCompleter) |
Realiza una acción cuando se invoca el método |
| OnExceptionalCompletion(Throwable, CountedCompleter) |
Realiza una acción cuando se invoca al método |
| PropagateCompletion() |
Equivalente a |
| QuietlyComplete() |
Completa esta tarea normalmente sin establecer un valor. (Heredado de ForkJoinTask) |
| QuietlyCompleteRoot() |
Equivalente a |
| QuietlyInvoke() |
Comienza a realizar esta tarea y espera su finalización si es necesario, sin devolver su resultado ni producir su excepción. (Heredado de ForkJoinTask) |
| QuietlyJoin() |
Combina esta tarea, sin devolver su resultado ni producir su excepción. (Heredado de ForkJoinTask) |
| Reinitialize() |
Restablece el estado de contabilidad interno de esta tarea, lo que permite un posterior |
| SetForkJoinTaskTag(Int16) |
Establece de forma atómica el valor de etiqueta de esta tarea y devuelve el valor anterior. (Heredado de ForkJoinTask) |
| SetHandle(IntPtr, JniHandleOwnership) |
Establece la propiedad Handle. (Heredado de Object) |
| SetRawResult(Object) |
Un método que da como resultado CountedCompleters puede usar opcionalmente para ayudar a mantener los datos de resultados. |
| ToArray<T>() |
con |
| ToString() |
Devuelve una representación de cadena del objeto. (Heredado de Object) |
| TryComplete() |
Si el recuento pendiente es distinto de cero, disminuye el recuento; De lo contrario, invoca |
| TryUnfork() |
Intenta anular la programación de esta tarea para su ejecución. (Heredado de ForkJoinTask) |
| UnregisterFromRuntime() |
con |
| Wait() |
Hace que el subproceso actual espere hasta que se despierta, normalmente por ser em notificado/em> o <em>interrumpido</em>.<>< (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) |
| 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) |
Implementaciones de interfaz explícitas
| IJavaPeerable.Disposed() |
con |
| IJavaPeerable.DisposeUnlessReferenced() |
con |
| IJavaPeerable.Finalized() |
con |
| IJavaPeerable.JniManagedPeerState |
con |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
con |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
con |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
con |
Métodos de extensión
| JavaCast<TResult>(IJavaObject) |
Realiza una conversión de tipos comprobados en tiempo de ejecución de Android. |
| JavaCast<TResult>(IJavaObject) |
con |
| GetJniTypeName(IJavaPeerable) |
con |
| GetAsync(IFuture) |
con |
| GetAsync(IFuture, Int64, TimeUnit) |
con |