Func<T,TResult> Delegar

Definição

Namespace:

System

Assemblies:

netstandard.dll, System.Runtime.dll

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

C#

public delegate TResult Func<in T,out TResult>(T arg);

Parâmetros de tipo

T

O tipo do 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

arg

T

O 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<T,TResult> delegado. Este exemplo declara uma Func<T,TResult> variável e atribui a ela uma expressão lambda que converte os caracteres em uma cadeia de caracteres em maiúsculas. O delegado que encapsula esse método é posteriormente passado para o Enumerable.Select método para alterar as cadeias de caracteres em uma matriz de cadeias de caracteres para maiúsculas.

C#

// Declare a Func variable and assign a lambda expression to the
// variable. The method takes a string and converts it to uppercase.
Func<string, string> selector = str => str.ToUpper();

// Create an array of strings.
string[] words = { "orange", "apple", "Article", "elephant" };
// Query the array and select strings according to the selector method.
IEnumerable<String> aWords = words.Select(selector);

// Output the results to the console.
foreach (String word in aWords)
    Console.WriteLine(word);

/*
This code example produces the following output:

ORANGE
APPLE
ARTICLE
ELEPHANT

*/

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 um parâmetro que é passado para ele por valor e que ele deve retornar um valor.

Observação

Para fazer referência a um método que tem um parâmetro e retorna void (ou no Visual Basic, que é declarado como um Sub e não como um Function), use o delegado genérico Action<T> .

Ao usar o Func<T,TResult> delegado, você não precisa definir explicitamente um delegado que encapsula um método com um único parâmetro. Por exemplo, o código a seguir declara explicitamente um delegado chamado ConvertMethod e atribui uma referência ao UppercaseString método à sua instância delegada.

C#

using System;

delegate string ConvertMethod(string inString);

public class DelegateExample
{
   public static void Main()
   {
      // Instantiate delegate to reference UppercaseString method
      ConvertMethod convertMeth = UppercaseString;
      string name = "Dakota";
      // Use delegate instance to call UppercaseString method
      Console.WriteLine(convertMeth(name));
   }

   private static string UppercaseString(string inputString)
   {
      return inputString.ToUpper();
   }
}

O exemplo a seguir simplifica esse código instanciando o Func<T,TResult> delegado em vez de definir explicitamente um novo delegado e atribuir um método nomeado a ele.

C#

// Instantiate delegate to reference UppercaseString method
Func<string, string> convertMethod = UppercaseString;
string name = "Dakota";
// Use delegate instance to call UppercaseString method
Console.WriteLine(convertMethod(name));

string UppercaseString(string inputString)
{
   return inputString.ToUpper();
}

// This code example produces the following output:
//
//    DAKOTA

Você também pode usar o Func<T,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#

 Func<string, string> convert = delegate(string s)
    { return s.ToUpper();};

 string name = "Dakota";
 Console.WriteLine(convert(name));

// This code example produces the following output:
//
//    DAKOTA

Você também pode atribuir uma expressão lambda a um Func<T,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#

Func<string, string> convert = s => s.ToUpper();

string name = "Dakota";
Console.WriteLine(convert(name));

// This code example produces the following output:
//
//    DAKOTA

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<T,TResult> parâmetros, você pode passar a esses métodos uma expressão lambda sem instanciar explicitamente um Func<T,TResult> 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: a palavra-chave fun (F#)
• Expressões lambda (Visual Basic)
• Delegados (Guia de Programação em C#)
• Delegados (F#)
• Delegados (Visual Basic)