Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C# / VB.NET - [C#] Posso creare ad esempio un
Forum - C# / VB.NET - [C#] Posso creare ad esempio un "gruppo" di textbox?

Avatar
mg (Normal User)
Rookie


Messaggi: 39
Iscritto: 19/11/2009

Segnala al moderatore
Postato alle 12:26
Giovedì, 19/11/2009
Sono alle prime armi.
OBIETTIVO: vorrei poter salvare in un file testo tutti gli input di un programma, input che possono essere inseriti in textbox, combobox, radiobutton e checkbox. In questo modo quando riapro lo stesso programma faccio leggere il file testo e mi si presentano gli ultimi input inseriti.

con VB creavo dei "gruppi" di controlli, ad esempio le textbox erano text1(1), text1(2), .... , text1(i), ecc... impostavo poi un ciclo for che salvava tutti i text delle textbox facendo variare l'indice i.
Vorrei poter creare le textbox(i) non a livello di codice ma nella form. In Vb dopo aver inserito il controllo nella proprietà nome aggiungevo in parte al nome (i) e si creava in automatico.

E' possibile fare qualcosa di simile in C#?
Per il mio "OBIETTIVO" probabilmente ci sono molti modi per raggiungerlo, qualche consiglio?

grazie a tutti
Marco



GIo e MAti - una sola parola: fantastici
PM Quote
Avatar
Thejuster (Member)
Guru^2


Messaggi: 1750
Iscritto: 04/05/2008

Segnala al moderatore
Postato alle 10:51
Venerdì, 20/11/2009
non è molto lantana la soluzione

infatti e proprio come hai scritto tu
ti bastava convertirla

Codice sorgente - presumibilmente C# / VB.NET

  1. TextBox[] txtbox = new TextBox[10];
  2. txtbox[0].Text = "quello che vuoi";




stessa cosa per recuperare il valore dalla matrice,
anziché usare un numero usi la i nel ciclo.

Codice sorgente - presumibilmente C#

  1. int i = 0;
  2.             using (StreamReader reader = new StreamReader("file.txt"))
  3.             {
  4.                 string linea;
  5.                 while ((linea = reader.ReadLine()) != null)
  6.                 {
  7.                     txtbox[i].Text = linea;
  8.                     i++;
  9.                 }
  10.             }




Ultima modifica effettuata da Thejuster il 20/11/2009 alle 10:56


PM Quote
Avatar
Gianluca87 (Ex-Member)
Expert


Messaggi: 300
Iscritto: 16/11/2008

Segnala al moderatore
Postato alle 12:00
Venerdì, 20/11/2009
propongo una soluzione a oggetti...
una classe Settings e n tipi classi per ogni tipo di oggetto conteneti le proprietà da salvare per ogni oggetto...
ad esempio per gli oggetti che hai citato...
Codice sorgente - presumibilmente C#

  1. [DataContract]
  2.         public class TextBoxSettings
  3.         {
  4.                 [DataMember]
  5.                 public string Text{get;set;}
  6.         }
  7.         [DataContract]
  8.         public class CheckBoxSettings
  9.         {
  10.                 [DataMember]
  11.                 public bool Checked { get; set; }
  12.         }
  13.         [DataContract]
  14.         public class RadioButtonSettings
  15.         {
  16.                 [DataMember]
  17.                 public bool Checked { get; set; }
  18.         }


ok una volta create le classi per i tipi di oggetti devi creare una classe che contenga tutte le classi per ogni oggetto che vuoi salvare del tipo di oggetto che vuoi salvare
quindi ad esempio per txtProva, chbProva, rdbProva
Codice sorgente - presumibilmente Delphi

  1. [DataContract]
  2.    public class Settings
  3.     {
  4.        [DataMember]
  5.        public TextBoxSettings txtProva { get; set; }
  6.        [DataMember]
  7.        public RadioButtonSettings rdbProva { get; set; }
  8.        [DataMember]
  9.        public CheckBoxSettings chbProva { get; set; }
  10.     }


sucessivamente ti occorrono 2 metodi per serializzare e deserializzare la tua classe di impostazioni
Codice sorgente - presumibilmente C#

  1. private string SerializeClass(object obj)
  2.         {
  3.             if (obj == null) throw new ArgumentNullException("obj");
  4.             DataContractSerializer dcs = new DataContractSerializer(obj.GetType());
  5.             MemoryStream ms = new MemoryStream();
  6.             dcs.WriteObject(ms, obj);
  7.             return Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Position);
  8.         }
  9.  
  10.         private object DeserializeClass(Type type, string serialized)
  11.         {
  12.             if (type == null) throw new ArgumentNullException("type");
  13.             if (serialized == null) throw new ArgumentNullException("serialized");
  14.             DataContractSerializer dcs = new DataContractSerializer(type);
  15.             MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(serialized));
  16.             return dcs.ReadObject(ms);
  17.         }


