Func<T,TResult> Delegado

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: netstandard.dll

Ensamblado:: System.Core.dll

Ensamblado:: mscorlib.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Encapsula un método que tiene un parámetro y devuelve un valor del tipo especificado por el parámetro 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

Parámetros de tipo

T

Tipo de parámetro del método que este delegado encapsula.

Este parámetro de tipo es contravariante, es decir, puede usar el tipo que haya especificado o cualquier tipo menos derivado. Si desea obtener más información sobre la covarianza y la contravarianza, consulte Covarianza y contravarianza en genéricos.

TResult

Tipo del valor devuelto del método que este delegado encapsula.

Este parámetro de tipo es covariante, es decir, puede usar el tipo que haya especificado o cualquier tipo más derivado. Si desea obtener más información sobre la covarianza y la contravarianza, consulte Covarianza y contravarianza en genéricos.

Parámetros

arg: T

Parámetro del método que este delegado encapsula.

Valor devuelto

TResult

Valor devuelto del método que este delegado encapsula.

Ejemplos

En el ejemplo siguiente se muestra cómo declarar y usar un Func<T,TResult> delegado. En este ejemplo se declara una variable y se le asigna una expresión lambda que convierte los caracteres Func<T,TResult> de una cadena a mayúsculas. El delegado que encapsula este método se pasa posteriormente al método para cambiar las cadenas de una matriz de Enumerable.Select cadenas a mayúsculas.

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

Comentarios

Puede usar este delegado para representar un método que se puede pasar como parámetro sin declarar explícitamente un delegado personalizado. El método encapsulado debe corresponder a la firma del método definida por este delegado. Esto significa que el método encapsulado debe tener un parámetro que se le pase por valor y que debe devolver un valor.

Nota

Para hacer referencia a un método que tiene un parámetro y devuelve (o en Visual Basic, que se declara como en lugar de como ), use el delegado genérico en void Sub su Function Action<T> lugar.

Cuando se usa el delegado, no es necesario definir explícitamente un delegado que encapsula un Func<T,TResult> método con un solo parámetro. Por ejemplo, el código siguiente declara explícitamente un delegado denominado y asigna una referencia ConvertMethod al método a su instancia de UppercaseString delegado.

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

En el ejemplo siguiente se simplifica este código mediante la creación de instancias del delegado en lugar de definir explícitamente un nuevo delegado y asignarle un Func<T,TResult> método con nombre.

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

También puede usar el delegado Func<T,TResult> con métodos anónimos en C#, como se muestra en el ejemplo siguiente. (Para obtener una introducción a los métodos anónimos, vea Métodos anónimos).

 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

También puede asignar una expresión lambda a un Func<T,TResult> delegado, como se muestra en el ejemplo siguiente. (Para obtener una introducción a las expresiones lambda, vea Expresiones lambda (VB), Expresiones lambda (C#) y Expresiones 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

El tipo subyacente de una expresión lambda es uno de los Func delegados genéricos. Esto permite pasar una expresión lambda como parámetro sin asignarla explícitamente a un delegado. En concreto, dado que muchos métodos de tipos del espacio de nombres tienen parámetros, puede pasar a estos métodos una expresión lambda sin crear explícitamente System.Linq Func<T,TResult> instancias de un Func<T,TResult> delegado.

Métodos de extensión

GetMethodInfo(Delegate)

Obtiene un objeto que representa el método representado por el delegado especificado.

Se aplica a

Compartir a través de