Func<T1,T2,T3,T4,TResult> Delegát

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: System.Core.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Zapouzdří metodu se čtyřmi parametry a vrátí hodnotu typu určeného parametrem TResult .

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

Parametry typu

T1

Typ prvního parametru metody, který tento delegát zapouzdřuje.

Tento parametr typu je kontravariantní. To znamená, že můžete použít buď zadaný typ, nebo libovolný typ, který je méně odvozený. Další informace o kovarianci a kontravarianci najdete v tématu popisujícím kovarianci a kontravarianci u parametrického polymorfismu.

T2

Typ druhého parametru metody, který tento delegát zapouzdřuje.

T3

Typ třetího parametru metody, který tento delegát zapouzdřuje.

T4

Typ čtvrtého parametru metody, který tento delegát zapouzdřuje.

TResult

Typ návratové hodnoty metody, kterou tento delegát zapouzdřuje.

Tento parametr typu je kovariantní. To znamená, že můžete použít buď zadaný typ, nebo libovolný typ, který je více odvozený. Další informace o kovarianci a kontravarianci najdete v tématu popisujícím kovarianci a kontravarianci u parametrického polymorfismu.

Parametry

arg1: T1

První parametr metody, kterou tento delegát zapouzdřuje.

arg2: T2

Druhý parametr metody, kterou tento delegát zapouzdřuje.

arg3: T3

Třetí parametr metody, kterou tento delegát zapouzdřuje.

arg4: T4

Čtvrtý parametr metody, kterou tento delegát zapouzdřuje.

Návratová hodnota

TResult

Návratová hodnota metody, kterou tento delegát zapouzdřuje.

Příklady

Následující příklad ukazuje, jak deklarovat a používat delegáta Func<T1,T2,TResult> . Tento příklad deklaruje proměnnou Func<T1,T2,TResult> a přiřadí ji výraz lambda, který přebírá String hodnotu a Int32 hodnotu jako parametry. Výraz lambda vrátí true , pokud je délka String parametru rovna hodnotě parametru Int32 . Delegát, který zapouzdřuje tuto metodu, se následně používá v dotazu k filtrování řetězců v poli řetězců.

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

Poznámky

Tento delegát můžete použít k reprezentaci metody, která se dá předat jako parametr, aniž byste explicitně deklarovali vlastního delegáta. Zapouzdřená metoda musí odpovídat podpisu metody definované tímto delegátem. To znamená, že zapouzdřená metoda musí mít čtyři parametry, z nichž každá je předána hodnotou a že musí vrátit hodnotu.

Poznámka

Chcete-li odkazovat na metodu, která má čtyři parametry a vrací void (unitv jazyce F#) (nebo v Visual Basic, která je deklarována jako místo Sub jako ), Functionpoužijte místo toho obecný Action<T1,T2,T3,T4> delegát.

Při použití Func<T1,T2,T3,T4,TResult> delegáta nemusíte explicitně definovat delegáta, který zapouzdřuje metodu se čtyřmi parametry. Například následující kód explicitně deklaruje obecný delegát pojmenovaný Searcher a přiřadí odkaz na metodu IndexOf ke své instanci delegáta.

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

Následující příklad tento kód zjednodušuje vytvořením instance delegáta Func<T1,T2,T3,T4,TResult> místo explicitního definování nového delegáta a přiřazením pojmenované metody k němu.

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

Delegáta můžete použít Func<T1,T2,T3,T4,TResult> s anonymními metodami v jazyce C#, jak je znázorněno v následujícím příkladu. (Úvod k anonymním metodám naleznete v tématu Anonymní metody.)

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);
   }
}

Výraz lambda můžete také přiřadit delegátu Func<T1,T2,TResult> , jak je znázorněno v následujícím příkladu. (Úvod k výrazům lambda najdete v tématu Výrazy lambda (VB), výrazy lambda (C#) a výrazy lambda (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

Základní typ výrazu lambda je jedním z obecných Func delegátů. To umožňuje předat výraz lambda jako parametr, aniž byste ho explicitně přiřadili delegátu. Zejména proto, že mnoho metod typů v System.Linq oboru názvů má Func parametry, můžete tyto metody předat výraz lambda, aniž byste explicitně vytvořili instanci delegáta Func .

Metody rozšíření

GetMethodInfo(Delegate)

Získá objekt, který představuje metodu reprezentovanou zadaným delegátem.

Platí pro