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

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

Function.cs

Zapouzdřuje metodu, která má tři parametry, a vrátí hodnotu typu určeného parametrem TResult .

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

public delegate TResult Func<in T1,in T2,in T3,out TResult>(T1 arg1, T2 arg2, T3 arg3) where T1 : allows ref struct where T2 : allows ref struct where T3 : allows ref struct where TResult : allows ref struct;

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

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

Parametry typu

T1

Typ prvního parametru metody, kterou 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.

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.

T3

Typ třetího parametru metody, kterou 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.

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.

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í jí 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žije 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 bez explicitního deklarování vlastního delegáta. Zapouzdřená metoda musí odpovídat podpisu metody definovanému tímto delegátem. To znamená, že zapouzdřená metoda musí mít tři parametry, z nichž každá je předána hodnotou a že musí vrátit hodnotu.

Note

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

Při použití Func<T1,T2,T3,TResult> delegáta nemusíte explicitně definovat delegáta, který zapouzdřuje metodu se třemi parametry. Například následující kód explicitně deklaruje obecný delegát pojmenovaný ParseNumber a přiřadí odkaz na metodu Parse jeho instanci delegáta.

using System;
using System.Globalization;

delegate T ParseNumber<T>(string input, NumberStyles styles,
                         IFormatProvider provider);

public class DelegateExample
{
   public static void Main()
   {
      string numericString = "-1,234";
      ParseNumber<int> parser = int.Parse;
      Console.WriteLine(parser(numericString,
                        NumberStyles.Integer | NumberStyles.AllowThousands,
                        CultureInfo.InvariantCulture));
   }
}

open System
open System.Globalization

type ParseNumber<'T> = delegate of (string * NumberStyles * IFormatProvider) -> 'T

let numericString = "-1,234"
let parser = ParseNumber<int> Int32.Parse

parser.Invoke(
    numericString,
    NumberStyles.Integer ||| NumberStyles.AllowThousands,
    CultureInfo.InvariantCulture )
|> printfn "%i"

Imports System.Globalization

Delegate Function ParseNumber(Of T)(input As String, styles As NumberStyles, _
                                    provider As IFormatProvider) As T

Module DelegateExample
   Public Sub Main()
      Dim numericString As String = "-1,234"
      Dim parser As ParseNumber(Of Integer) = AddressOf Integer.Parse
      Console.WriteLine(parser(numericString, _
                        NumberStyles.Integer Or NumberStyles.AllowThousands, _
                        CultureInfo.InvariantCulture))
   End Sub
End Module

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

using System;
using System.Globalization;

public class GenericFunc
{
   public static void Main()
   {
      string numericString = "-1,234";
      Func<string, NumberStyles, IFormatProvider, int> parser = int.Parse;
      Console.WriteLine(parser(numericString,
                        NumberStyles.Integer | NumberStyles.AllowThousands,
                        CultureInfo.InvariantCulture));
   }
}

open System
open System.Globalization

let parseInt (str: string) styles format = Int32.Parse(str, styles, format)

let numericString = "-1,234"

let parser =
    Func<string, NumberStyles, IFormatProvider, int> parseInt

parser.Invoke(
    numericString,
    NumberStyles.Integer ||| NumberStyles.AllowThousands,
    CultureInfo.InvariantCulture )
|> printfn "%i"

Imports System.Globalization

Module GenericFunc
   Public Sub Main()
      Dim numericString As String = "-1,234"
      Dim parser As Func(Of String, NumberStyles, IFormatProvider, Integer) _
                         = AddressOf Integer.Parse
      Console.WriteLine(parser(numericString, _
                        NumberStyles.Integer Or NumberStyles.AllowThousands, _
                        CultureInfo.InvariantCulture))
   End Sub
End Module

Delegáta můžete použít Func<T1,T2,T3,TResult> s anonymními metodami v jazyce C#, jak ukazuje následující příklad. (Úvod do anonymních metod naleznete v tématu Anonymní metody.)

using System;
using System.Globalization;

public class Anonymous
{
   public static void Main()
   {
      string numericString = "-1,234";
      Func<string, NumberStyles, IFormatProvider, int> parser =
           delegate(string s, NumberStyles sty, IFormatProvider p)
           { return int.Parse(s, sty, p); };
      Console.WriteLine(parser(numericString,
                        NumberStyles.Integer | NumberStyles.AllowThousands,
                        CultureInfo.InvariantCulture));
   }
}

Výraz lambda můžete také přiřadit delegátovi Func<T1,T2,T3,TResult> , jak ukazuje následující příklad. (Úvod do výrazů lambda najdete v tématu Výrazy lambda (VB),výrazy lambda (C#) a výrazy lambda (F#).)

using System;
using System.Globalization;

public class LambdaExpression
{
   public static void Main()
   {
      string numericString = "-1,234";
      Func<string, NumberStyles, IFormatProvider, int> parser = (s, sty, p)
                   => int.Parse(s, sty, p);
      Console.WriteLine(parser(numericString,
                        NumberStyles.Integer | NumberStyles.AllowThousands,
                        CultureInfo.InvariantCulture));
   }
}

open System
open System.Globalization

let numericString = "-1,234"
let parser = Func<string, NumberStyles, IFormatProvider, int>(fun s sty p ->
     Int32.Parse(s, sty, p))
     
parser.Invoke(numericString,
              NumberStyles.Integer ||| NumberStyles.AllowThousands,
              CultureInfo.InvariantCulture)
|> printfn "%i"

Imports System.Globalization

Module LambdaExpression
   Public Sub Main()
      Dim numericString As String = "-1,234"
      Dim parser As Func(Of String, NumberStyles, IFormatProvider, Integer) _
                         = Function(s, sty, p) Integer.Parse(s, sty, p)
      Console.WriteLine(parser(numericString, _
                        NumberStyles.Integer Or NumberStyles.AllowThousands, _
                        CultureInfo.InvariantCulture))
   End Sub
End Module

Základní typ výrazu lambda je jedním z obecných Func delegátů. Díky tomu je možné předat výraz lambda jako parametr, aniž byste ho explicitně přiřadili delegátovi. 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í

Name	Description
GetMethodInfo(Delegate)	Získá objekt, který představuje metodu reprezentovanou zadaným delegátem.

Viz také

• Výrazy lambda (Průvodce programováním v C#)
• Výrazy lambda
• Výrazy lambda: zábavné klíčové slovo (F#)
• Delegáti (Průvodce programováním v C#)
• Delegáti (F#)
• Delegates in Visual Basic