Hallo Th69,
Vielen Dank für deine Antwort.
Die Methode GetLocalPathConfigSettings() sieht so korrekt aus.
Ok wenigstens etwas obwohl es ja dein Verdienst ist.
Ich kapier es nicht wie ich diese 5 Methodenaufrufe aus der Methode GetLocalPathConfigSettings()
MainForm
public void GetLocalPathConfigSettings()
{
var settings = Settings.Default;
settings.SetControlTexts(tbLocalAppNames, "LocalAppName");
settings.SetControlTexts(tbSourceFilePathLocalApps, "LocalAppFilePath");
settings.SetControlTexts(tbSetPointFileLocalApps, "SetPointLocalApp");
settings.SetCheckBoxes(cbActivateLocalApps, "LocalAppAktiv");
settings.SetCheckBoxes(cbActivateCode2LocalApps, "ActivateCode2LocalApp");
}
hier in die 2 Methoden reinbringe.
Settings.cs
using System.Windows.Forms;
namespace PDE.Properties
{
internal sealed partial class Settings
{
#######################################################################
Ich denke hier brauche ich noch neue arrays aber ich weiß es nicht und das ist das was mich ärgert.
#######################################################################
internal void SetControlTexts(Control[] tbLocalAppNames, string v) <-- //tbLocalAppNames muss falsch sein
{
?
}
internal void SetCheckBoxes(CheckBox[] ?, string v)
{
for (int i = 0; i < ?.Length; i++)
{
?[i].Checked = (bool)Settings.Default[v + (i + 1)];
}
}
Es tut mir Leid aber das überfordert mich doch, alles in der Mainform zu machen ist eine Sache
aber mit einer Klasse in Zusammenspiel ist zu viel für mich.
Das ihr Euch das alles merken könnt wo Ihr was braucht (referenzieren, instanziieren, ....usw.)
Da muss ich mir noch viele Beispiele im Internet anschauen. Kennst du ein Beispiel was mir helfen könnte?
Das ich es vielleicht dadurch erarbeiten kann.
Vielen Dank für Deine Hilfe und Geduld.
Grüße Tommylik
Hallo Abt,
Vielen Dank für deine Antwort.
Das Prinzip nennt sich DRY => Don’t repeat yourself
Das kenne ich und deswegen bin ich ja dabei das mit den Schleifen zu lernen.
Ich möchte ja selber keinen Code der sich wiederholt. Nur die Umsetzung ist halt nicht so einfach.
Dann habe ich noch eine Frage. Ich kann also alles was in der Settings.cs auf 2 Methoden einkürzen.
Ist denn was ich in der MainForm gemacht habe richtig?
Oder muss das so aussehen? Mit SetControlTexts und SetCheckBoxes
public void GetLocalPathConfigSettings()
{
var settings = Settings.Default;
settings.SetControlTexts(tbLocalAppNames, "LocalAppName");
settings.SetControlTexts(tbSourceFilePathLocalApps, "LocalAppFilePath");
settings.SetControlTexts(tbSetPointFileLocalApps, "SetPointLocalApp");
settings.SetCheckBoxes(cbActivateLocalApps, "LocalAppAktiv");
settings.SetCheckBoxes(cbActivateCode2LocalApps, "ActivateCode2LocalApp");
}
public void SaveLocalPathConfigSettings()
{
var settings = Settings.Default;
settings.SetControlTexts(tbLocalAppNames, "LocalAppName");
settings.SetControlTexts(tbSourceFilePathLocalApps, "LocalAppFilePath");
settings.SetControlTexts(tbSetPointFileLocalApps, "SetPointLocalApp");
settings.SetCheckBoxes(cbActivateLocalApps, "LocalAppAktiv");
settings.SetCheckBoxes(cbActivateCode2LocalApps, "ActivateCode2LocalApp");
Settings.Default.Save();
}
von TH69
Die Methodenparameter für die ausgelagerten Methoden dann als Control[] bzw. CheckBox[] deklarieren
Muss das Control[] sein oder Textbox[]?
Wäre es richtig, wenn ich den folgenden Code aus der Mainform in die Settings.cs übernehme?
private TextBox[] tbLocalAppNames;
private TextBox[] tbSourceFilePathLocalApps;
private TextBox[] tbSetPointFileLocalApps;
private CheckBox[] cbActivateLocalApps;
private CheckBox[] cbActivateCode2LocalApps;
Vielen Dank nochmal für Deine Hilfe.
Grüße Tommylik
Hallo TH69,
Vielen Dank für deine Antwort und da muss ich dir gleich antworten.
Mir scheint, du machst dir immer mehr Arbeit als nötig ist.
Das ist ja kein wunder da ich ja oft nicht weiß was ich tue.
Du brauchst doch nicht für jedes konkrete Array eine eigene Methode (dafür sind doch die Parameter da), sondern (bisher) nur zwei verschiedene: für den Zugriff auf Text und Checked. Daher auch meine allgemeinen Namen: SetControlTexts und SetCheckBoxes.
Ok aber damit ich es besser verstehe und damit ich weiß wo ich ansetzen muss, das was ich umgesetzt habe ist falsch?
Verstehe ich dich richtig das ich die ganzen Methoden in der Settings.cs auf 2 Methoden einkürzen kann?
Ich tue mich halt schwer damit das was du mir als Hilfe zur Verfügung stellst an den richtigen stellen einzusetzen.
Ich hoffe, ich überfordere dich nicht zu sehr, aber es freut mich, dass du meine Tipps umsetzt. 😉
Nein, aber es ist auch nicht gerade ein Kinderspiel. Ich möchte halt nicht nicht aufgeben. Es macht mir spaß.
Aber jetzt mal die Gegenfrage wie viel Geduld hast?
Bei deinem jetzigen Code könnte man noch mehr Code einsparen (optimieren),
Darüber sollten wir nachdenken wenn ich das Thema Klasse > Form verstanden habe.
Und so aufgebaut ist wie es sein sollte.
Vielen Dank für deine bisherige Hilfe, Mühe und Zeit.
Grüße Tommylik
Hallo TH69,
Vielen Dank für deine tolle Hilfe.
PS: Zum Thema "Zugriff von anderer Klasse auf Window Control" kannst du dir auch mal meinen längeren Artikel Kommunikation von 2 Forms durchlesen.
Denn habe ich mir durchgelesen und deshalb denke ich das ich es nicht richtig umgesetzt habe.
Ich denke das mir der Eventhandler fehlt. Und wer weiß was sonst noch.
Was halt blöd ist, das es funktioniert trotzdem das ich es falsch umgesetzt habe.
Tut mir leid, dass es mit mir so schwierig ist.
Hier meine Umsetzung:
Settings.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace PDE.Properties
{
internal sealed partial class Settings
{
internal void GetLocalAppNames(TextBox[] tbLocalAppNames, string v)
{
for (int i = 0; i < tbLocalAppNames.Length; i++)
{
tbLocalAppNames[i].Text = (string)Settings.Default[v + (i + 1)];
}
//throw new NotImplementedException();
}
internal void GetSourceFilePathLocalApps(TextBox[] tbSourceFilePathLocalApps, string v)
{
for (int i = 0; i < tbSourceFilePathLocalApps.Length; i++)
{
tbSourceFilePathLocalApps[i].Text = (string)Settings.Default[v + (i + 1)];
}
//throw new NotImplementedException();
}
internal void GetSetPointFileLocalApps(TextBox[] tbSetPointFileLocalApps, string v)
{
for (int i = 0; i < tbSetPointFileLocalApps.Length; i++)
{
tbSetPointFileLocalApps[i].Text = (string)Settings.Default[v + (i + 1)];
}
//throw new NotImplementedException();
}
internal void GetActivateLocalApps(CheckBox[] cbActivateLocalApps, string v)
{
for (int i = 0; i < cbActivateLocalApps.Length; i++)
{
cbActivateLocalApps[i].Checked = (bool)Settings.Default[v + (i + 1)];
}
//throw new NotImplementedException();
}
internal void GetActivateCode2LocalApps(CheckBox[] cbActivateCode2LocalApps, string v)
{
for (int i = 0; i < cbActivateCode2LocalApps.Length; i++)
{
cbActivateCode2LocalApps[i].Checked = (bool)Settings.Default[v + (i + 1)];
}
//throw new NotImplementedException();
}
internal void SaveLocalAppNames(TextBox[] tbLocalAppNames, string v)
{
for (int i = 0; i < tbLocalAppNames.Length; i++)
{
Settings.Default[v + (i + 1)] = tbLocalAppNames[i].Text;
}
//throw new NotImplementedException();
}
internal void SaveSourceFilePathLocalApps(TextBox[] tbSourceFilePathLocalApps, string v)
{
for (int i = 0; i < tbSourceFilePathLocalApps.Length; i++)
{
Settings.Default[v + (i + 1)] = tbSourceFilePathLocalApps[i].Text;
}
//throw new NotImplementedException();
}
internal void SaveSetPointFileLocalApps(TextBox[] tbSetPointFileLocalApps, string v)
{
for (int i = 0; i < tbSetPointFileLocalApps.Length; i++)
{
Settings.Default[v + (i + 1)] = tbSetPointFileLocalApps[i].Text;
}
//throw new NotImplementedException();
}
internal void SaveActivateLocalApps(CheckBox[] cbActivateLocalApps, string v)
{
for (int i = 0; i < cbActivateLocalApps.Length; i++)
{
Settings.Default[v + (i + 1)] = cbActivateLocalApps[i].Checked;
}
//throw new NotImplementedException();
}
internal void SaveActivateCode2LocalApps(CheckBox[] cbActivateCode2LocalApps, string v)
{
for (int i = 0; i < cbActivateCode2LocalApps.Length; i++)
{
Settings.Default[v + (i + 1)] = cbActivateCode2LocalApps[i].Checked;
}
//throw new NotImplementedException();
}
}
}
MainForm.cs
using PDE.Properties;
namespace PDE
{
public partial class MainForm : Form
{
public void GetLocalPathConfigSettings()
{
this.txtChooseTargetPath.Text = Settings.Default.TargetPath;
var settings = Settings.Default;
settings.GetLocalAppNames(tbLocalAppNames, "LocalAppName");
settings.GetSourceFilePathLocalApps(tbSourceFilePathLocalApps, "LocalAppFilePath");
settings.GetSetPointFileLocalApps(tbSetPointFileLocalApps, "SetPointLocalApp");
settings.GetActivateLocalApps(cbActivateLocalApps, "LocalAppAktiv");
settings.GetActivateCode2LocalApps(cbActivateCode2LocalApps, "ActivateCode2LocalApp");
}
public void SaveLocalPathConfigSettings()
{
var settings = Settings.Default;
settings.SaveLocalAppNames(tbLocalAppNames, "LocalAppName");
settings.SaveSourceFilePathLocalApps(tbSourceFilePathLocalApps, "LocalAppFilePath");
settings.SaveSetPointFileLocalApps(tbSetPointFileLocalApps, "SetPointLocalApp");
settings.SaveActivateLocalApps(cbActivateLocalApps, "LocalAppAktiv");
settings.SaveActivateCode2LocalApps(cbActivateCode2LocalApps, "ActivateCode2LocalApp");
Settings.Default.TargetPath = this.txtChooseTargetPath.Text;
Settings.Default.Save();
}
PS: Zum Thema "Zugriff von anderer Klasse auf Window Control" kannst du dir auch mal meinen längeren Artikel Kommunikation von 2 Forms durchlesen.
Ich will mal dieses Beispiel ausprobieren zum lernen:
Für das Beispiel, daß eine SubForm den Label-Text der MainForm aktualisieren soll (z.B. um einen Status anzuzeigen) sieht der Code dann so aus:
class SubForm : Form
{
// ...
public class TextEventArgs : EventArgs
{
public TextEventArgs(string text)
{
Text = text; // Eigenschaft setzen
}
public string Text { get; set; } // Text als Eigenschaft definieren
}
public event EventHandler<TextEventArgs> UpdateText; // Ereignis deklarieren
void button_Click(object sender, EventArgs e)
{
// ...
OnUpdateText(new TextEventArgs("Test")); // Ereignis-Methode aufrufen
}
protected virtual void OnUpdateText(TextEventArgs e)
{
EventHandler<TextEventArgs> ev = UpdateText;
if (ev != null)
ev(this, e); // abonnierte Ereignismethode(n) aufrufen
}
}
Und nun muß im MainForm dann noch dieses Ereignis abonniert (zugewiesen) werden:
class MainForm : Form
{
void button_Click(object sender, EventArgs e)
{
SubForm subForm = new SubForm();
subForm.UpdateText += UpdateLabelText; // Ereignis abonnieren
subForm.ShowDialog(this);
}
void UpdateLabelText(object sender, SubForm.TextEventArgs e)
{
labelText.Text = e.Text; // Zugriff auf Eigenschaft des Ereignisses
}
}
Ich muss es doch schaffen diesen aha-Efekt zu bekommen.
Vielen Dank nochmal für deine besondere Hilfe.
Grüße Tommylik
Hallo an alle,
Vielen Dank für Eure Antworten.
@TH69
Vielen Dank für die Code Beispiele. Dadurch sind nochmal ein haufen Codezeilen rausgeflogen.
wenn du dir die Settings.Designer.cs mal (mit einem Texteditor) anschaust, dann siehst du, daß intern einfach nur der Index-Operator Item[String] der Basisklasse ApplicationSettingsBase benutzt wird, d.h. diesen kannst du also einfach selber nutzen, z.B.
Die Items sind die "propertyName" die ich in der Settings.settings angelegt habe.
Ich habe jetzt für alle eine Schleife angelegt.
public void GetLocalPathConfigSettings()
{
this.txtChooseTargetPath.Text = Properties.Settings.Default.TargetPath;
for (int i = 0; i < tbLocalAppNames.Length; i++)
{
tbLocalAppNames[i].Text = (string)Properties.Settings.Default["LocalAppName" + (i + 1)];
}
for (int i = 0; i < tbSourceFilePathLocalApps.Length; i++)
{
tbSourceFilePathLocalApps[i].Text = (string)Properties.Settings.Default["LocalAppFilePath" + (i + 1)];
}
for (int i = 0; i < tbSetPointFileLocalApps.Length; i++)
{
tbSetPointFileLocalApps[i].Text = (string)Properties.Settings.Default["SetPointLocalApp" + (i + 1)];
}
for (int i = 0; i < cbActivateLocalApps.Length; i++)
{
cbActivateLocalApps[i].Checked = (bool)Properties.Settings.Default["LocalAppAktiv" + (i + 1)];
}
for (int i = 0; i < cbActivateCode2LocalApps.Length; i++)
{
cbActivateCode2LocalApps[i].Checked = (bool)Properties.Settings.Default["ActivateCode2LocalApp" + (i + 1)];
}
}
Für die Save Methoden auch.
public void SaveLocalPathConfigSettings()
{
Properties.Settings.Default.TargetPath = this.txtChooseTargetPath.Text;
for (int i = 0; i < tbLocalAppNames.Length; i++)
{
Properties.Settings.Default["LocalAppName" + (i + 1)] = tbLocalAppNames[i].Text;
}
for (int i = 0; i < tbSourceFilePathLocalApps.Length; i++)
{
Properties.Settings.Default["LocalAppFilePath" + (i + 1)] = tbSourceFilePathLocalApps[i].Text;
}
for (int i = 0; i < tbSetPointFileLocalApps.Length; i++)
{
Properties.Settings.Default["SetPointLocalApp" + (i + 1)] = tbSetPointFileLocalApps[i].Text;
}
for (int i = 0; i < cbActivateLocalApps.Length; i++)
{
Properties.Settings.Default["LocalAppAktiv" + (i + 1)] = cbActivateLocalApps[i].Checked;
}
for (int i = 0; i < cbActivateCode2LocalApps.Length; i++)
{
Properties.Settings.Default["ActivateCode2LocalApp" + (i + 1)] = cbActivateCode2LocalApps[i].Checked;
}
Properties.Settings.Default.Save();
}
Edit: Alternativ dazu könntest du eine eigene "Settings.cs" anlegen (ruhig auch im Unterordner Properties) mit
namespace <ProjectNamespace>.Properties
Das habe ich gemacht aber das war es schon dafür brauche ich sehr viel Zeit.
Mein Problem ist zu verstehen wo was hingehört.
Es gibt zum Beispiel die Regel das man aus einer Klasse nicht auf die Controls zugreifen soll sondern Events dafür nutzt.
Man ist das kompliziert.
In der SPS zum Beispiel wenn ein Baustein zu groß wird kann ich einfach einen Teil raus nehmen
und in einen anderen Baustein packen und den Baustein dann aufrufen.
Unter anderem bin ich dabei dies hier zu lesen.
[FAQ] Kommunikation von 2 Forms
und das hier.
Zugriff von anderer Klasse auf Window Control
Aber es wäre toll wenn ich es schaffen würde alles was mit den Properties.Settings zu tun hat in die Settings.cs auszulagern.
(ich benutze dafür auch immer using Properties;, damit ich Properties nicht mehr explizit schreiben muß).
Darüber finde ich kein Beispiel das mir das erklärt.
Und auch deine Click-Methoden kannst du stark verkürzen, z.B.
Da hast du mir ja die Arbeit netter Weise abgenommen vielen Dank.
private void ChooseSourcePathLocalApp_Click(object sender, EventArgs e)
{
var textBox = sender as TextBox;
if (textBox != null)
{
if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
{
textBox.Text = folderBrowserDialog1.SelectedPath;
}
}
}
Aber vielen Dank für die tolle Hilfe und die Code-Snippets
Grüße Tommylik
Servus,
So, ich habe noch weiter gemacht und musste feststellen das, was ich Euch beim letzten Mal geschrieben habe, ist Blödsinn,
weil ich so ja nur in dem Test_Click Event die Arrays nutzen kann.
Ich habe das jetzt mal so umgebaut das ich es auf die ganze Mainform anwenden konnte. Habe einige hundert Zeilen
Code herausschmeißen können, weil ich viele Schleifen nutzen konnte.
Ich hänge die Datei mal an, weil sie trotzdem ich sie verkleinert habe noch über 800 Zeilen hat.
Wenn Ihr möchtet, könnt Ihr mir mal Eure Meinung sagen.
Was könnten meine Fehler sein das ein User Control größer wird wie die Vorlage?
Beim Erstellen des User Controls hat es genau die gleichen Maße wie die Steuerelemente auf meiner Form.
(3 Textboxen und 2 Checkboxen in einer Reihe angeordnet.)
Ziehe ich dann, dass User Control aus der Toolbox auf die Form, ist es fast doppelt so groß.
Eine Frage hätte ich noch.
Es sind viele Zeilen Code für die Propperties.Settings in der angehängten Datei.
Könnte man das auch verkleinern? Oder sogar in eine Klasse auslagern?
Wenn ja, gehe ich weiter auf die Suche.
Vielen Dank für Eure Hilfe.
Grüße Tommylik
Hallo,
Vielen Dank für die Antworten und für den Code-Snippet.
Ich tue mich sehr schwer damit, weil ich auch nicht weiß wann was genau wo hin muss.
Jetzt habe ich wieder eine neue Variante. Funktioniert, aber ob das richtig ist weiß ich nicht.
Also nach den Programmier Regeln.
public partial class MainForm : Form
{
public MainForm()
{
InitializeComponent();
}
private void Test_Click(object sender, EventArgs e)
{
TextBox[] tb = new TextBox[] { txtLocalAppName1, txtLocalAppName2, txtLocalAppName3, txtLocalAppName4,
txtLocalAppName5, txtLocalAppName6, txtLocalAppName7, txtLocalAppName8 };
for (int i = 0; i < cb.Length; i++)
{
tb[i].Enabled = (cb[i].Checked || string.IsNullOrEmpty(tb[i].Text));
}
}
Wenn jemand eine Checkbox wieder auf unchecked setzt soll dann das zugehörige Textfeld wieder disabled werden ? Das fehlt in deinem Code.
Die Textboxen werden mit einem anderen Button (speichern) auf disable gesetzt wenn sie Text enthalten damit nichts geändert werden kann.
Das sind sozusagen Konfigurationstextboxen die einmal beschrieben werden.
Der TestButton wird ein Loginbutton der die Textboxen auf Enabled setzt wenn man Änderungen machen muss.
So funktioniert es wie ich es möchte. Ob es richtig ist und auch sinnvoll kann ich nicht beurteilen.
Mal eine Frage, wenn ich eine Liste erstelle und die Textboxen da rein schreibe kann ich doch über den Index auf die einzelnen
Textboxen zugreifen oder ?
Wenn ich mehrere Textboxen in einer Reihe habe plus eine Checkbox und daraus ein User Control machen würde
und dann dieses User Control (erstmal mit dem Designer) mehrmals untereinander auf der Form platziere und
dann diese User Controls in eine Liste packe, wie spreche ich dann die Textboxen in dem User Control an?
Und was wäre wenn da noch ein TabControl dazwischen liegt?
Ich werde das mal ausprobieren ich hoffe es klappt.
Ihr habt ja gesagt das ich noch einiges über die OOP lernen muss.
Es gibt sehr viel hier im I-Net und wie ich schon mal gesagt habe wird das meistens mit der Klasse Auto erklärt.
Ich werde hauptsächlich mit Verzeichnissen und Dateien arbeiten und verstehe nicht wie man OOP mit
solchen Elementen in Verbindung bringen kann. Ich hoffe ihr versteht mich was ich sagen möchte.
Ich habe schon einige Videos über OOP geschaut aber keines von den Videos kann mir behilflich sein
mit dem was ich machen möchte.
Gibt es vielleicht ein Buch was ich kaufen könnte mit dem ich OOP besser verstehen lerne?
Vielen Dank nochmal für Eure Hilfe.
Grüße Tommylik
Servus,
Vielen Dank für Eure Antworten.
Kannst du nicht einfach mal den (Teil vom) Artikel anschauen?
Habe ich, aber ich verstehe das Beispiel leider nicht wie du vielleicht gehofft hast.
TextBox[] textBoxes = new TextBox[] { this.textBox1, this.textBox2, this.textBox3 };
Keine Ahnung wo das hinkommt im Code, das steht in dem Beispiel nicht mit dabei.
Ich habe es jetzt anders gelöst.
public partial class MainForm : Form
{
List<TextBox> txtLocalAppNameList = new List<TextBox>();
public MainForm()
{
InitializeComponent();
txtLocalAppNameList.Add(txtLocalAppName1);
txtLocalAppNameList.Add(txtLocalAppName2);
txtLocalAppNameList.Add(txtLocalAppName3);
txtLocalAppNameList.Add(txtLocalAppName4);
txtLocalAppNameList.Add(txtLocalAppName5);
txtLocalAppNameList.Add(txtLocalAppName6);
txtLocalAppNameList.Add(txtLocalAppName7);
txtLocalAppNameList.Add(txtLocalAppName8);
}
private void Test_Click(object sender, EventArgs e)
{
checkBoxes = new CheckBox[8];
checkBoxes[0] = chkActivateLocalApp1;
checkBoxes[1] = chkActivateLocalApp2;
checkBoxes[2] = chkActivateLocalApp3;
checkBoxes[3] = chkActivateLocalApp4;
checkBoxes[4] = chkActivateLocalApp5;
checkBoxes[5] = chkActivateLocalApp6;
checkBoxes[6] = chkActivateLocalApp7;
checkBoxes[7] = chkActivateLocalApp8;
for (int i = 0; i < checkBoxes.Length; i++)
{
if (checkBoxes[i].Checked == true)
{
txtLocalAppNameList[i].Enabled = true;
}
}
}
So funktioniert es wenigstens. Button klicken und alle Textboxen sind Enable.
Ich bin aber sehr enttäuscht ich dachte man könnte, wenn man mit Listen und Arrays arbeite, viel mehr Code Zeilen einsparen.
Meine If Konstruktion hat 42 Zeilen (siehe Beispiel oben). Jetzt sind es auch nicht viel weniger.
Na ja es funktioniert das ist die Hauptsache.
Vielen Dank für Eure Hilfe nochmal.
Grüße Tommylik
Hallo,
Vielen Dank für Eure Antworten.
Bei dir scheinen wirklich die Grundlagen der OOP noch nicht zu sitzen.
Ich habe bisher noch nichts gefunden das mir das erklären könnte.
90% aller Videos oder Tutoriell erklären das mit der Klasse Auto.
Und wie Abt schrieb, wenn du die Listen dann als Klassenmember anlegst (und im Konstruktor - nach InitializeComponent() - füllst), dann werden diese auch nicht jedesmal wieder neu angelegt.
Also nach dem InitializeComponent();
Ich habe das jetzt so umgesetzt:
public partial class MainForm : Form
{
List<TextBox> txtLocalAppNameList = new List<TextBox>();
CheckBox[] checkBoxes;
public MainForm()
{
InitializeComponent();
txtLocalAppNameList = new List<TextBox>();
txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName1.Text });
txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName2.Text });
txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName3.Text });
txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName4.Text });
txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName5.Text });
txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName6.Text });
txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName7.Text });
txtLocalAppNameList.Add(new TextBox { Text = txtLocalAppName8.Text });
checkBoxes = new CheckBox[8];
checkBoxes[0] = chkActivateLocalApp1;
checkBoxes[1] = chkActivateLocalApp2;
checkBoxes[2] = chkActivateLocalApp3;
checkBoxes[3] = chkActivateLocalApp4;
checkBoxes[4] = chkActivateLocalApp5;
checkBoxes[5] = chkActivateLocalApp6;
checkBoxes[6] = chkActivateLocalApp7;
checkBoxes[7] = chkActivateLocalApp8;
}
private void Test_Click(object sender, EventArgs e)
{
for (int i = 0; i < checkBoxes.Length; i++)
{
if (checkBoxes[i].Checked == true)
{
txtLocalAppNameList[i].Enabled = true;
}
}
}
So funktioniert es auch nicht keine Ahnung warum.
Ist es wenigstens ein bisschen richtig, weil da würde ich mich echt freuen.
Man ist das kompliziert.
Grüße Tommylik
Hallo TH69,
Ich war leider einige Zeit Arbeitstechnisch wo anders eingesetzt so das ich keine Zeit hatte.
Vielen Dank für deine letzte Antwort.
Das muss ich mir noch alles genauer anschauen und noch mehr lesen.
Aber ich habe jetzt erstmal deine Vorschlag mit dem Herumexperimentieren in angriff
genommen und will erstmal mehr mit Listen und Arrays machen.
Es bringt mir nicht Steuerelemente dynamisch erstellen zu können, wenn ich doch noch
nicht weiß wie ich z.B. alle Textboxen die auf einem TabPage sind in eine Liste bekomme.
Und ich denke das ist hier jetzt mein Problem.
Ich möchte folgendes mit einer Liste und for Schleife erledigen.
private void Test_Click(object sender, EventArgs e)
{
if (chkActivateLocalApp1.Checked)
{
txtLocalAppName1.Enabled = true;
}
if (chkActivateLocalApp2.Checked)
{
txtLocalAppName2.Enabled = true;
}
if (chkActivateLocalApp3.Checked)
{
txtLocalAppName3.Enabled = true;
}
if (chkActivateLocalApp4.Checked)
{
txtLocalAppName4.Enabled = true;
}
if (chkActivateLocalApp5.Checked)
{
txtLocalAppName5.Enabled = true;
}
if (chkActivateLocalApp6.Checked)
{
txtLocalAppName6.Enabled = true;
}
if (chkActivateLocalApp7.Checked)
{
txtLocalAppName7.Enabled = true;
}
if (chkActivateLocalApp8.Checked)
{
txtLocalAppName8.Enabled = true;
}
}
Mein Versuch mit einer Liste und Schleife.
Wenn ich mit dem Debugger und Haltepunkte schaue sind alle Werte vorhanden wie es sein sollte
aber es wird kein Textfeld auf Enabled gesetzt.
Mit der Code Variante oben schon.
Wo ist mein Fehler??
private void Login_Click(object sender, EventArgs e)
{
List<TextBox> txtLocalAppNameList = new List<TextBox>
{
new TextBox { Text = txtLocalAppName1.Text },
new TextBox { Text = txtLocalAppName2.Text },
new TextBox { Text = txtLocalAppName3.Text },
new TextBox { Text = txtLocalAppName4.Text },
new TextBox { Text = txtLocalAppName5.Text },
new TextBox { Text = txtLocalAppName6.Text },
new TextBox { Text = txtLocalAppName7.Text },
new TextBox { Text = txtLocalAppName8.Text }
};
CheckBox[] checkBoxes = new CheckBox[8];
checkBoxes[0] = chkActivateLocalApp1;
checkBoxes[1] = chkActivateLocalApp2;
checkBoxes[2] = chkActivateLocalApp3;
checkBoxes[3] = chkActivateLocalApp4;
checkBoxes[4] = chkActivateLocalApp5;
checkBoxes[5] = chkActivateLocalApp6;
checkBoxes[6] = chkActivateLocalApp7;
checkBoxes[7] = chkActivateLocalApp8;
for (int i = 0; i < checkBoxes.Length; i++)
{
if (checkBoxes[i].Checked == true)
{
txtLocalAppNameList[i].Enabled = true;
}
}
}
Mit dem 2. Code habe ich keinen Code mehr der sich widerholt aber dennoch viel zu viele Codezeilen.
Wie kann ich das besser machen?
Vielen Dank noch mal für deine Hilfe.
Grüße Tommylik