Func<T1,T2,T3,T4,TResult> Delegat

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: System.Core.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.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.

Kapselt eine Methode, die über vier Parameter verfügt und einen Wert des Typs zurückgibt, der durch den TResult-Parameter angegeben wird.

generic <typename T1, typename T2, typename T3, typename T4, typename TResult>
public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

public delegate TResult Func<in T1,in T2,in T3,in T4,out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

public delegate TResult Func<T1,T2,T3,T4,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

type Func<'T1, 'T2, 'T3, 'T4, 'Result> = delegate of 'T1 * 'T2 * 'T3 * 'T4 -> 'Result

Public Delegate Function Func(Of In T1, In T2, In T3, In T4, Out TResult)(arg1 As T1, arg2 As T2, arg3 As T3, arg4 As T4) As TResult

Public Delegate Function Func(Of T1, T2, T3, T4, TResult)(arg1 As T1, arg2 As T2, arg3 As T3, arg4 As T4) As TResult

Typparameter

T1

Der Typ des ersten Parameters der Methode, die dieser Delegat kapselt.

Dieser Typparameter ist kontravariant. Das bedeutet, dass Sie entweder den angegebenen Typ oder einen weniger abgeleiteten Typ verwenden können. Weitere Informationen zu Kovarianz und Kontravarianz finden Sie unter Kovarianz und Kontravarianz in Generics.

T2

Der Typ des zweiten Parameters der Methode, die dieser Delegat kapselt.

T3

Der Typ des dritten Parameters der Methode, die dieser Delegat kapselt.

T4

Der Typ des vierten Parameters der Methode, die dieser Delegat kapselt.

TResult

Der Typ des Rückgabewerts der Methode, die dieser Delegat kapselt.

Dieser Typparameter ist kovariant. Das bedeutet, dass Sie entweder den angegebenen Typ oder einen stärker abgeleiteten Typ verwenden können. Weitere Informationen zu Kovarianz und Kontravarianz finden Sie unter Kovarianz und Kontravarianz in Generics.

Parameter

arg1: T1

Der erste Parameter der Methode, die dieser Delegat kapselt.

arg2: T2

Der zweite Parameter der Methode, die dieser Delegat kapselt.

arg3: T3

Der dritte Parameter der Methode, die dieser Delegat kapselt.

arg4: T4

Der vierte Parameter der Methode, die dieser Delegat kapselt.

Rückgabewert

TResult

Der Rückgabewert der Methode, die dieser Delegat kapselt.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Sie eine Func<T1,T2,TResult> Stellvertretung deklarieren und verwenden. In diesem Beispiel wird eine Func<T1,T2,TResult> Variable deklariert und einem Lambdaausdruck zugewiesen, der einen Wert und Int32 einen String Wert als Parameter verwendet. Der Lambdaausdruck gibt zurück true , wenn die Länge String des Parameters gleich dem Wert des Int32 Parameters ist. Der Stellvertretung, der diese Methode kapselt, wird anschließend in einer Abfrage verwendet, um Zeichenfolgen in einem Array von Zeichenfolgen zu filtern.

using System;
using System.Collections.Generic;
using System.Linq;

public class Func3Example
{
   public static void Main()
   {
      Func<String, int, bool> predicate = (str, index) => str.Length == index;

      String[] words = { "orange", "apple", "Article", "elephant", "star", "and" };
      IEnumerable<String> aWords = words.Where(predicate).Select(str => str);

      foreach (String word in aWords)
         Console.WriteLine(word);
   }
}

open System
open System.Linq

let predicate = Func<string, int, bool>(fun str index -> str.Length = index)

let words = [ "orange"; "apple"; "Article"; "elephant"; "star"; "and" ]
let aWords = words.Where predicate

for word in aWords do
    printfn $"{word}"

Imports System.Collections.Generic
Imports System.Linq

Public Module Func3Example

   Public Sub Main()
      Dim predicate As Func(Of String, Integer, Boolean) = Function(str, index) str.Length = index

      Dim words() As String = { "orange", "apple", "Article", "elephant", "star", "and" }
      Dim aWords As IEnumerable(Of String) = words.Where(predicate)

      For Each word As String In aWords
         Console.WriteLine(word)
      Next   
   End Sub
