MethodHandle.AsSpreader Método

Referência

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

AsSpreader(Class, Int32)	Cria 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)	Cria 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)

Cria 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 espalhados 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

Cria 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 seu destino, o identificador de 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 receber os elementos de matriz diretamente, como se fosse 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 pares por transmissão e/ou unboxing para os tipos dos parâmetros de rastreamento do alvo. Por fim, o alvo é chamado. O que o destino eventualmente retorna é retornado inalterado pelo adaptador.

Antes de chamar o destino, o adaptador verifica se a matriz contém exatamente elementos 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 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 lançará um NullPointerException se a matriz for null e lançará 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 usado de acordo com os termos descritos na Creative Commons 2.5 Attribution License.

Aplica-se a

AsSpreader(Int32, Class, Int32)

Cria 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 começar.

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 espalhados 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

Cria 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 seu destino, o identificador de 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, são substituídos por um único parâmetro de matriz do tipo arrayType.

Esse método se comporta muito como #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

Compartilhar via

MethodHandle.AsSpreader Método

Definição

Sobrecargas

AsSpreader(Class, Int32)

Parâmetros

Retornos

Comentários

Aplica-se a

AsSpreader(Int32, Class, Int32)

Parâmetros

Retornos

Comentários

Aplica-se a

Recursos adicionais