Func<T,TResult> 代理人

定義

封裝具有一個參數並傳回 TResult 參數指定類型之值的方法。

generic <typename T, typename TResult>
public delegate TResult Func(T arg);
public delegate TResult Func<in T,out TResult>(T arg);
public delegate TResult Func<T,TResult>(T arg);
type Func<'T, 'Result> = delegate of 'T -> 'Result
Public Delegate Function Func(Of In T, Out TResult)(arg As T) As TResult 
Public Delegate Function Func(Of T, TResult)(arg As T) As TResult 

類型參數

T

這個委派所封裝之方法的參數類型。

這是反變數的型別參數。 也就是說,您可以使用您指定的類型,或衍生程度較低的任何類型。 如需共變數與反變數的詳細資訊,請參閱泛型中的共變數與反變數
TResult

這個委派所封裝之方法的傳回值之類型。

這是共變數的型別參數。 也就是說,您可以使用您指定的類型,或衍生程度較高的任何類型。 如需共變數與反變數的詳細資訊,請參閱泛型中的共變數與反變數

參數

arg
T

這個委派所封裝之方法的參數。

傳回值

TResult

這個委派所封裝之方法的傳回值。

範例

下列範例示範如何宣告和使用 Func<T,TResult> 委派。 此範例會宣告 Func<T,TResult> 變數,並為其指派 lambda 運算式,將字串中的字元轉換為大寫。 封裝這個方法的委派會接著傳遞至 Enumerable.Select 方法,以將字串陣列中的字串變更為大寫。

// 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

*/
open System
open System.Linq

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

// Create a list of strings.
let words = [ "orange"; "apple"; "Article"; "elephant" ]

// Query the list and select strings according to the selector function.
let aWords = words.Select selector

// Output the results to the console.
for word in aWords do
    printfn $"{word}"

// This code example produces the following output:
//     ORANGE
//     APPLE
//     ARTICLE
//     ELEPHANT
Imports System.Collections.Generic
Imports System.Linq

Module Func
   Public Sub Main()
      ' Declare a Func variable and assign a lambda expression to the  
      ' variable. The method takes a string and converts it to uppercase.
      Dim selector As Func(Of String, String) = Function(str) str.ToUpper()
   
      ' Create an array of strings.
      Dim words() As String = { "orange", "apple", "Article", "elephant" }
      ' Query the array and select strings according to the selector method.
      Dim aWords As IEnumerable(Of String) = words.Select(selector)
   
      ' Output the results to the console.
      For Each word As String In aWords
         Console.WriteLine(word)
      Next
   End Sub
End Module
' This code example produces the following output:
'           
'   ORANGE
'   APPLE
'   ARTICLE
'   ELEPHANT
// Declare a delegate
delegate String ^ MyDel(String ^);

// Create wrapper class and function that takes in a string and converts it to uppercase
ref class DelegateWrapper {
public:
    String ^ ToUpper(String ^ s) {
        return s->ToUpper();
    }
};

int main() {
    // Declare delegate
    DelegateWrapper ^ delegateWrapper = gcnew DelegateWrapper;
    MyDel ^ DelInst = gcnew MyDel(delegateWrapper, &DelegateWrapper::ToUpper);

    // Cast into Func
    Func<String ^, String ^> ^ selector = reinterpret_cast<Func<String ^, String ^> ^>(DelInst);

    // Create an array of strings
    array<String ^> ^ words = { "orange", "apple", "Article", "elephant" };

    // Query the array and select strings according to the selector method
    Generic::IEnumerable<String ^> ^ aWords = Enumerable::Select((Generic::IEnumerable<String^>^)words, selector);

    // Output the results to the console
    for each(String ^ word in aWords)
        Console::WriteLine(word);
    /*
    This code example produces the following output:

    ORANGE
    APPLE
    ARTICLE
    ELEPHANT
    */
}

備註

您可以使用這個委派來代表可以傳遞為參數的方法,而不需要明確宣告自訂委派。 封裝的方法必須對應至這個委派所定義的方法簽章。 這表示封裝的方法必須有一個以傳值方式傳遞給它的參數,而且必須傳回值。

注意

若要參考具有一個參數的方法,並傳回 void (或 Visual Basic 中宣告為, Sub 而不是做為) 的方法 Function ,請改用泛型 Action<T> 委派。

當您使用 Func<T,TResult> 委派時,不需要明確地定義委派,此委派會封裝具有單一參數的方法。 例如,下列程式碼會明確宣告名為的委派 ConvertMethod ,並將該方法的參考指派 UppercaseString 給它的委派實例。

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();
   }
}
type ConvertMethod = delegate of string -> string

let uppercaseString (inputString: string) =
    inputString.ToUpper()
    
// Instantiate delegate to reference uppercaseString function
let convertMeth = ConvertMethod uppercaseString
let name = "Dakota"

// Use delegate instance to call uppercaseString function
printfn $"{convertMeth.Invoke name}"
' Declare a delegate to represent string conversion method
Delegate Function ConvertMethod(ByVal inString As String) As String

Module DelegateExample
   Public Sub Main()
      ' Instantiate delegate to reference UppercaseString method
      Dim convertMeth As ConvertMethod = AddressOf UppercaseString
      Dim name As String = "Dakota"
      ' Use delegate instance to call UppercaseString method
      Console.WriteLine(convertMeth(name))
   End Sub

   Private Function UppercaseString(inputString As String) As String
      Return inputString.ToUpper()
   End Function
End Module

下列範例會藉由具現化委派來簡化此程式碼 Func<T,TResult> ,而不是明確定義新的委派,並將命名方法指派給它。

// 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
open System

let uppercaseString (inputString: string) =
    inputString.ToUpper()

// Instantiate delegate to reference uppercaseString function
let convertMethod = Func<string, string> uppercaseString
let name = "Dakota"

// Use delegate instance to call uppercaseString function
printfn $"{convertMethod.Invoke name}"

// This code example produces the following output:
//    DAKOTA
Module GenericFunc
   Public Sub Main()
      ' Instantiate delegate to reference UppercaseString method
      Dim convertMethod As Func(Of String, String) = AddressOf UppercaseString
      Dim name As String = "Dakota"
      ' Use delegate instance to call UppercaseString method
      Console.WriteLine(convertMethod(name))
   End Sub

   Private Function UppercaseString(inputString As String) As String
      Return inputString.ToUpper()
   End Function
End Module

您也可以 Func<T,TResult> 在 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

您也可以將 lambda 運算式指派給 Func<T,TResult> 委派,如下列範例所示。 (如需 lambda 運算式的簡介,請參閱lambda 運算式 (VB) lambda 運算式 (c # ) lambda 運算式 (F # ) . )

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

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

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

let convert = Func<string, string>(fun s -> s.ToUpper())

let name = "Dakota"
printfn $"{convert.Invoke name}"

// This code example produces the following output:
//    DAKOTA
Module LambdaExpression
   Public Sub Main()
      Dim convert As Func(Of String, String) = Function(s) s.ToUpper()
      
      Dim name As String = "Dakota"
      Console.WriteLine(convert(name))  
   End Sub
End Module

Lambda 運算式的基礎類型是其中一個泛型 Func 委派。 如此一來,您就可以將 lambda 運算式當做參數傳遞,而不需要明確地將它指派給委派。 尤其是,由於命名空間中的許多類型方法 System.Linq 都有 Func<T,TResult> 參數,您可以將這些方法傳遞給 lambda 運算式,而不需要明確具現化 Func<T,TResult> 委派。

擴充方法

GetMethodInfo(Delegate)

取得表示特定委派所代表之方法的物件。

適用於

另請參閱