Udostępnij za pośrednictwem


Func<T,TResult> Delegat

Definicja

Hermetyzuje metodę, która ma jeden parametr i zwraca wartość typu określonego TResult przez parametr .

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 

Parametry typu

T

Typ parametru metody, który ten delegat hermetyzuje.

Ten parametr typu jest kontrawariantny. Oznacza to, że możesz użyć typu, który został przez Ciebie określony, lub dowolnego typu, który jest mniej pochodny. Aby uzyskać więcej informacji o kowariancji i kontrawariancji, zobacz Kowariancja i kontrawariancja w typach ogólnych.
TResult

Typ zwracanej wartości metody, którą hermetyzuje ten delegat.

Ten parametr typu jest kowariantny. Oznacza to, że możesz użyć typu, który został przez Ciebie określony, lub dowolnego typu, który jest bardziej pochodny. Aby uzyskać więcej informacji o kowariancji i kontrawariancji, zobacz Kowariancja i kontrawariancja w typach ogólnych.

Parametry

arg
T

Parametr metody, którą hermetyzuje ten delegat.

Wartość zwracana

TResult

Zwracana wartość metody, którą hermetyzuje ten delegat.

Przykłady

W poniższym przykładzie pokazano, jak zadeklarować delegata i używać go Func<T,TResult> . W tym przykładzie zadeklarowano zmienną Func<T,TResult> i przypisano do niej wyrażenie lambda, które konwertuje znaki w ciągu na wielkie litery. Delegat hermetyzujący tę metodę jest następnie przekazywany do Enumerable.Select metody w celu zmiany ciągów w tablicy ciągów na wielkie litery.

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

Uwagi

Tego delegata można użyć do reprezentowania metody, którą można przekazać jako parametr bez jawnego deklarowania delegata niestandardowego. Hermetyzowana metoda musi odpowiadać podpisowi metody zdefiniowanej przez ten delegat. Oznacza to, że metoda hermetyzowana musi mieć jeden parametr, który jest do niego przekazywany przez wartość, i że musi zwrócić wartość.

Uwaga

Aby odwołać się do metody, która ma jeden parametr i zwraca void (lub w Visual Basic, który jest zadeklarowany jako a Sub , a nie jako Function), należy zamiast tego użyć delegata ogólnego Action<T> .

Jeśli używasz delegata Func<T,TResult> , nie musisz jawnie definiować delegata, który hermetyzuje metodę za pomocą jednego parametru. Na przykład poniższy kod jawnie deklaruje delegata o nazwie ConvertMethod i przypisuje odwołanie do UppercaseString metody do jej wystąpienia delegata.

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

Poniższy przykład upraszcza ten kod przez utworzenie wystąpienia delegata Func<T,TResult> zamiast jawnego zdefiniowania nowego delegata i przypisania do niego nazwanej metody.

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

Możesz również użyć delegata Func<T,TResult> z metodami anonimowymi w języku C#, jak pokazano w poniższym przykładzie. (Aby zapoznać się z wprowadzeniem do metod anonimowych, zobacz Metody anonimowe).

 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

Można również przypisać wyrażenie lambda do delegata Func<T,TResult> , jak pokazano w poniższym przykładzie. (Aby zapoznać się z wprowadzeniem do wyrażeń lambda, zobacz Wyrażenia lambda (VB),Lambda Expressions (C#) i Lambda Expressions (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

Podstawowym typem wyrażenia lambda jest jeden z delegatów ogólnych Func . Dzięki temu można przekazać wyrażenie lambda jako parametr bez jawnego przypisania go do delegata. W szczególności, ponieważ wiele metod typów w System.Linq przestrzeni nazw ma Func<T,TResult> parametry, można przekazać te metody wyrażenie lambda bez jawnego utworzenia wystąpienia delegata Func<T,TResult> .

Metody rozszerzania

GetMethodInfo(Delegate)

Pobiera obiekt reprezentujący metodę reprezentowaną przez określonego delegata.

Dotyczy

Zobacz też