Wie kann ich Wörter von Containern am Besten darstellen und verändern?

Servus zusammen 😉

ich überlege mir gerade, wie ich verschiedene Wörter von Containern am besten darstellen und auch verändern kann.

Habe aus einer XML die Daten gelesen (deserialisiert) und diese Wörter will ich nun in Spalten von den jeweiligen Containern darstellen. Für Adjektive und Objekte habe ich es provisorisch probiert. Leider erscheinen die Wörter nicht....
Habe auch einen anderen Ansatz versucht, die jeweiligen Container zu durchlaufen und dann in einer Methode (Print) diese jeweils als ListViewItem anzuhängen. Hier ist aber das Problem, dass der User später nicht die Werte schön ändern kann und alles in einer Spalte ist...

Hätte von euch jemand nen Tipp, wie man das "schön" lösen kann, wie gesagt, würde ich gerne eigl. die DataGridView verwenden, doch leider fällt es mir schwer, die Wörter in die jeweilige Spalte zu bekommen, bzw. bleibt diese einfach leer.

Probiere es heute wahrscheinlich noch den ganzen Tag weiter, könnt ja gerne was dazuschreiben.
Vielen Dank 😉

private void CreateContainer_Load(object sender, EventArgs e) {
            
            OpenFileDialog OFD = new OpenFileDialog();

            if (OFD.ShowDialog() == DialogResult.OK) {
                string path = OFD.FileName;

                XmlSerializer Serializer = new XmlSerializer(typeof(DrainPartContainerStore));
                StreamReader Reader = new StreamReader(path);

                DrainPartContainerStore Store1 = new DrainPartContainerStore();

                Store1 = (DrainPartContainerStore) Serializer.Deserialize(Reader);
                Reader.Close();

                DataGridView1.DataSource = Store1.AdjectiveContainer;
                DataGridView1.DataSource = Store1.ObjectContainer;


                //Store1.AdjectiveContainer.ForEach(Print);
                //Store1.ObjectContainer.ForEach(Print);

        public List<string> AdjectiveContainer { get; set; }

        public List<string> ObjectContainer { get; set; }

  <AdjectiveContainer>
    <string>blaue</string>
    <string>grüne</string>
    <string>dicke</string>
    <string>lustige</string>
    <string>frische</string>
    <string>arme</string>
    <string>reiche</string>
    <string>ziellose</string>
    <string>namenlose</string>
    <string>pünktliche</string>
    <string>saubere</string>
  </AdjectiveContainer>
  <ObjectContainer>
    <string>Bären</string>
    <string>Esel</string>
    <string>Löwen</string>
    <string>Würmer</string>
    <string>Nashörner</string>
    <string>Vögel</string>
    <string>Tiger</string>
    <string>Fliegen</string>
    <string>Ameisen</string>
  </ObjectContainer>

Hast du beim DataGridView auch AutoGenerateColumns auf true stehen (ist aber auch Default)?

Und hast du denn mit dem Debugger überprüft, ob überhaupt die Listen gefüllt sind?

Außerdem kann man eine List<string> nicht direkt an ein DGV binden, denn dann sieht man nur die Länge der Strings, s.a. How to bind a List<string> to a DataGridView control? (also entweder mit einer Wrapper-Klasse oder per LINQ)

PS: Mit

DataGridView1.DataSource = Store1.AdjectiveContainer;
DataGridView1.DataSource = Store1.ObjectContainer;

überschreibst du die erste Liste wieder (siehst also nur die 2. Liste).

Am besten in 2 verschiedenen DGVs anzeigen.

Edit: Und du hast noch einen weiteren (beliebten) Anfängerfehler gemacht.
Du brauchst bei der Variablendeklaration kein neues Objekt anlegen:

 DrainPartContainerStore Store1 = new DrainPartContainerStore();

da es in der darauffolgenden Zeile ja schon direkt mit einem anderen Objekt überschrieben wird.
Es reicht also

DrainPartContainerStore Store1;

Store1 = (DrainPartContainerStore) Serializer.Deserialize(Reader);

bzw. gleich bei der Variablendaklaration initialisieren:

DrainPartContainerStore Store1 = (DrainPartContainerStore) Serializer.Deserialize(Reader); // oder alternativ "var Store1 = ..." verwenden

Außerdem sollten lokale Variablen mit einem Kleinbuchstaben anfangen (also auch nicht OFD, sondern ofd bzw. besser openFileDialog 😉

Außerdem kann man eine List<string> nicht direkt an ein DGV binden, denn dann sieht man nur die Länge der Strings, s.a.
> (also entweder mit einer Wrapper-Klasse oder per LINQ)

Danke hierfür, das war eben das knackigste. Bin zurück ausm Urlaub und habe das eben weitergemacht. Hat funktioniert, und danke auch für die anderen Tipps 👍

Wie speichert man jetzt Änderungen, also wenn der Nutzer Änderungen in der DataGridView vornimmt?
Meine erste Überlegung wäre, einen Button "Speichern" einzufügen, sobald der Nutzer etwas geändert hat, sodass die Änderungen gesavt werden. Funktion des Buttons wäre "Serializen", sodass dies im XML gespeichert ist. Denkt ihr der Ansatz ist korrekt? 🙂

Schön, daß es jetzt bei dir funktioniert.

Und ja, genauso wie du Daten geladen (deserialisierst) hast, kannst du sie auch wieder abspeichern (serialisieren):

xmlSerializer.Serialize(streamWriter, data);

Guten Abend,

habe jetzt ein Problem hierzu. Habe alle string-Container in DataGridViews jetzt stehen. Wenn ich jetzt als Nutzer, Wörter abändere z.B. und dann auf den Button "Speichern" drücke, dann kann das wohl nicht gespeichert werden, da das DGV quasi nirgends abgespeichert ist. Kann das sein? Für jeden Container, den ich habe erstelle ich eine DGV, um die Wörter anzeigen zu lassen.

Wird der Aufwand groß das umzuändern? Bzw. gibt es keine Möglichkeit, die abgeänderten Daten von der GUI ins XML zu bekommen? bin grad echt etwas am Verzweifeln....

Danke schonmal.

Hier der Code:

for (int i = 0; i < QuantityOfContainers; i++) {
                if (PropertiesOfDPCS[i].PropertyType != typeof(List<string>)) {
                    continue;
                }
                DataGridView DGV = new DataGridView();
                DataGridViewTextBoxColumn Col = new DataGridViewTextBoxColumn();
                Col.HeaderText = PropertiesOfDPCS[i].Name;
                DGV.Columns.AddRange(Col);

                this.Controls.Add(DGV);
                //DGV.ColumnCount = 1;
                DGV.Location = new Point(Width, 35);
                Width += 160;
                DGV.Size = new Size(150, 400);

                DGV.DataSource = GetListForCurrentLoop(DPCS1, PropertiesOfDPCS[i].Name);
                DGV.Show();

            }

Die Daten werden doch mittels DataSource gesetzt, d.h. umgekehrt kannst du diese auch wieder auslesen:

var list = dataGridView.DataSource as List<string> // passenden Typ einsetzen

Da du jedoch die DataGridViews dynamisch erstellst, müßtest du diese jeweils in einer Schleife durchgehen. Hierfür könntest du dann gleich ein Dictionary<DataGridView, List<string>> erstellen, s.a. [FAQ] Variablennamen zur Laufzeit zusammensetzen / Dynamisches Erzeugen von Controls.

Besser wäre es außerdem, wenn du deine Programmstruktur entsprechend [Artikel] Drei-Schichten-Architektur aufbaust (so daß du keine direkte Kopplung zwischen (G)UI und XML-Serlialisierung hast).

Genau, habe es dynamisch gemacht, dass so viele DGVs erstellt werden, so viele Container ich habe von dem bestimmten Typ.

Die Daten werden doch mittels DataSource gesetzt, d.h. umgekehrt kannst du diese auch wieder auslesen:

Hierzu stellt sich mir nur die Frage, wo im Code ich das auslesen soll, ich meine, wenn ich das in der Methode ButtonUpdate_Click mache, dann habe ich doch gar keinen Zugriff mehr auf die DVG.DataSource, da diese bei der Form _Load erzeugt wird. Oder ist ein Button zum Updaten gar nicht nötig? Bin mir noch immer nicht sicher, wie ich das eingelesene XML nachdem Ändern in der DGV saven kann.
Außerdem soll der geänderte Text natürlich dann auch im neuen XML abgeändert sein.

An sich verstehe ich, dass ich den DataSource einer Liste mit "as" hinzufüge. Aber wo im Code soll das geschehen? Die anderen beiden Links lese ich auch gleich mal durch, wie du bemerkt hast, bin ich Anfänger 😉
Danke für das schnelle Antworten hier immer.

Darum ja mein Hinweis auf das Dictionary<...> sowie den Link. Irgendwo mußt du ja dir die Referenzen auf die DataGridViews merken (bzw. besser wäre wahrscheinlich gleich nur die Listen selbst in einer passenden Container-Struktur [in der Logik-Schicht] abzuspeichern).