Buongiorno,
perdonami, credo di aver capito cosa volevi fare solo ora... 
in pratica, correggimi se sbaglio, vorresti estendere alcuni metodi con del codice che fa una determinata cosa, e per non stare a modificare il tutto vorresti fare un codice standard che va bene senza modifiche in ogni metodo nella quale posizionerai il codice, senza preoccuparti di modificarlo in base a i parametri passati, è corretto adesso?
se ho compreso bene il concetto purtroppo ti devo dare una cattiva notizia : non si può fare con la reflection. Perlomeno non in maniera semplice, credo che potresti andare a cercare i valori all'interno dello stack, ma io onestamente lo sconsiglio vivamente, anche perchè con una eventuale modifica rischieresti di fare davvero un casino.
In realtà potresti fare una cosa che a mio parere potrebbe essere anche più elegante come soluzione, ovvero l'uso degli Extension Method in questo modo :
codice:
namespace ExtensionMethods
{
class Program
{
static void Main(string[] args)
{
Class1 c1 = new Class1();
dynamic test = c1.MyCodeExtension("Method1", "parameter Value", 1);
Console.WriteLine(test);
test = c1.MyCodeExtension("Method2", 1, 1);
Console.WriteLine(string.Format("result = {0}", test));
//void
c1.MyCodeExtension("Method3");
//chiamato con metodo tradizionale non aggiunge +1 a intParameter
test = c1.Method2(1,1);
Console.WriteLine(string.Format("result = {0}", test));
}
}
public class Class1
{
public string Method1(string stringParameter, int intParameter)
{
return string.Format("type : {2}. this is stringParameter : {0} and this is intParameter : {1}", stringParameter, intParameter, this.GetType().Name);
}
public int Method2(int stringParameter, int intParameter)
{
return stringParameter + intParameter;
}
public void Method3()
{
Console.WriteLine("in Method3");
}
}
public static class Extension
{
public static dynamic MyCodeExtension<T>(this T obj, string Method, params object[] Parameters)
{
int i=0;
MethodInfo mi = typeof(T).GetMethod(Method);
if (Parameters.Length > 0)
{
Dictionary<string, dynamic> parameterObjList = new Dictionary<string, dynamic>();
ParameterInfo[] pInfo = mi.GetParameters();
pInfo.OrderBy(o => o.Position).ToList()
.ForEach(f =>
parameterObjList.Add(f.Name, Parameters[i++])
);
//Qui inserisci il codice di estensione.
//Ad esempio sotto richiamo il parametro con il nome da una stringa elo stampo a video
Console.WriteLine(parameterObjList["stringParameter"]);
//qui invece modifico il valore passato al metodo in modo
//che agginga +1 al parametro numerico prima di passarlo al metodo reale
parameterObjList["intParameter"]++;
Parameters = parameterObjList.Values.ToArray();
}
//restituisci il valore del metodo tradizionale e passi i parametri
//eventualmente modificati
return mi.Invoke(obj, Parameters);
}
}
}
in questo modo non dovrai includere il codice in ogni metodo, ti basterà aggiungerlo solo nel metodo di estensione nella classe statica (Extension) e dovrai solo chiamare il metodo in modo un po diverso, ovvero anzichè così :
codice:
Class1 c1 = new Class1();
c1.Method1("parameter Value", 1);
lo farai così :
codice:
Class1 c1 = new Class1();
c1.MyCodeExtension("Method1", "parameter Value", 1);
ma potrai ancora chiamarlo in modo tradizionale (non eseguirà il codice aggiuntivo) e chiamerai in questo modo solo i metodi nella quale ti serve (in qualsiasi metodo di qualsiasi classe tu voglia senza aggiungere codice) il codice aggiuntivo e solo se in quel momento ti serve.
Spero di aver capito bene stavolta 
Rispondi quotando
