Pasar una función (con parámetros) como parámetro?

Question

Quiero crear una genérica a la que me puedo pasar una función como un parámetro, sin embargo, esta función puede incluir parámetros en sí por lo ...

int foo = GetCachedValue("LastFoo", methodToGetFoo) 

tal que:

protected int methodToGetFoo(DateTime today) 
{ return 2; // example only } 

Esencialmente quiero tener un método que verificará el valor en caché, de lo contrario generará el valor según el método aprobado.

¿Pensamientos?

Answer 1

Parece que usted quiere una Func<T>:

T GetCachedValue<T>(string key, Func<T> method) { 
    T value; 
    if(!cache.TryGetValue(key, out value)) { 
     value = method(); 
     cache[key] = value; 
    } 
    return value; 
} 

La persona que llama puede entonces terminar con esto de muchas maneras; para funciones simples:

int i = GetCachedValue("Foo", GetNextValue); 
... 
int GetNextValue() {...} 

o cuando se trata de argumentos, un cierre:

var bar = ... 
int i = GetCachedValue("Foo",() => GetNextValue(bar)); 

Answer 2

Usted puede crear su propio delegado, pero en C# 3.0 puede que le resulte más conveniente utilizar el built-in Func<T> familia de delegados para resolver este problema. Ejemplo:

public int GetCachedValue(string p1, int p2, 
          Func<DateTime, int> getCachedValue) 
{ 
    // do some stuff in here 
    // you can call getCachedValue like any normal function from within here 
} 

Este método se llevará a tres argumentos: una cadena, un int, y una función que toma un DateTime y devuelve un int. Por ejemplo: existen

int foo = GetCachedValue("blah", 5, methodToGetFoo); // using your method 
int bar = GetCachedValue("fuzz", 1, d => d.TotalDays); // using a lambda 

Different Func<T, U, V...> etc. tipos en el marco para acomodar métodos con diferentes cantidades de argumentos.

Answer 3

Crear un delegado para el método methodToGetFoo

public delegate object GenerateValue(params p); 
public event GenerateValue OnGenerateValue; 

Definir GetCachedValue utilizar el delegado

int GetCachedValue(string key, GenerateValue functionToCall); 

Luego, en la implementación de OnGenerateValue puede comprobar la década de param.

Answer 4

Here es algo simple que comencé que se puede llevar un poco más allá (como lo hice para un proyecto comercial).

En mi caso esto fue para almacenar en caché las llamadas de servicio web, y se utilizó algo como:

WebService ws = new WebService(); 
var result = ws.Call(x => x.Foo("bar", 1)); // x is the ws instance 

Answer 5

Usando System.Action y expresión lambda (método anónimo). Por ejemplo

public void myMethod(int integer){ 

    //Do something 

} 

public void passFunction(System.Action methodWithParameters){ 

    //Invoke 
    methodWithParameters(); 

} 

//... 

//Pass anonimous method using lambda expression 
passFunction(() => myMethod(1234));