Func<T1,T2,T3,TResult> Delegato

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: System.Core.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Incapsula un metodo che ha tre parametri e restituisce un valore del tipo specificato dal parametro 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);

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

Parametri di tipo

T1

Tipo del primo parametro del metodo incapsulato da questo delegato.

Questo parametro di tipo è controvariante, ovvero puoi usare il tipo specificato o qualsiasi tipo meno derivato. Per altre informazioni sulla covarianza e la controvarianza, vedi Covarianza e controvarianza nei generics.

T2

Tipo del secondo parametro del metodo incapsulato da questo delegato.

T3

Tipo del terzo parametro del metodo incapsulato da questo delegato.

TResult

Tipo del valore restituito del metodo incapsulato da questo delegato.

Questo parametro di tipo è covariante, ovvero puoi usare il tipo specificato o qualsiasi tipo più derivato. Per altre informazioni sulla covarianza e la controvarianza, vedi Covarianza e controvarianza nei generics.

Parametri

arg1: T1

Primo parametro del metodo incapsulato da questo delegato.

arg2: T2

Secondo parametro del metodo incapsulato da questo delegato.

arg3: T3

Terzo parametro del metodo incapsulato da questo delegato.

Valore restituito

TResult

Valore restituito del metodo incapsulato da questo delegato.

Esempio

Nell'esempio seguente viene illustrato come dichiarare e usare un Func<T1,T2,TResult> delegato. Questo esempio dichiara una Func<T1,T2,TResult> variabile e la assegna a un'espressione lambda che accetta un String valore e un Int32 valore come parametri. L'espressione lambda restituisce true se la lunghezza del String parametro è uguale al valore del Int32 parametro . Il delegato che incapsula questo metodo viene successivamente usato in una query per filtrare le stringhe in una matrice di stringhe.

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

Commenti

È possibile usare questo delegato per rappresentare un metodo che può essere passato come parametro senza dichiarare esplicitamente un delegato personalizzato. Il metodo incapsulato deve corrispondere alla firma del metodo definita da questo delegato. Ciò significa che il metodo incapsulato deve avere tre parametri, ognuno dei quali viene passato per valore e che deve restituire un valore.

Nota

Per fare riferimento a un metodo con tre parametri e restituisce void ( in F#) (o in Visual Basic, dichiarato come anziché Sub come ), Functionusare invece il delegato genericoAction<T1,T2,T3>unit.

Quando si usa il Func<T1,T2,T3,TResult> delegato, non è necessario definire in modo esplicito un delegato che incapsula un metodo con tre parametri. Ad esempio, il codice seguente dichiara in modo esplicito un delegato generico denominato ParseNumber e assegna un riferimento al metodo all'istanza Parse del delegato.

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

L'esempio seguente semplifica questo codice creando un'istanza del Func<T1,T2,T3,TResult> delegato anziché definendo in modo esplicito un nuovo delegato e assegnando un metodo denominato.

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

È possibile usare il Func<T1,T2,T3,TResult> delegato con metodi anonimi in C#, come illustrato nell'esempio seguente. Per un'introduzione ai metodi anonimi, vedere Metodi anonimi.

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

È anche possibile assegnare un'espressione lambda a un Func<T1,T2,T3,TResult> delegato, come illustrato nell'esempio seguente. Per un'introduzione alle espressioni lambda, vedere Espressioni lambda (VB), espressioni lambda (C#) ed espressioni 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

Il tipo sottostante di un'espressione lambda è uno dei delegati generici Func . In questo modo è possibile passare un'espressione lambda come parametro senza assegnarla in modo esplicito a un delegato. In particolare, poiché molti metodi di tipi nello spazio dei System.Linq nomi hanno Func parametri, è possibile passare questi metodi a un'espressione lambda senza creare esplicitamente un'istanza di un Func delegato.

Metodi di estensione

GetMethodInfo(Delegate)

Ottiene un oggetto che rappresenta il metodo rappresentato dal delegato specificato.

Si applica a

Condividi tramite