ArrayList als Zwischenspeicher verwenden

Hallo zusammen,
eigentlich ist mein Anliegen trivial....Ich möchte bei einer Auswahl auf ein TreeNode dieses ausgewählte abspeichern in einem ArrayList. Beim Wechsel des Nodes möchte ich
dann das ArrayList abarbeiten und anschliessend mit dem zuletzt aktivierten Node befüllen. Ich ahbe sogar eien innere Klasse(KatItem), die nur für das Ablegen zuständig ist.

Hier ein bischen Code:::
An der *// Stelle wird das ArrayList befüllt

 public ArrayList MatZuKat()
        {
            KatItem inikatit = new KatItem();
            ArrayList al_Ukn = new ArrayList();
            al_MatId.Clear();

            char[] sep = new char[] { ',' };
            string[] nodeID = selTree.Name.Split(sep, StringSplitOptions.None);
            
            al_Ukn = F_LastNode(ddStruktKnoten);

            foreach (KeyValuePair<string[], ArrayList> kv_kn in ddKnoten)
            {
                if (kv_kn.Key[0] == nodeID[0])
                {
                    foreach (string[,] str_ddVal in kv_kn.Value)
                    {
                        foreach (string al_str in al_Ukn)
                        {
                            //beschreibt,dass lediglich der KatalogKopf vorhanden ist, ohne Material
                            if (al_str == "1")
                            {
                                break;
                            }
                            else if(al_str == str_ddVal[0, 1])
                            {
                                al_MatId.Add(str_ddVal[0, 4]);
                            }
                        }
                    }
                }
            }

            *////////*///////
            inikatit.setKatItem(al_MatId);
            return al_MatId;
        }

An dieser Stelle soll auf das ArrayList zugeriffen werden.Nach abarbeitung wird das
ArrayList mit den neuen Werten befüllt..

public void MatzuKat_erweitern(ArrayList alMatzuord)
        {
            KatItem iniKatit = new KatItem();

            foreach (String alStr in iniKatit.getKatItem())
            {
                if (alMatzuord.Contains(alStr))
                {
                }
                else
                {
                    //base.SaveMethods(inidbupd.delMethod(alStr, "Id", "StruktTree"));    
                }
            }

            alMatzuord.Clear();

            *///
            iniKatit.setKatItem(al_MatId);
        }

Und hier die innere Klasse

private class KatItem
        {

            ArrayList alMatId = new ArrayList();
            ArrayList alTemp = new ArrayList();

            public KatItem()
            {
        
            }

            public ArrayList getKatItem()
            {
                TempAl();
                return alTemp;
            }
            

            public void setKatItem(ArrayList al_migKatItem)
            {
            
                alMatId = al_migKatItem;
        
            }

            private void TempAl()
            {
                foreach (String alstr in alMatId)
                {
                    alTemp.Add(alstr.Clone());
                }
            
            }
        }

Grüsse SharpNew

Hmm, erstens sehe ich deine Frage nicht und naja, auch dein Anliegen ist mir noch nicht ganz klar.

Du hast ne TreeView, dort makierst du >ein?< Element. Das willst du zwischenspeichern und sobald du ein anderes Element markierst willst du das zwischengespeicherte wieder hinzufügen? Ich bin verwirrt. Vielleicht kannst noch bissle was zu schreiben, weiß grad absolut gar net was du mit ner ArrayList willst 🙂

Ja,Stimmt war ein bischen wenig. Also das TreeView ist gekoppelt mit einer ListView. Sobald ein Node aus dem TreeView selektiert, wird im ListView zugeordnente Artikel als Beispiel angezeigt. Man Kann nun weitere Artikel in das ListView hinzufügen oder entfernen. Beim Wechsel in ein anderen Node sollen die Änderungen abgespeichert werden. Davor muss ich natürlich abgleichen ob etwas hinzugekommen ist bzw. entfernt worden ist. Und den Anfangszustand den möchte ich mir merken...

Grüsse

Ahh, jetzt ists um einiges klarer was du vorhast 😉 Musst die direkt wissen was zugekommen ist, oder nur dass irgendwas zugekommen ist?

Ich würde den Vorgang mal abgekoppelt von der Darstellung im UI sehen. Du hast irgend ne Collection mit allen Nodes. Jede Node wird durch ne Klasse representiert die von mir aus nen Titel hat(das was in der TreeView angezeigt werden soll) und dann den Inhalt in Form einer Collection von Artikeln. Ich gehe mal einfach davon aus das es nur wichtig ist dass es Änderungen gab, weil dann ist die Sache relativ einfach. Das Hinzufügen und Entfernen von Artikeln kapselst du dann durch ne Funktion oder auch nen Property die dann bei schreibenden Zugriff einfach nen Flag setzen das die ArtikelCollection verändert wurde. Wenn du nun ne andere Node auswählst, brauchst du nur in der Alten schaun ob dieses "ichwurdeverändert" Flag gesetzt ist.

So würde ich es ungefähr machen. Falls es wichtig ist, wieviel was verändert wurde, ists nen bissle aufwändiger, aber nicht unbedingt schwerer. Du musst einfach bei jedem verändernden Zugriff auf die ArtikelCollection schaun ob was hinzugekommen ist, oder entfernt wurde, und dir das merken.

Nur für den letzten Fall, dass es wirklich wichtig ist was verändert wurde, musst du dir deine ausgewählte Node zwischenspeichern(das Objekt musst du dann wohl Clonen um wirklich ne unabhängige Kopie zu erhalten) und dann müsstest du bei neuer Auswahl dann die Original und Kopie der ArtikelCollections wirklich Element für Element vergleichen.

Dazu würde ich aber keine ArrayList benutzen, sondern immer typisierte List<T> oder im Falle der Node/Artikel Zuordnung vielleicht auch nen Dictionary<string,Artikel> oder sowas.

Hallo sharp.new,

du solltest nicht die TreeNode zwischenspeichern, sondern die Objekte/Daten, die den Treenodes zugrundeliegen. Trennung von Oberfläche und Modell ==> MVC.

herbivore

Danke für die vielen Anreize erst einmal, aber was sagt Ihr zu meinem Code. Wie könnte man diese durch eine kleine Änderung, so hinbekommen, wie angedacht.

zu Talla: ich Tendiere zu dem zweiten Vorschlag von dir. Diese habe ich auch versucht Codetechnisch umzusetzten(siehe oben).

Grüsse

Naja, nen paar Auffälligkeiten(ist nicht gerade leicht verständlicher Code 😉)

public void MatzuKat_erweitern(ArraywList alMatzuord)
        {
            KatItem iniKatit = new KatItem();

            foreach (String alStr in iniKatit.getKatItem())

Naja, deine Schleife wird keine Schleife werden weil keine Strings in der ArrayList sein werden. Du weist ja nie über setKatItem deinem KatItem was zu bevor du es verwendest. Von daher ist auch die ArrayList mit den kopierten Daten leer.

Du weist zwar in

public ArrayList MatZuKat()
        {
...
            inikatit.setKatItem(al_MatId);
}

deinem KatItem Objekt was zu, aber das ist ja ein anderes als das was du beim Laden verwendest, weil dort erstellst du jedes mal ein neues statt das wo du die Daten reingefüllt hast zu verwenden. Musst halt deiner "erweitern" Funktion auch wirklich die zwischengespeicherten Daten übergeben, sonst kanns ja nichts erweitern.