End Module

Hinweise

Sie können diese Stellvertretung verwenden, um eine Methode darzustellen, die als Parameter übergeben werden kann, ohne explizit eine benutzerdefinierte Stellvertretung zu deklarieren. Die gekapselte Methode muss der Von diesem Stellvertretung definierten Methodensignatur entsprechen. Dies bedeutet, dass die gekapselte Methode vier Parameter aufweisen muss, die jeweils nach Wert übergeben werden, und dass sie einen Wert zurückgeben muss.

Hinweis

Verwenden Sie stattdessen die generische Action<T1,T2,T3,T4> Stellvertretung, um auf eine Methode zu verweisen, die vier Parameter enthält undunit void (in F#) oder in Visual Basic zurückgibt.Sub Function

Wenn Sie die Func<T1,T2,T3,T4,TResult> Stellvertretung verwenden, müssen Sie keine Stellvertretung explizit definieren, die eine Methode mit vier Parametern kapselt. Der folgende Code deklariert beispielsweise explizit einen generischen Stellvertretungsnamen Searcher und weist der Methode einen Verweis auf die IndexOf Stellvertretungsinstanz zu.

using System;

delegate int Searcher(string searchString, int start, int count,
                         StringComparison type);

public class DelegateExample
{
   public static void Main()
   {
      string title = "The House of the Seven Gables";
      int position = 0;
      Searcher finder = title.IndexOf;
      do
      {
         int characters = title.Length - position;
         position = finder("the", position, characters,
                         StringComparison.InvariantCultureIgnoreCase);
         if (position >= 0)
         {
            position++;
            Console.WriteLine("'The' found at position {0} in {1}.",
                              position, title);
         }
      } while (position > 0);
   }
}

open System

type Searcher = delegate of (string * int * int * StringComparison) -> int

let title = "The House of the Seven Gables"
let finder = Searcher title.IndexOf
let mutable position = 0

while position > -1 do
    let characters = title.Length - position
    position <- 
        finder.Invoke("the", position, characters, StringComparison.InvariantCultureIgnoreCase)
    if position >= 0 then
        position <- position + 1
        printfn $"'The' found at position {position} in {title}."

Delegate Function Searcher(searchString As String, _
                           start As Integer,  _
                           count As Integer, _
                           type As StringComparison) As Integer

Module DelegateExample
   Public Sub Main()
      Dim title As String = "The House of the Seven Gables"
      Dim position As Integer = 0
      Dim finder As Searcher = AddressOf title.IndexOf
      Do
         Dim characters As Integer = title.Length - position
         position = finder("the", position, characters, _
                         StringComparison.InvariantCultureIgnoreCase) 
         If position >= 0 Then
            position += 1
            Console.WriteLine("'The' found at position {0} in {1}.", _
                              position, title)
         End If   
      Loop While position > 0   
   End Sub
End Module

Im folgenden Beispiel wird dieser Code vereinfacht, indem er die Stellvertretung instanziiert Func<T1,T2,T3,T4,TResult> , anstatt eine neue Stellvertretung explizit zu definieren und einer benannten Methode zuzuweisen.

using System;

public class DelegateExample
{
   public static void Main()
   {
      string title = "The House of the Seven Gables";
      int position = 0;
      Func<string, int, int, StringComparison, int> finder = title.IndexOf;
      do
      {
         int characters = title.Length - position;
         position = finder("the", position, characters,
                         StringComparison.InvariantCultureIgnoreCase);
         if (position >= 0)
         {
            position++;
            Console.WriteLine("'The' found at position {0} in {1}.",
                              position, title);
         }
      } while (position > 0);
   }
}

open System

let indexOf (s: string) s2 pos chars comparison =
    s.IndexOf(s2, pos, chars, comparison) 

let title = "The House of the Seven Gables"
let finder = Func<string, int, int, StringComparison, int>(indexOf title)
let mutable position = 0

while position > -1 do
    let characters = title.Length - position
    position <- 
        finder.Invoke("the", position, characters, StringComparison.InvariantCultureIgnoreCase)
    if position >= 0 then
        position <- position + 1
        printfn $"'The' found at position {position} in {title}."

Module DelegateExample
   Public Sub Main()
      Dim title As String = "The House of the Seven Gables"
      Dim position As Integer = 0
      Dim finder As Func(Of String, Integer, Integer, StringComparison, Integer) _
                    = AddressOf title.IndexOf
      Do
         Dim characters As Integer = title.Length - position
         position = finder("the", position, characters, _
                         StringComparison.InvariantCultureIgnoreCase) 
         If position >= 0 Then
            position += 1
            Console.WriteLine("'The' found at position {0} in {1}.", _
                              position, title)
         End If   
      Loop While position > 0   
   End Sub
End Module

Sie können die Stellvertretung mit anonymen Methoden in C# verwenden, wie das Func<T1,T2,T3,T4,TResult> folgende Beispiel veranschaulicht. (Eine Einführung in anonyme Methoden finden Sie unter Anonyme Methoden.)

using System;

public class DelegateExample
{
   public static void Main()
   {
      string title = "The House of the Seven Gables";
      int position = 0;
      Func<string, int, int, StringComparison, int> finder =
           delegate(string s, int pos, int chars, StringComparison type)
           { return title.IndexOf(s, pos, chars, type); };
      do
      {
         int characters = title.Length - position;
         position = finder("the", position, characters,
                         StringComparison.InvariantCultureIgnoreCase);
         if (position >= 0)
         {
            position++;
            Console.WriteLine("'The' found at position {0} in {1}.",
                              position, title);
         }
      } while (position > 0);
   }
}

Sie können auch einem Func<T1,T2,TResult> Stellvertretung einen Lambdaausdruck zuweisen, wie das folgende Beispiel veranschaulicht. (Eine Einführung in Lambda-Ausdrücke finden Sie unter Lambda-Ausdrücke (VB), Lambda-Ausdrücke (C#) und Lambda-Ausdrücke (F#).)

using System;

public class DelegateExample
{
   public static void Main()
   {
      string title = "The House of the Seven Gables";
      int position = 0;
      Func<string, int, int, StringComparison, int> finder =
           (s, pos, chars, type) => title.IndexOf(s, pos, chars, type);
      do
      {
         int characters = title.Length - position;
         position = finder("the", position, characters,
                         StringComparison.InvariantCultureIgnoreCase);
         if (position >= 0)
         {
            position++;
            Console.WriteLine("'The' found at position {0} in {1}.",
                              position, title);
         }
      } while (position > 0);
   }
}

open System

let title = "The House of the Seven Gables"

let finder =
    Func<string, int, int, StringComparison, int>(fun s pos chars typ -> title.IndexOf(s, pos, chars, typ))

let mutable position = 0

while position > -1 do
    let characters = title.Length - position
    position <- finder.Invoke("the", position, characters, StringComparison.InvariantCultureIgnoreCase)

    if position >= 0 then
        position <- position + 1
        printfn $"'The' found at position {position} in {title}."

Module DelegateExample
   Public Sub Main()
      Dim title As String = "The House of the Seven Gables"
      Dim position As Integer = 0
      Dim finder As Func(Of String, Integer, Integer, StringComparison, Integer) _
                    = Function(s, pos, chars, type) _
                    title.IndexOf(s, pos, chars, type)
      Do
         Dim characters As Integer = title.Length - position
         position = finder("the", position, characters, _
                         StringComparison.InvariantCultureIgnoreCase) 
         If position >= 0 Then
            position += 1
            Console.WriteLine("'The' found at position {0} in {1}.", _
                              position, title)
         End If   
      Loop While position > 0   
   End Sub
End Module

Der zugrunde liegende Typ eines Lambdaausdrucks ist eine der generischen Func Stellvertretungen. Dadurch kann ein Lambdaausdruck als Parameter übergeben werden, ohne ihn explizit einem Stellvertretung zuzuweisen. Insbesondere, da viele Typen im System.Linq Namespace Parameter haben Func , können Sie diese Methoden einen Lambdaausdruck übergeben, ohne eine Func Stellvertretung explizit instanziieren zu müssen.

Erweiterungsmethoden

GetMethodInfo(Delegate)

Ruft ein Objekt ab, das die Methode darstellt, die vom angegebenen Delegaten dargestellt wird.

Gilt für