altri 2 metodi per salvare e caricare la classe alla chiusura e all'avvio della tua applicazioni
Codice sorgente - presumibilmente C++

  1. private Settings LoadSettings()
  2.         {
  3.             XmlDocument xConfig = new XmlDocument();
  4.             xConfig.Load(Application.StartupPath + @"\Config.xml");
  5.             return (Settings)DeserializeClass(typeof(Settings), xConfig.InnerXml);
  6.         }
  7.  
  8.         private void SaveSettings(Settings cSettings)
  9.         {
  10.             XmlDocument xConfig = new XmlDocument();
  11.             xConfig.LoadXml(SerializeClass(cSettings));
  12.             xConfig.Save(Application.StartupPath + @"\Config.xml");
  13.         }



UTILIZZO :
Caricare un impostazione :
Codice sorgente - presumibilmente Plain Text

  1. txtProva.Text = Settings.txtProva.Text;


Aggiornare la classe settings :
Codice sorgente - presumibilmente Plain Text

  1. Settings.txtProva.Text = txtProva.Text;



CONSIDERAZIONI :
con questo metodo non devi gestire cicli, è più flessibile perchè ti consente di salvare quante proprietà vuoi per ogni oggetto e differenziare le proprietà per tipo di oggetto che intendi salvare ;)

Ultima modifica effettuata da Gianluca87 il 20/11/2009 alle 12:03


a domanda precisa, risposta precisa...
a domanda generica, risposta generica...
PM Quote
Avatar
mg (Normal User)
Rookie


Messaggi: 39
Iscritto: 19/11/2009

Segnala al moderatore
Postato alle 14:29
Venerdì, 20/11/2009
Prima di leggere le vostre risposte, per riuscire a fare quanto specificato nell'"obiettivo" del primo post ero giunto a questa soluzione. Essendo assai inesperto probabilmente è da migliorare. Ora con calma leggo i vostri consigli e colgo l'occasione per ringraziarvi.

Ecco la mia "modesta" soluzione:

Codice sorgente - presumibilmente C# / VB.NET

  1. //****************************************************************************************
  2. // Rev. 0.0 - 20.11.2009            LEGGI e SCRIVI INPUT //************************************************************************
  3.        
  4.         // Richiede using System.IO e System.Collections
  5.         // LeggiInputdaFileTxt e ScriviInputsuFileTxt sono due metodi per recuperare e salvare tutti gli input presenti nella "gridprincipale" nel file "nomefile"
  6.         // Sono salvati:    - text          nelle textbox
  7.         //                  - ischeched     di radiobutton
  8.         //                  - ischeched     di checkbox
  9.  
  10.         public static void LeggiInputdaFileTxt(string nomefile, Grid gridprincipale)
  11.         {
  12.             FileStream flussobyte = File.Open(nomefile, FileMode.Open);     // la classe "filestream" definisce oggetti che rappresentano un flusso di byte. I byte possono rappresentare
  13.                                                                             // diversi file: file testo, immagini, video, ecc...
  14.                                                                             // il metodo open apre il file e si mette all'inizio
  15.             StreamReader flussocaratteri = new StreamReader(flussobyte);    // la classe streamreader definisce oggetti che leggono flussi di byte e riconoscono i caratteri
  16.             Giovanni.scorrecontrolli(gridprincipale, flussocaratteri);
  17.             flussocaratteri.Close();
  18.         }
  19.  
  20.         public static void ScriviInputsuFileTxt(string nomefile, Grid gridprincipale)
  21.         {
  22.             FileStream flussobyte = File.Open(nomefile, FileMode.Create);   // vedi descrizione riportata per LeggiInputdaFileTxt
  23.                                                                             // il filemode "create" crea il file, se esiste lo cancella e si posiziona all'inizio.
  24.             StreamWriter flussocaratteri = new StreamWriter(flussobyte);
  25.             Giovanni.scorrecontrolli(gridprincipale, flussocaratteri);
  26.             flussocaratteri.Close();
  27.         }
  28.        
  29.         public static void scorrecontrolli(object root, StreamReader flussocaratteri) // ho l'Overload di questo metodo, posso passare oggetto StreamReader o un oggetto StreamWriter
  30.                                                         // questo metodo scorre tutti i controlli presenti nell'object specificato quando è richiamato il metodo
  31.                                                         // l'oggetto passato deve essere la Grid principale che contiene tutto
  32.         {
  33.             Control control = root as Control;          // utilizzo l'operatore "as". Se il cast è positivo control è diverso da null altrimenti è null
  34.             if (control != null)                        // verifico se il cast ha avuto successo (questo avviene quando l'oggetto non è un contenitore), nel caso positivo impongo cosa fare
  35.             {
  36.                 // inserire l'azione da fare
  37.                 TextBox tex = control as TextBox;
  38.                 RadioButton rad = control as RadioButton;
  39.                 CheckBox cbox = control as CheckBox;
  40.                 if (tex !=null)                         // verifico se il cast ha avuto successo
  41.                    tex.Text = flussocaratteri.ReadLine();
  42.                 if (rad != null)                        // verifico se il cast ha avuto successo
  43.                 {
  44.                     string radvalue= flussocaratteri.ReadLine();
  45.                     if (radvalue == "True")            
  46.                         rad.IsChecked = true;
  47.                     else
  48.                         rad.IsChecked = false;
  49.                 }
  50.                 if (cbox != null)                       // verifico se il cast ha avuto successo
  51.                 {
  52.                     string radvalue = flussocaratteri.ReadLine();
  53.                     if (radvalue == "True")
  54.                         cbox.IsChecked = true;
  55.                     else
  56.                         cbox.IsChecked = false;
  57.                 }
  58.  
  59.  
  60.             }
  61.             if (root is DependencyObject)               // verifico se l'oggetto è una DependencyObject, come un pannello ad esempio, in questo caso richiamo lo stesso metodo per
  62.                                                         // tutti gli elementi figlio.
  63.             {
  64.                 foreach (object child in LogicalTreeHelper.GetChildren((DependencyObject)root))
  65.                     scorrecontrolli(child,flussocaratteri);
  66.             }
  67.            
  68.         }




GIo e MAti - una sola parola: fantastici
PM Quote
Avatar
mg (Normal User)
Rookie


Messaggi: 39
Iscritto: 19/11/2009

Segnala al moderatore
Postato alle 14:33
Venerdì, 20/11/2009
Avevo dimenticato un pezzo! Ecco il codice intero.

