C# / VB.NET - [C#] Posso creare ad esempio un "gruppo" di textbox?

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

non è molto lantana la soluzione

infatti e proprio come hai scritto tu
ti bastava convertirla

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

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

int i = 0;
            using (StreamReader reader = new StreamReader("file.txt"))
            {
                string linea;
                while ((linea = reader.ReadLine()) != null)
                {
                    txtbox[i].Text = linea;
                    i++;
                }
            }

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...

	[DataContract]
	public class TextBoxSettings
	{
		[DataMember]
		public string Text{get;set;}
	}
	[DataContract]
	public class CheckBoxSettings
	{
		[DataMember]
		public bool Checked { get; set; }
	}
	[DataContract]
	public class RadioButtonSettings
	{
		[DataMember]
		public bool Checked { get; set; }
	}

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

  [DataContract]
   public class Settings
    {
       [DataMember]
       public TextBoxSettings txtProva { get; set; }
       [DataMember]
       public RadioButtonSettings rdbProva { get; set; }
       [DataMember]
       public CheckBoxSettings chbProva { get; set; }
    }

sucessivamente ti occorrono 2 metodi per serializzare e deserializzare la tua classe di impostazioni

        private string SerializeClass(object obj)
        {
            if (obj == null) throw new ArgumentNullException("obj");
            DataContractSerializer dcs = new DataContractSerializer(obj.GetType());
            MemoryStream ms = new MemoryStream();
            dcs.WriteObject(ms, obj);
            return Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Position);
        }

        private object DeserializeClass(Type type, string serialized)
        {
            if (type == null) throw new ArgumentNullException("type");
            if (serialized == null) throw new ArgumentNullException("serialized");
            DataContractSerializer dcs = new DataContractSerializer(type);
            MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(serialized));
            return dcs.ReadObject(ms);
        }

altri 2 metodi per salvare e caricare la classe alla chiusura e all'avvio della tua applicazioni

        
        private Settings LoadSettings()
        {
            XmlDocument xConfig = new XmlDocument();
            xConfig.Load(Application.StartupPath + @"\Config.xml");
            return (Settings)DeserializeClass(typeof(Settings), xConfig.InnerXml);
        }

        private void SaveSettings(Settings cSettings)
        {
            XmlDocument xConfig = new XmlDocument();
            xConfig.LoadXml(SerializeClass(cSettings));
            xConfig.Save(Application.StartupPath + @"\Config.xml");
        }

UTILIZZO :
Caricare un impostazione :

        txtProva.Text = Settings.txtProva.Text;

Aggiornare la classe settings :

       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

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:

//****************************************************************************************
// Rev. 0.0 - 20.11.2009            LEGGI e SCRIVI INPUT //************************************************************************
        
        // Richiede using System.IO e System.Collections
        // LeggiInputdaFileTxt e ScriviInputsuFileTxt sono due metodi per recuperare e salvare tutti gli input presenti nella "gridprincipale" nel file "nomefile"
        // Sono salvati:    - text          nelle textbox
        //                  - ischeched     di radiobutton
        //                  - ischeched     di checkbox

        public static void LeggiInputdaFileTxt(string nomefile, Grid gridprincipale)
        {
            FileStream flussobyte = File.Open(nomefile, FileMode.Open);     // la classe "filestream" definisce oggetti che rappresentano un flusso di byte. I byte possono rappresentare
                                                                            // diversi file: file testo, immagini, video, ecc...
                                                                            // il metodo open apre il file e si mette all'inizio
            StreamReader flussocaratteri = new StreamReader(flussobyte);    // la classe streamreader definisce oggetti che leggono flussi di byte e riconoscono i caratteri
            Giovanni.scorrecontrolli(gridprincipale, flussocaratteri);
            flussocaratteri.Close();
        }

        public static void ScriviInputsuFileTxt(string nomefile, Grid gridprincipale) 
        {
            FileStream flussobyte = File.Open(nomefile, FileMode.Create);   // vedi descrizione riportata per LeggiInputdaFileTxt
                                                                            // il filemode "create" crea il file, se esiste lo cancella e si posiziona all'inizio.
            StreamWriter flussocaratteri = new StreamWriter(flussobyte);
            Giovanni.scorrecontrolli(gridprincipale, flussocaratteri);
            flussocaratteri.Close();
        }
        
        public static void scorrecontrolli(object root, StreamReader flussocaratteri) // ho l'Overload di questo metodo, posso passare oggetto StreamReader o un oggetto StreamWriter
                                                        // questo metodo scorre tutti i controlli presenti nell'object specificato quando è richiamato il metodo
                                                        // l'oggetto passato deve essere la Grid principale che contiene tutto
        {
            Control control = root as Control;          // utilizzo l'operatore "as". Se il cast è positivo control è diverso da null altrimenti è null
            if (control != null)                        // verifico se il cast ha avuto successo (questo avviene quando l'oggetto non è un contenitore), nel caso positivo impongo cosa fare
            {
                // inserire l'azione da fare
                TextBox tex = control as TextBox;
                RadioButton rad = control as RadioButton;
                CheckBox cbox = control as CheckBox;
                if (tex !=null)                         // verifico se il cast ha avuto successo
                   tex.Text = flussocaratteri.ReadLine();
                if (rad != null)                        // verifico se il cast ha avuto successo
                {
                    string radvalue= flussocaratteri.ReadLine();
                    if (radvalue == "True")             
                        rad.IsChecked = true;
                    else
                        rad.IsChecked = false;
                }
                if (cbox != null)                       // verifico se il cast ha avuto successo
                {
                    string radvalue = flussocaratteri.ReadLine();
                    if (radvalue == "True")
                        cbox.IsChecked = true;
                    else
                        cbox.IsChecked = false;
                }


            }
            if (root is DependencyObject)               // verifico se l'oggetto è una DependencyObject, come un pannello ad esempio, in questo caso richiamo lo stesso metodo per 
                                                        // tutti gli elementi figlio.
            {
                foreach (object child in LogicalTreeHelper.GetChildren((DependencyObject)root))
                    scorrecontrolli(child,flussocaratteri);
            }
           
        }

