Newsgroup: it.comp.dotnet
Titolo: VB net - Structured Enums

Avete idea se qualche workaround consenta di emularle, o cmq 
conoscete qualche tecnica per implementarne ?
 
Per structured enums intendo una gerarchia di costanti 
accessibili con una sintassi abbastanza simile a quella di 
una serie di namespaces nidificati, però maggiormente type 
safe (e presumo anche più efficienti).
 
ciao e grazie
Soviet_Mario
 

 qualche tecnica per implementarne ?
 
classi statiche (shared in vb) che espogono proprietà readonly di tipo 
enum, potrebbero andare bene?
 
in c# sarebbe una del tipo:
 
static class Foo
{
   static class Bar
   {
       public static readonly MyEnumType Value = MyEnumType.Value;
   }
}
 
se ho capito bene cosa intendi
 
.m
 
-- 
blog @ //
milestone.topics.it
 
 
 

Ciao Soviet_Mario,

mollo, io e le union non andiamo per n ulla d'accordo, ci vuole Raff 
:-)



 
Per essere sicuro se fare una new o riusare l'oggetto ti conviene usare 
(come si fa anche in C++) il factory pattern --> costruttore privato e 
metodo statico pubblico che genera o riusa le istanze.
 
Il comportamento standard di .net è semplice: i reference value (cioè 
tutte le classi sono reference, quindi hai in mano un puntatore. Se lo 
copi (a = b) non fai altro che duplicare il reference e non l'istanza.
Se vuoi creare un'istanza devi fare new, fine del gioco.
 
Se invece hai valuetype (le struct), hai in mano direttamente l'oggetto 
che è allocato sullo stack (no gc) e ogni volta che fai (x = y) o lo 
passi ad un metodo ne istanzi uno nuovo.
 
Se hai grafi complessi da costruire, devi necessariemente crearti una 
tua struttura prevedendo liste di reference.
 
Se vuoi costruire un grafo strong-typed dinamicamente, ti conviene 
generare dinamicamente il codice C# per quel grafo.
 
 
Non so bene cosa ci vuoi fare, quindi non so dirti di più....
 
-- 
Raffaele Rialdi  
http://www.iamraf.net
 
Weblog: 
http://blogs.ugidotnet.org/raffaele
 
Microsoft MVP profile 
https://mvp.support.microsoft.com/profile/raffaele
 
UGIdotNET - 
http://www.ugidotnet.org/
 
 
 


 
LOL, non ho capito cosa c'entrino le union, ma vabbè :)



 
mi hai già dato molte spiegazioni e spunti. Ma non sono 
sicuro di sapere cosa intendi per generare codice 
dinamicamente (C# non l'ho nemmeno mai usato). Intuisco che 
non c'entri niente coi template. Forse con le macro ?
In VB si può ? Ho visto che c'è una categoria di cose (tipo 
TypeBuilder) che non ho mai usato, ti riferivi a queste 
funzionalità ?
Ciao
e grazie
Soviet
 


 
Puoi generare codice C# in tanti modi. Il più semplice è via testo 
(concateni con uno stringbuilder) ma è anche intricato.
Il più complesso è via "CodeDom".
Il futuro è via "Roslyn" che è attualmente in ctp.
 
Ma qui il discorso si allarga troppo :)


 Il futuro è via "Roslyn" che è attualmente in ctp.
 
Si forse questa roba è troppo avanzata.
Cmq grazie dei ripassi !
ciao
Soviet


 lo vedrebbe ?). Avresti qualche termine di ricerca per poter cercare info ?
 
Semplicemente perché il compilatore è disponibile nel 
framework.net
 
anche senza sistema di sviluppo.
Quindi puoi creare una classe, compilarla, caricarla in memoria ed 
eseguire il suo codice.
 
 
Ciao!


 anche senza sistema di sviluppo.
 
e viene invocato da dentro il codice stesso, per produrre 
altro codice "online", cioè dinamicamente chiamabile non 
appena tornati dalla chiamata al compilatore ?
 
Co-domanda : questo compilatore è parte dell'eseguibile o se 
ne assume l'esistenza separatamente ? E se è la prima, 
ammettendo di non invocarlo mai, non viene linkato, vero ? 
Ma penserei la seconda ... mah
 
grazie delle dritte
Soviet



Ciao,
sono rimasto incuriosito dal tuo problema, ci ho giochicchiato un poco e 
sono giunto ad un abbozzo di soluzione che potrebbe o divertirti o 
interessarti. Il concetto è quello di sostituire i puntatori con delle 
specie di handle. L'esempio che ti propongo è uno dei più classici: 
caricamento ordinato di un albero binario (Button1) e stampa ordinata 
(Button2). E' solo un abbozzo, quindi ti prego di non riderne in modo 
eccessivamente sguaiato:
 
