Func<T1,T2,T3,TResult> Delegar
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Encapsula um método que tem três parâmetros e retorna um valor do tipo especificado pelo parâmetro 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 -> 'ResultPublic 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 Parâmetros de tipo
- T1
O tipo do primeiro parâmetro do método encapsulado por esse delegado.
Este parâmetro de tipo é contravariante. Isso significa que é possível usar o tipo especificado ou qualquer tipo menos derivado. Para obter mais informações sobre covariância e contravariância, consulte Covariância e contravariância em genéricos.- T2
O tipo do segundo parâmetro do método encapsulado por esse delegado.
Este parâmetro de tipo é contravariante. Isso significa que é possível usar o tipo especificado ou qualquer tipo menos derivado. Para obter mais informações sobre covariância e contravariância, consulte Covariância e contravariância em genéricos.- T3
O tipo do terceiro parâmetro do método encapsulado por esse delegado.
Este parâmetro de tipo é contravariante. Isso significa que é possível usar o tipo especificado ou qualquer tipo menos derivado. Para obter mais informações sobre covariância e contravariância, consulte Covariância e contravariância em genéricos.- TResult
O tipo do valor retornado do método encapsulado por esse delegado.
Este parâmetro de tipo é covariante. Isso significa que é possível usar o tipo especificado ou qualquer tipo mais derivado. Para obter mais informações sobre covariância e contravariância, consulte Covariância e contravariância em genéricos.Parâmetros
- arg1
- T1
O primeiro parâmetro do método encapsulado por esse delegado.
- arg2
- T2
O segundo parâmetro do método encapsulado por esse delegado.
- arg3
- T3
O terceiro parâmetro do método encapsulado por esse delegado.
Valor Retornado
O valor retornado do método encapsulado por esse delegado.
Exemplos
O exemplo a seguir demonstra como declarar e usar um Func<T1,T2,TResult> delegado. Este exemplo declara uma Func<T1,T2,TResult> variável e atribui a ela uma expressão lambda que usa um String valor e um Int32 valor como parâmetros. A expressão lambda retornará true se o comprimento do String parâmetro for igual ao valor do Int32 parâmetro . O delegado que encapsula esse método é usado posteriormente em uma consulta para filtrar cadeias de caracteres em uma matriz de cadeias de caracteres.
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
Comentários
Você pode usar esse delegado para representar um método que pode ser passado como um parâmetro sem declarar explicitamente um delegado personalizado. O método encapsulado deve corresponder à assinatura do método definida por esse delegado. Isso significa que o método encapsulado deve ter três parâmetros, cada um deles é passado para ele por valor e que deve retornar um valor.
Observação
Para fazer referência a um método que tem três parâmetros e retorna void ( em F#) (ou no Visual Basic, que é declarado como um Sub e não como um Function), use o delegado genéricoAction<T1,T2,T3>unit.
Ao usar o Func<T1,T2,T3,TResult> delegado, você não precisa definir explicitamente um delegado que encapsula um método com três parâmetros. Por exemplo, o código a seguir declara explicitamente um delegado genérico chamado ParseNumber e atribui uma referência ao Parse método à sua instância delegada.
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
O exemplo a seguir simplifica esse código instanciando o Func<T1,T2,T3,TResult> delegado em vez de definir explicitamente um novo delegado e atribuir um método nomeado a ele.
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
Você pode usar o Func<T1,T2,T3,TResult> delegado com métodos anônimos em C#, como ilustra o exemplo a seguir. (Para obter uma introdução aos métodos anônimos, consulte Métodos anônimos.)
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));
}
}
Você também pode atribuir uma expressão lambda a um Func<T1,T2,T3,TResult> delegado, como ilustra o exemplo a seguir. (Para obter uma introdução às expressões lambda, consulte Expressões Lambda (VB), Expressões Lambda (C#) e Expressões 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
O tipo subjacente de uma expressão lambda é um dos delegados genéricos Func . Isso possibilita passar uma expressão lambda como um parâmetro sem atribuí-la explicitamente a um delegado. Em particular, como muitos métodos de tipos no System.Linq namespace têm Func parâmetros, você pode passar a esses métodos uma expressão lambda sem instanciar explicitamente um Func delegado.
Métodos de Extensão
| GetMethodInfo(Delegate) |
Obtém um objeto que representa o método representado pelo delegado especificado. |
Aplica-se a
Confira também
Comentários
Em breve: ao longo de 2024, vamos eliminar problemas do GitHub como o mecanismo de comentários para conteúdo e substituí-lo por um novo sistema de comentários. Para obter mais informações, consulte: https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de