Konsistentes Keyword in strukturierter Form

Question

Hi

ich möchte eine Variable definieren, die einen Keywordstring entgegennimmt. Das Keyword muss aus Konsistenzgründen einer bestimmten Struktur folgen. An einem Beispiel soll das verdeutlicht werden:

• Der Benutzer bekommt eine Liste der Kontinente angezeigt und wählt einen aus.
• Danach erhält er eine Liste der Länder des ausgewählten Kontinents und wählt eines aus (oder wählt undefiniert -> fertig, nur Kontinent festgelegt)
• Danach erhält er ggfls. eine Liste der Städte des ausgewählten Landes und wählt eine aus (oder wählt undefiniert -> fertig, nur Land festgelegt)
• ... (weitere Vertiefungen in der Verschachtelung sollten möglich sein.)

Das Ergebnise könnten sein:

• KeyWord = Asien
• KeyWord = Amerika>Kalifornien
• KeyWord = Europa>Deutschland>Berlin

Meinen ersten Gehversuch habe ich mit Klassen und deren Verschachtelungen begonnen, aber mir scheint das zu monströs zu werden. Im Moment habe ich eine Denkblokade, die einen einfacherern Weg nahelegt.

Hat jemand den richtigen Tip?

Gruß Peter

        public class KeyWord
        {
            public enum eKontinent
            {
                Europa,
                Asien,
                Amerika,
            }
            public eKontinent Kontinent;
            public IList<eKontinent> kontinente = new List<eKontinent>();

            public KeyWord(eKontinent kontinent)
            {
                Kontinent = kontinent;
                foreach (eKontinent e in Enum.GetValues(typeof(eKontinent)))
                {
                    kontinente.Add(e);
                }
            }

            public override string ToString()
            {
                return "KeyWord: " + Kontinent.ToString();
            }


            /// <summary>
            /// Klasse des Kontinent Europa mit Unterklassen der Länder in Europa 
            /// </summary>
            public class Europa
            {
                public enum eLand
                {
                    Undefined,
                    Deutschland,
                    Schweiz,
                }
                public eKontinent Kontinent;
                public eLand Land = eLand.Undefined;
                public IList<eLand> Laender = new List<eLand>();

                public Europa(eKontinent kontinent, eLand land)
                {
                    Kontinent = kontinent;
                    Land = land;
                    foreach (eLand e in Enum.GetValues(typeof(eLand)))
                    {
                        Laender.Add(e);
                    }
                }

                public override string ToString()
                {
                    return "Genauerer KeyWord: " + Kontinent.ToString() + ">" + Land.ToString();
                }


                /// <summary>
                /// UnterUnterKlasse mit dem ausgewählten Land des Kontinent Unterklassen der Städte
                /// </summary>
                public class Deutschland
                {
                    public enum eStadt
                    {
                        Undefined,
                        Berlin,
                        Hamburg,
                    }
                    public eKontinent Kontinent;
                    public eLand Land = eLand.Undefined;
                    public eStadt Stadt = eStadt.Undefined;
                    public IList<eStadt> Staedte = new List<eStadt>();

                    public Deutschland(eKontinent kontinent, eLand land, eStadt stadt)
                    {
                        Kontinent = kontinent;
                        Land = land;
                        Stadt = stadt;
                        foreach (eStadt e in Enum.GetValues(typeof(eStadt)))
                        {
                            Staedte.Add(e);
                        }
                    }

                    public override string ToString()
                    {
                        return "Genauster KeyWord: " + Kontinent.ToString() + ">" + Land.ToString() + ">" + Stadt.ToString();
                    }
                }
            }

            public class Asien
            {  }

            public class Amerika
            { }
        }

Answer 1

Hi Peter,
mit Klassen dieses Problem zu lösen, ist nur eine der Möglichkeiten.

Alternativ kann man auch eine flache Liste nehmen, die alle Elemente enthält und in der jedes Datenobjekt auf das übergeordnete Datenobjekt verweist.

Eine andere Möglichkeit ist die Nutzung eines XML-Stromes, der dann beliebig strukturiert werden kann.

Welcher Weg eine optimale Lösung ergibt, hängt von vielen weiteren Bedingungen des Projektes ab. Ggf. muss eine Variantenbetrachtung herangezogen werden.

---

--
Viele Grüsse
Peter Fleischer (MVP, Partner)
Meine Homepage mit Tipps und Tricks
Kommas richtig setzen! Leben retten!
Wir essen Opa.
Wir essen, Opa.

Answer 2

Danke für die weiteren Denkanstöße