Func<T1,T2,T3,TResult> Delegar

Definição

Namespace:

System

Assemblies:

netstandard.dll, System.Runtime.dll

Encapsula um método que tem três parâmetros e retorna um valor do tipo especificado pelo parâmetro TResult.

C#

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

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

TResult

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.

C#

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

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.

C#

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

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.

C#

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

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

C#

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#).)

C#

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

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

• Expressões lambda (Guia de Programação em C#)
• Expressões Lambda
• Expressões lambda: a palavra-chave fun (F#)
• Delegados (Guia de Programação em C#)
• Delegados (F#)
• Delegados no Visual Basic