- 2 Button + 1 TextBox
-------------------------
     struct tree
     {
         public int tok;
         public int id_l;
         public int id_h;
     }
 
 
     public partial class Form1 : Form
     {
         Dictionary<int, tree> cGrafo = new Dictionary<int, tree>();
         static int next = 0;
 
         public Form1()
         {
             InitializeComponent();
         }
 
         private void button1_Click(object sender, EventArgs e)
         {
             List<int> lTok = new List<int>{
                                 7, 5, 2, 8, 6, 3
                             };
             int ID = 0, prev;
             tree cur;
             cGrafo.Clear();
             cGrafo.Add(0, new tree { tok = 0, id_l = -1, id_h = -1 });
             foreach (int i in lTok)
             {
                 cur = cGrafo[0];
                 prev = 0;
                 while(cur.tok != i)
                 {
                     if (i < cur.tok)
                     {
                         if (cGrafo.ContainsKey(cur.id_l))
                         {
                             prev = cur.id_l;
                             cur = cGrafo[cur.id_l];
                         }
                         else
                         {
                             cGrafo.Add(++ID, new tree() { tok = i, id_h 
= -1, id_l = -1  });
                             cur.id_l = ID;
                             cGrafo[prev] = cur;
                         }
                     }
                     else if (i > cur.tok)
                     {
                         if (cGrafo.ContainsKey(cur.id_h))
                         {
                             prev = cur.id_h;
                             cur = cGrafo[cur.id_h];
                         }
                         else
                         {
                             cGrafo.Add(++ID, new tree() { tok = i, id_h 
= -1, id_l = -1 });
                             cur.id_h = ID;
                             cGrafo[prev] = cur;
                         }
                     }
                 }
 
             }
         }
 
         private void button2_Click(object sender, EventArgs e)
         {
             SGrafo(0);
         }
 
         private bool SGrafo(int id)
         {
             if(cGrafo.ContainsKey(id))
             {
                 SGrafo(cGrafo[id].id_l);
                 listBox1.Items.Add(cGrafo[id].tok);
                 SGrafo(cGrafo[id].id_h);
                 return true;
             }
             return false;
         }
     }
 
-------------------------
Spero ti sia utile.

 eccessivamente sguaiato:
 
Ciao ... figurati ! Anzi ti ringrazio molto dell'interessamento.
Ora ho una settimana di consigli di classe, ma appena 
possibile mi studio il tuo codice (a colpo d'occhio mi pare 
un albero binario ? Ma basterebbe mettere un'array di 
handles invece che solo h e l, vero ?
Alla prox
ciao
Soviet
 
Ah ... PS. Non sei il primo che mi risponde in C#. In 
effetti sto usando VB (e in C++ so programmare solo unmanaged)
 
riciao


 VB (e in C++ so programmare solo unmanaged)
 
Questo è il minore dei miei problemi, anzi, ne ho approfittato per 
scriverla meglio e rendere ricorsivo anche l'inserimento. Sempre 
mettendo 2 button e una listbox in un form:
 
Structure tree
     Dim token As Integer
     Dim id_l, id_h As Integer
End Structure
 
Public Class Form1
     Dim t As New AdmTree
 
     Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As 
System.EventArgs) Handles Button1.Click
         Dim lTok As New List(Of Integer)(New Integer() { _
         7, 5, 2, 8, 6, 3, 4, 9, -2 _
         })
         For Each tok As Integer In lTok
             t.Add(tok)
         Next
     End Sub
 
     Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As 
System.EventArgs) Handles Button2.Click
         Dim oList As New List(Of Integer)
 
         ListBox1.Items.Clear()
 
         ListBox1.Items.Add("Ascend")
         oList.Clear()
         t.GetAscendL(0, oList)
         For Each l As Integer In oList
             ListBox1.Items.Add(l)
         Next
 
         ListBox1.Items.Add("Descend")
         oList.Clear()
         t.GetDescendL(0, oList)
         For Each l As Integer In oList
             ListBox1.Items.Add(l)
         Next
     End Sub
End Class
 
Class AdmTree
     Private cGrafo As New Dictionary(Of Integer, tree)
     Private Changed As Boolean = False
     Private _ID As Integer = 0
 
     Public Sub Add(ByRef t As Integer)
         If cGrafo.ContainsKey(0) Then
             tInsert(0, t)
         Else
             cGrafo.Add(_ID, New tree() With {.token = t, .id_l = -1, 
.id_h = -1})
         End If
         _ID += 1
     End Sub
 
     Private Function tInsert(ByVal id As Integer, ByRef t As Integer) 
As Integer
         Dim _t As tree
 
         If cGrafo.TryGetValue(id, _t) Then
             If t > _t.token Then
                 _t.id_h = tInsert(_t.id_h, t)
             ElseIf t < _t.token Then
                 _t.id_l = tInsert(_t.id_l, t)
             End If
             If Changed Then
                 cGrafo(id) = _t
                 Changed = False
             End If
             tInsert = id
         Else
             cGrafo.Add(_ID, New tree() With {.token = t, .id_l = -1, 
.id_h = -1})
             Changed = True
             tInsert = _ID
         End If
     End Function
 
     Public Function GetAscendL(ByVal id As Integer, ByRef l As List(Of 
Integer)) As Boolean
         If cGrafo.ContainsKey(id) Then
             GetAscendL(cGrafo(id).id_l, l)
             l.Add(cGrafo(id).token)
             GetAscendL(cGrafo(id).id_h, l)
             Return True
         End If
         Return False
     End Function
 
     Public Function GetDescendL(ByVal id As Integer, ByRef l As List(Of 
Integer)) As Boolean
         If cGrafo.ContainsKey(id) Then
             GetDescendL(cGrafo(id).id_h, l)
             l.Add(cGrafo(id).token)
             GetDescendL(cGrafo(id).id_l, l)
             Return True
         End If
         Return False
     End Function
End Class

 cGrafo.Add(_ID, New tree() With {.token = t, .id_l = -1, ..id_h = -1})



 
È semplicemente parte del framework per cui le sue dll vengono caricate 
in memoria solo se le usi. Le normali app non lo usano.


Il 27/11/2011 12:19, Raffaele Rialdi [MVP] ha scritto:
 
CUT ALL
 
ri-grazie di tutte le spiegazioni
ciao
Soviet