Func<T1,T2,T3,TResult> Gedelegeerde

Definitie

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

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;

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

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 

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

Type parameters

Parameters

Retourwaarde

De retourwaarde van de methode die door deze gemachtigde wordt ingekapseld.

Voorbeelden

In het volgende voorbeeld ziet u hoe u een Func<T1,T2,TResult> gemachtigde declareert en gebruikt. In dit voorbeeld declareert u een Func<T1,T2,TResult> variabele en wijst u deze toe aan een lambda-expressie die een String waarde en een Int32 waarde als parameters gebruikt. De lambda-expressie retourneert true als de lengte van de String parameter gelijk is aan de waarde van de Int32 parameter. De gemachtigde die deze methode inkapselt, wordt vervolgens gebruikt in een query om tekenreeksen in een matrix met tekenreeksen te filteren.

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

Opmerkingen

U kunt deze gemachtigde gebruiken om een methode te vertegenwoordigen die als parameter kan worden doorgegeven zonder expliciet een aangepaste gemachtigde te declareren. De ingekapselde methode moet overeenkomen met de methodehandtekening die door deze gemachtigde is gedefinieerd. Dit betekent dat de ingekapselde methode drie parameters moet hebben, die elk op waarde worden doorgegeven en dat deze een waarde moet retourneren.

Wanneer u de Func<T1,T2,T3,TResult> gemachtigde gebruikt, hoeft u niet expliciet een gemachtigde te definiëren die een methode inkapselt met drie parameters. De volgende code declareert bijvoorbeeld expliciet een algemene gemachtigde met de naam ParseNumber en wijst een verwijzing naar de methode toe aan het Parse gemachtigde exemplaar.

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

In het volgende voorbeeld wordt deze code vereenvoudigd door de Func<T1,T2,T3,TResult> gemachtigde te instantiëren in plaats van expliciet een nieuwe gemachtigde te definiëren en er een benoemde methode aan toe te wijzen.

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

U kunt de Func<T1,T2,T3,TResult> gemachtigde gebruiken met anonieme methoden in C#, zoals in het volgende voorbeeld wordt geïllustreerd. (Zie Anonieme methoden voor een inleiding tot anonieme methoden.)

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

U kunt ook een lambda-expressie toewijzen aan een Func<T1,T2,T3,TResult> gemachtigde, zoals in het volgende voorbeeld wordt geïllustreerd. (Zie Lambda Expressions (VB), Lambda Expressions (C#) en Lambda Expressions (F#) voor een inleiding tot lambda-expressies.)

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

Het onderliggende type lambda-expressie is een van de algemene Func gemachtigden. Dit maakt het mogelijk om een lambda-expressie als parameter door te geven zonder deze expliciet toe te wijzen aan een gemachtigde. Omdat veel typen typen in de System.Linq naamruimte parameters hebben Func , kunt u deze methoden een lambda-expressie doorgeven zonder expliciet een Func gemachtigde te instantiëren.

Zie ook

• Lambda-expressies (C#-programmeerhandleiding)
• Lambda-expressies
• Lambda-expressies: het leuke trefwoord (F#)
• Gemachtigden (C#-programmeerhandleiding)
• Gemachtigden (F#)
• Delegates in Visual Basic