Que es Func, como y cuando se usa

¿Qué es Func<>y para qué se utiliza?

Func<T>es un tipo de delegado predefinido para un método que devuelve algún valor del tipo T.

En otras palabras, puede usar este tipo para hacer referencia a un método que devuelve algún valor de T. P.ej

public static string GetMessage() { return "Hello world"; }

puede ser referenciado así

Func<string> f = GetMessage;

Piense en ello como un marcador de posición. Puede ser muy útil cuando tiene un código que sigue un patrón determinado pero no necesita estar vinculado a ninguna funcionalidad en particular.

Por ejemplo, considere el Enumerable.Selectmétodo de extensión.

• El patrón es: para cada elemento de una secuencia, seleccione algún valor de ese elemento (por ejemplo, una propiedad) y cree una nueva secuencia que conste de estos valores.
• El marcador de posición es: alguna función de selector que realmente obtiene los valores para la secuencia descrita anteriormente.

Este método toma una Func<T, TResult>función concreta en lugar de cualquier. Esto permite que se use en cualquier contexto donde se aplique el patrón anterior.

Entonces, por ejemplo, digamos que tengo un List<Person>y quiero solo el nombre de cada persona en la lista. Puedo hacer esto:

var names = people.Select(p => p.Name);

O di que quiero la edad de cada persona:

var ages = people.Select(p => p.Age);

De inmediato, puede ver cómo pude aprovechar el mismo código que representa un patrón (con Select) con dos funciones diferentes ( p => p.Namey p => p.Age).

La alternativa sería escribir una versión diferente de Selectcada vez que desee escanear una secuencia en busca de un tipo de valor diferente. Entonces, para lograr el mismo efecto que el anterior, necesitaría:

// Presumably, the code inside these two methods would look almost identical;
// the only difference would be the part that actually selects a value
// based on a Person.
var names = GetPersonNames(people);
var ages = GetPersonAges(people);

Con un delegado actuando como marcador de posición, me libero de tener que escribir el mismo patrón una y otra vez en casos como este.

Func<T1, T2, ..., Tn, Tr> representa una función que toma argumentos (T1, T2, ..., Tn) y devuelve Tr.

Por ejemplo, si tiene una función:

double sqr(double x) { return x * x; }

Puede guardarlo como una especie de variable de función:

Func<double, double> f1 = sqr;
Func<double, double> f2 = x => x * x;

Y luego use exactamente como usaría sqr:

f1(2);
Console.WriteLine(f2(f1(4)));

etc.

Sin embargo, recuerde que es un delegado; para obtener información más avanzada, consulte la documentación.

Encuentro Func<T>muy útil cuando creo un componente que necesita ser personalizado "sobre la marcha".

Tome este ejemplo muy simple: un PrintListToConsole<T>componente.

Un objeto muy simple que imprime esta lista de objetos en la consola. Desea permitir que el desarrollador que lo usa personalice la salida.

Por ejemplo, desea permitirle definir un tipo particular de formato de número, etc.

Sin Func

Primero, debe crear una interfaz para una clase que toma la entrada y produce la cadena para imprimir en la consola.

interface PrintListConsoleRender<T> {
  String Render(T input);
}

Luego, debe crear la clase PrintListToConsole<T>que toma la interfaz creada anteriormente y la usa sobre cada elemento de la lista.

class PrintListToConsole<T> {

    private PrintListConsoleRender<T> _renderer;

    public void SetRenderer(PrintListConsoleRender<T> r) {
        // this is the point where I can personalize the render mechanism
        _renderer = r;
    }

    public void PrintToConsole(List<T> list) {
        foreach (var item in list) {
            Console.Write(_renderer.Render(item));
        }
    }   
}

El desarrollador que necesita usar su componente debe:

1. implementar la interfaz

2. pasar la clase real al PrintListToConsole

   class MyRenderer : PrintListConsoleRender<int> {
       public String Render(int input) {
           return "Number: " + input;
       }
   }
   
   class Program {
       static void Main(string[] args) {
           var list = new List<int> { 1, 2, 3 };
           var printer = new PrintListToConsole<int>();
           printer.SetRenderer(new MyRenderer());
           printer.PrintToConsole(list);
           string result = Console.ReadLine();   
       }   
   }

Usar Func es mucho más sencillo

Dentro del componente, define un parámetro de tipo Func<T,String>que representa una interfaz de una función que toma un parámetro de entrada de tipo T y devuelve una cadena (la salida para la consola)

class PrintListToConsole<T> {

    private Func<T, String> _renderFunc;

    public void SetRenderFunc(Func<T, String> r) {
        // this is the point where I can set the render mechanism
        _renderFunc = r;
    }

    public void Print(List<T> list) {
        foreach (var item in list) {
            Console.Write(_renderFunc(item));
        }
    }
}

Cuando el desarrollador usa su componente, simplemente le pasa al componente la implementación del Func<T, String>tipo, que es una función que crea la salida para la consola.

class Program {
    static void Main(string[] args) {
        var list = new List<int> { 1, 2, 3 }; // should be a list as the method signature expects
        var printer = new PrintListToConsole<int>();
        printer.SetRenderFunc((o) => "Number:" + o);
        printer.Print(list); 
        string result = Console.ReadLine();
    }
}

Func<T>le permite definir una interfaz de método genérico sobre la marcha. Usted define qué tipo es la entrada y qué tipo es la salida. Simple y conciso.

Func<T1,R>y los otros Funcdelegados genéricos predefinidos ( Func<T1,T2,R>, Func<T1,T2,T3,R>y otros) son delegados genéricos que devuelven el tipo del último parámetro genérico.

Si tiene una función que necesita devolver diferentes tipos, dependiendo de los parámetros, puede usar un Funcdelegado, especificando el tipo de retorno.

Es solo un delegado genérico predefinido. Al usarlo, no necesita declarar a todos los delegados. Hay otro delegado predefinido Action<T, T2...>, que es el mismo pero devuelve vacío.

Tal vez no sea demasiado tarde para agregar información.

Suma:

El Func es un delegado personalizado definido en el espacio de nombres del sistema que le permite apuntar a un método con la misma firma (como lo hacen los delegados), usando 0 a 16 parámetros de entrada y que debe devolver algo.

Nomenclatura y uso:

Func<input_1, input_2, ..., input1_6, output> funcDelegate = someMethod;

Definición:

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

Dónde se usa:

Se utiliza en expresiones lambda y métodos anónimos.