MethodHandle.AsSpreader Methode

Referenz

Definition

Namespace:: Java.Lang.Invoke

Assembly:: Mono.Android.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Überlädt

AsSpreader(Class, Int32)	Macht einen <Em-Array-Spread></em-Methodenhandle>, der ein nachfolgendes Arrayargument akzeptiert und seine Elemente als Positionsargumente verteilt.
AsSpreader(Int32, Class, Int32)	Macht einen <Em>Array-Spread</Em-Methodenziehpunkt> , der ein Arrayargument an einer bestimmten Position akzeptiert und seine Elemente als Positionsargumente anstelle des Arrays verteilt.

AsSpreader(Class, Int32)

Macht einen <Em-Array-Spread></em-Methodenhandle>, der ein nachfolgendes Arrayargument akzeptiert und seine Elemente als Positionsargumente verteilt.

[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

Parameter

arrayType: Class

in der Regel Object[]der Typ des Arrayarguments, aus dem die Spread-Argumente extrahiert werden sollen

arrayLength: Int32

Die Anzahl der Argumente, die aus einem eingehenden Arrayargument verteilt werden sollen

Gibt zurück

MethodHandle

ein neues Methodenhandle, das sein endgültiges Arrayargument verteilt, bevor der ursprüngliche Methodenhandle aufgerufen wird

Attribute: RegisterAttribute

Hinweise

Macht einen <Em-Array-Spread></em-Methodenhandle>, der ein nachfolgendes Arrayargument akzeptiert und seine Elemente als Positionsargumente verteilt. Das neue Methodenhandle passt sich als Ziel an den aktuellen Methodenhandle an. Der Typ des Adapters entspricht dem Typ des Ziels, mit der Ausnahme, dass die endgültigen arrayLength Parameter des Zieltyps durch einen einzelnen Arrayparameter des Typs arrayTypeersetzt werden.

Wenn sich der Arrayelementtyp von einem der entsprechenden Argumenttypen im ursprünglichen Ziel unterscheidet, wird das ursprüngliche Ziel so angepasst, dass die Arrayelemente direkt übernommen werden, als ob durch einen Aufruf von #asType asType.

Wenn der Adapter aufgerufen wird, ersetzt der Adapter ein nachfolgendes Arrayargument durch die Elemente des Arrays, jedes als eigenes Argument für das Ziel. (Die Reihenfolge der Argumente wird beibehalten.) Sie werden gekoppelt durch Umwandlung und/oder Entboxung in die Typen der nachfolgenden Parameter des Ziels konvertiert. Schließlich wird das Ziel aufgerufen. Was das Ziel schließlich zurückgibt, wird vom Adapter unverändert zurückgegeben.

Vor dem Aufrufen des Ziels überprüft der Adapter, dass das Array genau genug Elemente enthält, um dem Zielmethodenhandle eine korrekte Argumentanzahl bereitzustellen. (Das Array kann auch null sein, wenn Nullelemente erforderlich sind.)

Wenn der Adapter aufgerufen wird, wird die Länge des angegebenen array Arguments abgefragt, als ob durch oder arraylength bytecodearray.length. Wenn der Adapter ein array-Argument der Länge Null akzeptiert, kann das angegebene array Argument entweder ein Array der Länge Null oder null; andernfalls löst der Adapter ein NullPointerException , wenn das Array vorhanden ist null , und löst ein IllegalArgumentException , wenn das Array nicht über die richtige Anzahl von Elementen verfügt.

Hier sind einige einfache Beispiele für Arrayverteilungsmethodenhandles: <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>

Java-Dokumentation für java.lang.invoke.MethodHandle.asSpreader(java.lang.Class<?>, int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die vom Android Open Source-Projekt erstellt und freigegeben werden und gemäß den in der Creative Commons 2.5 Attribution License beschriebenen Begriffen verwendet werden.

Gilt für:

AsSpreader(Int32, Class, Int32)

Macht einen <Em>Array-Spread</Em-Methodenziehpunkt> , der ein Arrayargument an einer bestimmten Position akzeptiert und seine Elemente als Positionsargumente anstelle des Arrays verteilt.

[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

Parameter

spreadArgPos: Int32

die Position (nullbasierter Index) in der Argumentliste, an der die Verbreitung beginnen soll.

arrayType: Class

in der Regel Object[]der Typ des Arrayarguments, aus dem die Spread-Argumente extrahiert werden sollen

arrayLength: Int32

Die Anzahl der Argumente, die aus einem eingehenden Arrayargument verteilt werden sollen

Gibt zurück

MethodHandle

ein neues Methodenhandle, das ein Arrayargument an einer bestimmten Position verteilt, bevor der ursprüngliche Methodenhandle aufgerufen wird

Attribute: RegisterAttribute

Hinweise

Macht einen <Em>Array-Spread</Em-Methodenziehpunkt> , der ein Arrayargument an einer bestimmten Position akzeptiert und seine Elemente als Positionsargumente anstelle des Arrays verteilt. Das neue Methodenhandle passt sich als Ziel an den aktuellen Methodenhandle an. Der Typ des Adapters entspricht dem Typ des Ziels, mit der Ausnahme, dass die arrayLength Parameter des Zieltyps, beginnend mit der nullbasierten Position spreadArgPos, durch einen einzelnen Arrayparameter des Typs arrayTypeersetzt werden.

Diese Methode verhält sich sehr ähnlich #asSpreader(Class, int), akzeptiert aber ein zusätzliches spreadArgPos Argument, um anzugeben, an welcher Position in der Parameterliste die Verbreitung stattfinden soll.

Hinzugefügt in 9.

Java-Dokumentation für java.lang.invoke.MethodHandle.asSpreader(int, java.lang.Class<?>, int).

Gilt für:

Freigeben über

MethodHandle.AsSpreader Methode

Definition

Überlädt

AsSpreader(Class, Int32)

Parameter

Gibt zurück

Hinweise

Gilt für:

AsSpreader(Int32, Class, Int32)

Parameter

Gibt zurück

Hinweise

Gilt für:

Zusätzliche Ressourcen