Avevo dimenticato un pezzo! Ecco il codice intero.

        //*************************************************************************************************************************************************************************
        //Rev. 0.0 - 20.11.2009                                                LEGGI e SCRIVI INPUT 
        //*************************************************************************************************************************************************************************
        
        // Richiede using System.IO e System.Collections
        // LeggiInputdaFileTxt e ScriviInputsuFileTxt sono due metodi per recuperare e salvare tutti gli input presenti nella "gridprincipale" nel file "nomefile"
        // Sono salvati:    - text          nelle textbox
        //                  - ischeched     di radiobutton
        //                  - ischeched     di checkbox

        public static void LeggiInputdaFileTxt(string nomefile, Grid gridprincipale)
        {
            FileStream flussobyte = File.Open(nomefile, FileMode.Open);     // la classe "filestream" definisce oggetti che rappresentano un flusso di byte. I byte possono rappresentare
                                                                            // diversi file: file testo, immagini, video, ecc...
                                                                            // il metodo open apre il file e si mette all'inizio
            StreamReader flussocaratteri = new StreamReader(flussobyte);    // la classe streamreader definisce oggetti che leggono flussi di byte e riconoscono i caratteri
            Giovanni.scorrecontrolli(gridprincipale, flussocaratteri);
            flussocaratteri.Close();
        }

        public static void ScriviInputsuFileTxt(string nomefile, Grid gridprincipale) 
        {
            FileStream flussobyte = File.Open(nomefile, FileMode.Create);   // vedi descrizione riportata per LeggiInputdaFileTxt
                                                                            // il filemode "create" crea il file, se esiste lo cancella e si posiziona all'inizio.
            StreamWriter flussocaratteri = new StreamWriter(flussobyte);
            Giovanni.scorrecontrolli(gridprincipale, flussocaratteri);
            flussocaratteri.Close();
        }
        
        public static void scorrecontrolli(object root, StreamReader flussocaratteri) // ho l'Overload di questo metodo, posso passare oggetto StreamReader o un oggetto StreamWriter
                                                        // questo metodo scorre tutti i controlli presenti nell'object specificato quando è richiamato il metodo
                                                        // l'oggetto passato deve essere la Grid principale che contiene tutto
        {
            Control control = root as Control;          // utilizzo l'operatore "as". Se il cast è positivo control è diverso da null altrimenti è null
            if (control != null)                        // verifico se il cast ha avuto successo (questo avviene quando l'oggetto non è un contenitore), nel caso positivo impongo cosa fare
            {
                // inserire l'azione da fare
                TextBox tex = control as TextBox;
                RadioButton rad = control as RadioButton;
                CheckBox cbox = control as CheckBox;
                if (tex !=null)                         // verifico se il cast ha avuto successo
                   tex.Text = flussocaratteri.ReadLine();
                if (rad != null)                        // verifico se il cast ha avuto successo
                {
                    string radvalue= flussocaratteri.ReadLine();
                    if (radvalue == "True")             
                        rad.IsChecked = true;
                    else
                        rad.IsChecked = false;
                }
                if (cbox != null)                       // verifico se il cast ha avuto successo
                {
                    string radvalue = flussocaratteri.ReadLine();
                    if (radvalue == "True")
                        cbox.IsChecked = true;
                    else
                        cbox.IsChecked = false;
                }


            }
            if (root is DependencyObject)               // verifico se l'oggetto è una DependencyObject, come un pannello ad esempio, in questo caso richiamo lo stesso metodo per 
                                                        // tutti gli elementi figlio.
            {
                foreach (object child in LogicalTreeHelper.GetChildren((DependencyObject)root))
                    scorrecontrolli(child,flussocaratteri);
            }
           
        }
        public static void scorrecontrolli(object root, StreamWriter flussocaratteri) // ho l'Overload di questo metodo, posso passare oggetto StreamReader o un oggetto StreamWriter
                                                        // questo metodo scorre tutti i controlli presenti nell'object specificato quando è richiamato il metodo
                                                        // l'oggetto passato deve essere la Grid principale che contiene tutto
        {
            Control control = root as Control;          // utilizzo l'operatore "as". Se il cast è positivo control è diverso da null altrimenti è null
            if (control != null)                        // verifico se il cast ha avuto successo (questo avviene quando l'oggetto non è un contenitore), nel caso positivo impongo cosa fare
            {
                TextBox tex = control as TextBox;
                RadioButton rad = control as RadioButton;
                CheckBox cbox = control as CheckBox;
                if (tex != null)
                    flussocaratteri.WriteLine(tex.Text);
                if (rad != null)
                   flussocaratteri.WriteLine(rad.IsChecked);
                if (cbox != null)
                    flussocaratteri.WriteLine(cbox.IsChecked);
            }
            if (root is DependencyObject)               // verifico se l'oggetto è una DependencyObject, come un pannello ad esempio, in questo caso richiamo lo stesso metodo per 
            // tutti gli elementi figlio.
            {
                foreach (object child in LogicalTreeHelper.GetChildren((DependencyObject)root))
                    scorrecontrolli(child, flussocaratteri);
            }

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...