reciben - parametros programacion c#

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

Question

Quiero crear un genérico al que pueda pasar una función como parámetro, sin embargo, esta función puede incluir parámetros en sí misma, así que ...

int foo = GetCachedValue("LastFoo", methodToGetFoo)

Tal que

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

Esencialmente quiero tener un método que compruebe la memoria caché para un valor, de lo contrario generará el valor basado en el método pasado.

¿Pensamientos?

Answer 1

Crear un delegado para el método methodToGetFoo

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

Defina GetCachedValue para usar el delegado

int GetCachedValue(string key, GenerateValue functionToCall);

Luego, en la implementación de OnGenerateValue puede verificar los parámetros.

Answer 2

Parece que quieres un 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 envolver esto de muchas maneras; para funciones simples:

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

o donde se involucran argumentos, un cierre:

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

Answer 3

Puede crear su propio delegado, pero en C # 3.0 puede que le resulte más conveniente usar la familia de delegados Func<T> incorporada 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 tomará tres argumentos: una cadena, un int y una función que toma un DateTime y devuelve un int. Por ejemplo:

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

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

Answer 4

Usando System.Action y lambda expresión (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));

Answer 5

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

En mi caso, esto fue para cachear las llamadas de servicios web, y se utilizó algo como:

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