MethodHandle.AsSpreader Método

Definição

Namespace:: Java.Lang.Invoke

Assembly:: Mono.Android.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Sobrecargas

Nome	Description
AsSpreader(Class, Int32)	Faz um <>identificador de método em array-spreading</em>, que aceita um argumento de matriz à direita e espalha seus elementos como argumentos posicionais.
AsSpreader(Int32, Class, Int32)	Faz um <>identificador de método em array-spreading</em>, que aceita um argumento de matriz em uma determinada posição e espalha seus elementos como argumentos posicionais no lugar da matriz.

AsSpreader(Class, Int32)

Faz um <>identificador de método em array-spreading</em>, que aceita um argumento de matriz à direita e espalha seus elementos como argumentos posicionais.

[Android.Runtime.Register("asSpreader", "(Ljava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_Ljava_lang_Class_IHandler", ApiSince=26)]
public virtual Java.Lang.Invoke.MethodHandle? AsSpreader(Java.Lang.Class? arrayType, int arrayLength);

[<Android.Runtime.Register("asSpreader", "(Ljava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_Ljava_lang_Class_IHandler", ApiSince=26)>]
abstract member AsSpreader : Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle
override this.AsSpreader : Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle

Parâmetros

arrayType: Class

geralmente Object[], o tipo do argumento de matriz do qual extrair os argumentos de propagação

arrayLength: Int32

o número de argumentos a serem distribuídos de um argumento de matriz de entrada

Retornos

MethodHandle

um novo identificador de método que espalha seu argumento de matriz final, antes de chamar o identificador de método original

Atributos: RegisterAttribute

Comentários

Faz um <>identificador de método em array-spreading</em>, que aceita um argumento de matriz à direita e espalha seus elementos como argumentos posicionais. O novo identificador de método adapta, como destino, o identificador do método atual. O tipo do adaptador será o mesmo que o tipo do destino, exceto que os parâmetros finais arrayLength do tipo do destino são substituídos por um único parâmetro de matriz do tipo arrayType.

Se o tipo de elemento de matriz for diferente de qualquer um dos tipos de argumento correspondentes no destino original, o destino original será adaptado para levar os elementos da matriz diretamente, como se fosse por uma chamada para #asType asType.

Quando chamado, o adaptador substitui um argumento de matriz à direita pelos elementos da matriz, cada um como seu próprio argumento para o destino. (A ordem dos argumentos é preservada.) Eles são convertidos em par por conversão e/ou unboxing para os tipos dos parâmetros à direita do destino. Por fim, o destino é chamado. O que o destino eventualmente retorna é retornado inalterado pelo adaptador.

Antes de chamar o destino, o adaptador verifica se a matriz contém elementos exatamente suficientes para fornecer uma contagem de argumentos correta para o identificador do método de destino. (A matriz também pode ser nula quando zero elementos são necessários.)

Quando o adaptador é chamado, o comprimento do argumento fornecido array é consultado como se fosse por array.length ou arraylength bytecode. Se o adaptador aceitar um argumento de matriz à direita de comprimento zero, o argumento fornecido array poderá ser uma matriz de comprimento zero ou null; caso contrário, o adaptador gerará um NullPointerException se a matriz for null e gerará um IllegalArgumentException se a matriz não tiver o número correto de elementos.

Aqui estão alguns exemplos simples de identificadores de método de propagação de matriz: <blockquote>

{@code
            MethodHandle equals = publicLookup()
              .findVirtual(String.class, "equals", methodType(boolean.class, Object.class));
            assert( (boolean) equals.invokeExact("me", (Object)"me"));
            assert(!(boolean) equals.invokeExact("me", (Object)"thee"));
            // spread both arguments from a 2-array:
            MethodHandle eq2 = equals.asSpreader(Object[].class, 2);
            assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" }));
            assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" }));
            // try to spread from anything but a 2-array:
            for (int n = 0; n <= 10; n++) {
              Object[] badArityArgs = (n == 2 ? new Object[0] : new Object[n]);
              try { assert((boolean) eq2.invokeExact(badArityArgs) && false); }
              catch (IllegalArgumentException ex) { } // OK
            }
            // spread both arguments from a String array:
            MethodHandle eq2s = equals.asSpreader(String[].class, 2);
            assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" }));
            assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" }));
            // spread second arguments from a 1-array:
            MethodHandle eq1 = equals.asSpreader(Object[].class, 1);
            assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" }));
            assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" }));
            // spread no arguments from a 0-array or null:
            MethodHandle eq0 = equals.asSpreader(Object[].class, 0);
            assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0]));
            assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null));
            // asSpreader and asCollector are approximate inverses:
            for (int n = 0; n <= 2; n++) {
                for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) {
                    MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n);
                    assert( (boolean) equals2.invokeWithArguments("me", "me"));
                    assert(!(boolean) equals2.invokeWithArguments("me", "thee"));
                }
            }
            MethodHandle caToString = publicLookup()
              .findStatic(Arrays.class, "toString", methodType(String.class, char[].class));
            assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray()));
            MethodHandle caString3 = caToString.asCollector(char[].class, 3);
            assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C'));
            MethodHandle caToString2 = caString3.asSpreader(char[].class, 2);
            assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray()));
            }

</blockquote>

Documentação Java para java.lang.invoke.MethodHandle.asSpreader(java.lang.Class<?>, int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.

Aplica-se a

AsSpreader(Int32, Class, Int32)

Faz um <>identificador de método em array-spreading</em>, que aceita um argumento de matriz em uma determinada posição e espalha seus elementos como argumentos posicionais no lugar da matriz.

[Android.Runtime.Register("asSpreader", "(ILjava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_ILjava_lang_Class_IHandler", ApiSince=33)]
public virtual Java.Lang.Invoke.MethodHandle? AsSpreader(int spreadArgPos, Java.Lang.Class? arrayType, int arrayLength);

[<Android.Runtime.Register("asSpreader", "(ILjava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_ILjava_lang_Class_IHandler", ApiSince=33)>]
abstract member AsSpreader : int * Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle
override this.AsSpreader : int * Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle

Parâmetros

spreadArgPos: Int32

a posição (índice baseado em zero) na lista de argumentos na qual a propagação deve ser iniciada.

arrayType: Class

geralmente Object[], o tipo do argumento de matriz do qual extrair os argumentos de propagação

arrayLength: Int32

o número de argumentos a serem distribuídos de um argumento de matriz de entrada

Retornos

MethodHandle

um novo identificador de método que espalha um argumento de matriz em uma determinada posição, antes de chamar o identificador de método original

Atributos: RegisterAttribute

Comentários

Faz um <>identificador de método em array-spreading</em>, que aceita um argumento de matriz em uma determinada posição e espalha seus elementos como argumentos posicionais no lugar da matriz. O novo identificador de método adapta, como destino, o identificador do método atual. O tipo do adaptador será o mesmo que o tipo do destino, exceto que os arrayLength parâmetros do tipo do destino, começando na posição spreadArgPosbaseada em zero, serão substituídos por um único parâmetro de matriz do tipo arrayType.

Esse método se comporta muito parecido #asSpreader(Class, int), mas aceita um argumento adicional spreadArgPos para indicar em qual posição na lista de parâmetros a propagação deve ocorrer.

Adicionado em 9.

Documentação Java para java.lang.invoke.MethodHandle.asSpreader(int, java.lang.Class<?>, int).

Aplica-se a