Func<T1,T2,TResult> Gedelegeerde

Definitie

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

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

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

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

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

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

Public Delegate Function Func(Of T1, T2, TResult)(arg1 As T1, arg2 As T2) 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 twee parameters moet hebben, die elk op waarde worden doorgegeven en dat deze een waarde moet retourneren.

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

using System;

delegate string[] ExtractMethod(string stringToManipulate, int maximum);

public class DelegateExample
{
   public static void Main()
   {
      // Instantiate delegate to reference ExtractWords method
      ExtractMethod extractMeth = ExtractWords;
      string title = "The Scarlet Letter";
      // Use delegate instance to call ExtractWords method and display result
      foreach (string word in extractMeth(title, 5))
         Console.WriteLine(word);
   }

   private static string[] ExtractWords(string phrase, int limit)
   {
      char[] delimiters = new char[] {' '};
      if (limit > 0)
         return phrase.Split(delimiters, limit);
      else
         return phrase.Split(delimiters);
   }
}

type ExtractMethod = delegate of string * int -> string []

let extractWords (phrase: string) limit =
    let delimiters = [| ' ' |]
    if limit > 0 then
        phrase.Split(delimiters, limit)
    else
        phrase.Split delimiters

// Instantiate delegate to reference extractWords function
let extractMeth = ExtractMethod extractWords
let title = "The Scarlet Letter"

// Use delegate instance to call extractWords function and display result
for word in extractMeth.Invoke(title, 5) do
    printfn $"{word}"

' Declare a delegate to represent string extraction method
Delegate Function ExtractMethod(ByVal stringToManipulate As String, _
                                ByVal maximum As Integer) As String()

Module DelegateExample
   Public Sub Main()
      ' Instantiate delegate to reference ExtractWords method
      Dim extractMeth As ExtractMethod = AddressOf ExtractWords
      Dim title As String = "The Scarlet Letter"
      ' Use delegate instance to call ExtractWords method and display result
      For Each word As String In extractMeth(title, 5)
         Console.WriteLine(word)
      Next   
   End Sub

   Private Function ExtractWords(phrase As String, limit As Integer) As String()
      Dim delimiters() As Char = {" "c}
      If limit > 0 Then
         Return phrase.Split(delimiters, limit)
      Else
         Return phrase.Split(delimiters)
      End If
   End Function
End Module

In het volgende voorbeeld wordt deze code vereenvoudigd door een Func<T1,T2,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;

public class GenericFunc
{
   public static void Main()
   {
      // Instantiate delegate to reference ExtractWords method
      Func<string, int, string[]> extractMethod = ExtractWords;
      string title = "The Scarlet Letter";
      // Use delegate instance to call ExtractWords method and display result
      foreach (string word in extractMethod(title, 5))
         Console.WriteLine(word);
   }

   private static string[] ExtractWords(string phrase, int limit)
   {
      char[] delimiters = new char[] {' '};
      if (limit > 0)
         return phrase.Split(delimiters, limit);
      else
         return phrase.Split(delimiters);
   }
}

open System

let extractWords (phrase: string) limit =
    let delimiters = [| ' ' |]
    if limit > 0 then
        phrase.Split(delimiters, limit)
    else
        phrase.Split delimiters

// Instantiate delegate to reference extractWords function
let extractMethod = Func<string, int, string[]> extractWords
let title = "The Scarlet Letter"

// Use delegate instance to call extractWords function and display result
for word in extractMethod.Invoke(title, 5) do
    printfn $"{word}"

Module GenericFunc
   Public Sub Main()
      ' Instantiate delegate to reference ExtractWords method
      Dim extractMeth As Func(Of String, Integer, String()) = AddressOf ExtractWords
      Dim title As String = "The Scarlet Letter"
      ' Use delegate instance to call ExtractWords method and display result
      For Each word As String In extractMeth(title, 5)
         Console.WriteLine(word)
      Next   
   End Sub

   Private Function ExtractWords(phrase As String, limit As Integer) As String()
      Dim delimiters() As Char = {" "c}
      If limit > 0 Then
         Return phrase.Split(delimiters, limit)
      Else
         Return phrase.Split(delimiters)
      End If
   End Function
End Module

U kunt de Func<T1,T2,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;

public class Anonymous
{
   public static void Main()
   {
      Func<string, int, string[]> extractMeth = delegate(string s, int i)
         { char[] delimiters = new char[] {' '};
           return i > 0 ? s.Split(delimiters, i) : s.Split(delimiters);
         };

      string title = "The Scarlet Letter";
      // Use Func instance to call ExtractWords method and display result
      foreach (string word in extractMeth(title, 5))
         Console.WriteLine(word);
   }
}

U kunt ook een lambda-expressie toewijzen aan een Func<T1,T2,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;

public class LambdaExpression
{
   public static void Main()
   {
      char[] separators = new char[] {' '};
      Func<string, int, string[]> extract = (s, i) =>
           i > 0 ? s.Split(separators, i) : s.Split(separators) ;

      string title = "The Scarlet Letter";
      // Use Func instance to call ExtractWords method and display result
      foreach (string word in extract(title, 5))
         Console.WriteLine(word);
   }
}

open System

let separators = [| ' ' |]

let extract =
    Func<string, int, string []> (fun s i ->
        if i > 0 then
            s.Split(separators, i)
        else
            s.Split separators)

let title = "The Scarlet Letter"

// Use Func instance to call lambda expression and display result
for word in extract.Invoke(title, 5) do
    printfn $"{word}"

Module LambdaExpression
   Public Sub Main()
      Dim separators() As Char = {" "c}
      Dim extract As Func(Of String, Integer, String()) = Function(s, i) _
          CType(iif(i > 0, s.Split(separators, i), s.Split(separators)), String())  
      
      Dim title As String = "The Scarlet Letter"
      For Each word As String In extract(title, 5)
         Console.WriteLine(word)
      Next   
   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<T1,T2,TResult> , kunt u deze methoden een lambda-expressie doorgeven zonder expliciet een Func<T1,T2,TResult> gemachtigde te instantiëren.

Zie ook

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