[C#] Puntatore di codice

[tossam]

Ciao.

Ho appena incominciato a studiare C#, e riesco a farlo velocemente per via della mia discreta conoscenza del java.
A dir la verità, ho preferito C# al solito Vb, per una questione di efficenza: ho in mente un progetto complesso, che richiede la massima efficenza. Per questo ho pensato a un linguaggio, veloce e portabile, il C#, per l'appunto. Ma veniamo al dunque...
Ho scoperto la potenzialità dei puntatori del C#, ( in realtà da come ho capito, sono dei semplici riferimenti alla memoria, no?), mi chiedevo se l'uso dei puntatori, permettesse anche di puntare a una certa sezione di codice.

Il mio problema è il seguente: A seconda di una stringa, deve essere eseguita una porzione di codice specifica. Una prima soluzione potrebbe essere la seguente:

if(valore.equals("cost1")){
...
}else if(valore.equals("cost2")){
...
} else if(valore.equals("cost3")){
...
}

se le casistiche si presentano numerose, mi accorgo immediatamente che il codice sarebbe abbastanza lento, e anche che verrebbero diciamo, preferite alcune vie (in termini di efficenza) piuttosto che altre (ad esempio cost1 viene eseguita subito, constN, invece dovrà passare tutti gli else-if)...

così mi è venuta l'idea di prendere una tabella hash, (Hashtable) e inserirvi come chiave il valore da trovare. Come vaore, mi sarebbe piaciuto inserire un puntatore che puntava ad una ruotine corrispondente.

Allora, ora che vi ho spiegato, sapete un modo per puntare a una porzione di codice dinamicamente?

[KataKlism2002]

beh, innanzi tutto potresti usare una switch invece che che una serie di if

switch(valore)
{
     case "cost1":
          ....
          ....
          break;
     case "cost2":
          ....
          ....
          break;
     case "cost3":
          ....
          ....
          break;
}

vedi se sta soluzione ti garba, se non lo facesse potrei reindirizzarti verso la soluzione che chiedi, anche se non è una strada facile da seguire perchè ti devi spippare la reflection.

[tossam]

Uhm, no che nn va bene il select case, scusa swich... hihi, colpa del basic...
Alla fine è solo un modo diverso di scrivere l'else no?
In fin dei conti ciò che nn mi garba è che proprio che questo algoritmo non gestisce bene l'efficenza, ed inoltre da maggiore priorità alla prima parola anzichè all'ultima.

E' vero che anche questo accadrebbe in un algoritmo di hash, ma almeno delego il mio problema a qualcuno che di algoritmi di ricerca se ne intende più di me, e che sicuramente ha reso più efficente la cosa.

Inoltre, se invece di ricevere valori stringa, riceverri dei numeri, il fatto è che praticamente dal punto di efficenza sarebbe perfetto:

butto i puntatori in un array, e poi eseguo il puntatore i-esimo, che corrisponde all'iesimo blocco di istruzioni. Perciò nn ci sarebbe neppure un algoritmo di ricerca in mezzo ai maroni!
E' questa la potenza che mi serve del puntatore, ma dovrei imparare come puntarli a codice.

Per il momento sto comunque progettando un namespace che contanga molte classi, ognuna delle quali risolva una classe di problemi, poi pensavo di buttarli tutti ( ovviamente istanziati come oggetti) nel vettore o nella tabella di hash secondo l'esigenza, e il giochetto è fatto. Solo che un oggetto penso che sia molto meno efficente da utilizzare piuttosto che un puntatore...

dunque se perfavore mi puoi spiegare come fare.. intanto incomincio a studiarmi la reflection va... così ti facilito la tua spiegazione poi senza farti troppe domande...

grazie!

[tossam]

Uhm... ho letto qualcosa sui reflection...
Dici che dovrei inizializzare un oggetto contenente tutti i metodi, per poi usando la riflessione, per mezzo di un foreach, costruirmi una tabella di hash che ha per chiavi i nomi dei metodi, e per valori i corrispondenti oggetti di tipo MethodInfo...
Per poi, in seguito fare in questo modo:

((MethodInfo)myHash[value]).Invoke(myObject,myArgs);

in questo modo posso anche passare tramite un array di object gli argomenti! fantastico...
Sembra una buona soluzione.
Sicuramente è migliore del namespace contenente tante classi quanti i metodi da impostare! hihi
Se poi riesco in un qualche modo a scartare l'hashTable e a utilizzare un sano array così non utilizzo algoritmi di ricerca è ancora meglio...

beh grazie. hai detto quella parola magica che mi ha aiutato: "Riflessione"...

Ciao! E grazie ancora!

[MItaly]

L'uso della reflection è sicuramente più lento di un semplice switch, visto che è una delle caratteristiche meno efficienti del .NET Framework.
Piuttosto associa ad ogni elemento un delegate:

using System.Collections.Generic;
delegate void tuoDelegato();
//...
class TuaClasse
{
    public static void TuoMetodo1()
    {
        //codice
    }
    //...
    public void TuoMetodo2()
    {
        //codice
    }
}
//...
Dictionary<string, tuoDelegato> hashTable = new Dictionary<string, tuoDelegato>;
//esempio con un metodo statico
hashTable.Add("chiave1", new tuoDelegato(TuaClasse.TuoMetodo1));
//esempio con un metodo d'istanza
TuaClasse tc = new TuaClasse;
hashTable.Add("chiave2", new tuoDelegato(tc.TuoMetodo2));
//...
hashTable["chiave1"](); //chiama TuaClasse.TuoMetodo1
hashTable["chiave2"](); //chiama tc.TuoMetodo2

.
L'uso dei delegate tra l'altro è quanto di più vicino a quanto avevi chiesto all'inizio, dato che un delegate è un puntatore a metodo "sicuro" (dato che ne ricorda la signature e consente di chiamarlo solo in modo corretto).

[tossam]

Ecco! grande! questo è proprio quello che cercavooo!
Bravissimo, grazie mille!

In poche parole delegate permette di usare le variabili come metodi no?
Stupendo, credo che mi servirà molto delegate, anche per altre cose... Grazie ancora!

[oregon]

I delegate sono l' "equivalente" dei puntatori a funzione del C, ma sono type-safe e sicuri.

Delegate (C# Reference)
http://msdn2.microsoft.com/en-us/lib...8e(VS.80).aspx