Codice sorgente - presumibilmente C# / VB.NET

  1. //*************************************************************************************************************************************************************************
  2.         //Rev. 0.0 - 20.11.2009                                                LEGGI e SCRIVI INPUT
  3.         //*************************************************************************************************************************************************************************
  4.        
  5.         // Richiede using System.IO e System.Collections
  6.         // LeggiInputdaFileTxt e ScriviInputsuFileTxt sono due metodi per recuperare e salvare tutti gli input presenti nella "gridprincipale" nel file "nomefile"
  7.         // Sono salvati:    - text          nelle textbox
  8.         //                  - ischeched     di radiobutton
  9.         //                  - ischeched     di checkbox
  10.  
  11.         public static void LeggiInputdaFileTxt(string nomefile, Grid gridprincipale)
  12.         {
  13.             FileStream flussobyte = File.Open(nomefile, FileMode.Open);     // la classe "filestream" definisce oggetti che rappresentano un flusso di byte. I byte possono rappresentare
  14.                                                                             // diversi file: file testo, immagini, video, ecc...
  15.                                                                             // il metodo open apre il file e si mette all'inizio
  16.             StreamReader flussocaratteri = new StreamReader(flussobyte);    // la classe streamreader definisce oggetti che leggono flussi di byte e riconoscono i caratteri
  17.             Giovanni.scorrecontrolli(gridprincipale, flussocaratteri);
  18.             flussocaratteri.Close();
  19.         }
  20.  
  21.         public static void ScriviInputsuFileTxt(string nomefile, Grid gridprincipale)
  22.         {
  23.             FileStream flussobyte = File.Open(nomefile, FileMode.Create);   // vedi descrizione riportata per LeggiInputdaFileTxt
  24.                                                                             // il filemode "create" crea il file, se esiste lo cancella e si posiziona all'inizio.
  25.             StreamWriter flussocaratteri = new StreamWriter(flussobyte);
  26.             Giovanni.scorrecontrolli(gridprincipale, flussocaratteri);
  27.             flussocaratteri.Close();
  28.         }
  29.        
  30.         public static void scorrecontrolli(object root, StreamReader flussocaratteri) // ho l'Overload di questo metodo, posso passare oggetto StreamReader o un oggetto StreamWriter
  31.                                                         // questo metodo scorre tutti i controlli presenti nell'object specificato quando è richiamato il metodo
  32.                                                         // l'oggetto passato deve essere la Grid principale che contiene tutto
  33.         {
  34.             Control control = root as Control;          // utilizzo l'operatore "as". Se il cast è positivo control è diverso da null altrimenti è null
  35.             if (control != null)                        // verifico se il cast ha avuto successo (questo avviene quando l'oggetto non è un contenitore), nel caso positivo impongo cosa fare
  36.             {
  37.                 // inserire l'azione da fare
  38.                 TextBox tex = control as TextBox;
  39.                 RadioButton rad = control as RadioButton;
  40.                 CheckBox cbox = control as CheckBox;
  41.                 if (tex !=null)                         // verifico se il cast ha avuto successo
  42.                    tex.Text = flussocaratteri.ReadLine();
  43.                 if (rad != null)                        // verifico se il cast ha avuto successo
  44.                 {
  45.                     string radvalue= flussocaratteri.ReadLine();
  46.                     if (radvalue == "True")            
  47.                         rad.IsChecked = true;
  48.                     else
  49.                         rad.IsChecked = false;
  50.                 }
  51.                 if (cbox != null)                       // verifico se il cast ha avuto successo
  52.                 {
  53.                     string radvalue = flussocaratteri.ReadLine();
  54.                     if (radvalue == "True")
  55.                         cbox.IsChecked = true;
  56.                     else
  57.                         cbox.IsChecked = false;
  58.                 }
  59.  
  60.  
  61.             }
  62.             if (root is DependencyObject)               // verifico se l'oggetto è una DependencyObject, come un pannello ad esempio, in questo caso richiamo lo stesso metodo per
  63.                                                         // tutti gli elementi figlio.
  64.             {
  65.                 foreach (object child in LogicalTreeHelper.GetChildren((DependencyObject)root))
  66.                     scorrecontrolli(child,flussocaratteri);
  67.             }
  68.            
  69.         }
  70.         public static void scorrecontrolli(object root, StreamWriter flussocaratteri) // ho l'Overload di questo metodo, posso passare oggetto StreamReader o un oggetto StreamWriter
  71.                                                         // questo metodo scorre tutti i controlli presenti nell'object specificato quando è richiamato il metodo
  72.                                                         // l'oggetto passato deve essere la Grid principale che contiene tutto
  73.         {
  74.             Control control = root as Control;          // utilizzo l'operatore "as". Se il cast è positivo control è diverso da null altrimenti è null
  75.             if (control != null)                        // verifico se il cast ha avuto successo (questo avviene quando l'oggetto non è un contenitore), nel caso positivo impongo cosa fare
  76.             {
  77.                 TextBox tex = control as TextBox;
  78.                 RadioButton rad = control as RadioButton;
  79.                 CheckBox cbox = control as CheckBox;
  80.                 if (tex != null)
  81.                     flussocaratteri.WriteLine(tex.Text);
  82.                 if (rad != null)
  83.                    flussocaratteri.WriteLine(rad.IsChecked);
  84.                 if (cbox != null)
  85.                     flussocaratteri.WriteLine(cbox.IsChecked);
  86.             }
  87.             if (root is DependencyObject)               // verifico se l'oggetto è una DependencyObject, come un pannello ad esempio, in questo caso richiamo lo stesso metodo per
  88.             // tutti gli elementi figlio.
  89.             {
  90.                 foreach (object child in LogicalTreeHelper.GetChildren((DependencyObject)root))
  91.                     scorrecontrolli(child, flussocaratteri);
  92.             }




GIo e MAti - una sola parola: fantastici
PM Quote
Avatar
Gianluca87 (Ex-Member)
Expert


Messaggi: 300
Iscritto: 16/11/2008

Segnala al moderatore
Postato alle 21:04
Venerdì, 20/11/2009
ho guardato un pò il tuo codice, complimenti per l'impegno!
se funziona e ti soddisfa sicuramente è la scelta migliore...
mano a mano che aumenta il numero di oggetti temo che ti troverai in difficoltà...
prova a guardare l'esempio che ti ho dato...


a domanda precisa, risposta precisa...
a domanda generica, risposta generica...
PM Quote