generic enum

maciek

Hi,

Ich zerbreche mir gerade den Kopf ueber folgende Gehirnuebung:

Code

public enum MenuOptions
{
    option1,
    option2,
    option3
}


public class SubMenu<SubMenuEnumeration>
    where SubMenuEnumeration : struct, IConvertible
{


    private SubMenuEnumeration _defaultOption;


    public SubMenu(SubMenuEnumeration defaultOption)
    {
        _defaultOption = defaultOption;
    }


    public ??? Options
    {
        get
        {
            return ???;
        }
    }
}


SubMenu<MenuOptions> myMenu = new SubMenu<MenuOptions>(MenuOptions.option2);

Alles anzeigen

Ich glaube es kann einfach nicht funktionieren alle moeglichen enum Optionen mit get wieder zurueckzugeben, sodass ich den untenstehenden Code ausfuehren kann, richtig?

Code

MenuOptions myOption1 = myMenu.Options.option1;

damike

Meinst du sowas?

Code

namespace ConsoleApplication1
{
    public enum MenuOptions
    {
        option1,
        option2,
        option3
    }
    class Foo
    {
        public IEnumerable Options
        {
            get
            {
                foreach (MenuOptions option in Enum.GetValues(typeof(MenuOptions)))
                {
                    yield return option;
                }
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Foo bar = new Foo();
            foreach (MenuOptions option in bar.Options)
            {
                Console.WriteLine("{0}\n", option.ToString());
            }
            Console.ReadKey();
        }
    }
}

Alles anzeigen

damike

Ah sorry schlecht gelesen - hab das glaub ich falsch verstanden sehe ich grade ...

Das ist dann wirklich knifflig. IEnumerable aus dem ersten Post generisch machen - dann geht LINQ drauf. Oder:

Code

namespace ConsoleApplication1
{
    public enum MenuOptions
    {
        option1,
        option2,
        option3
    }
    public class SubMenu<SubMenuEnumeration>
        where SubMenuEnumeration : struct, IConvertible
    {
        private SubMenuEnumeration _defaultOption;
        public SubMenu(SubMenuEnumeration defaultOption)
        {
            _defaultOption = defaultOption;
        }
        public SubMenuEnumeration Options(string value)
        {
            return (SubMenuEnumeration)Enum.Parse(typeof(SubMenuEnumeration), value);            
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            SubMenu<MenuOptions> myMenu = new SubMenu<MenuOptions>(MenuOptions.option2);
            MenuOptions myOption1 = myMenu.Options("option1");
            Console.WriteLine(myOption1.ToString());
            Console.ReadKey();
        }
    }
}

Alles anzeigen

Sorry - war gerade laufen und hab wohl net sauber gelesen was du willst Andere Möglichkeit als diese fällt mir nicht ein :confused:

fabs

Darf man fragen, warum du hier überhaupt eine enum verwendest? Wenn du die Menüelemente schon hardcoden willst, kannst du das mit Listen fast genauso einfach schreiben:

Code

public class Menu
{
      private List<String> options=new List<String>{"option1","option2","option3"};
      [...]
}

Komplizierter:

Code

public class Menu
{
      private List<Option> options=new List<Option>{new Option("option1"),new Option("option2"),new Option("option3")};
      [...]
}

Oder wenn du das ganze in einem statischen Repository haben willst, kannst du immer noch eine Enumeration verwenden, dann aber für die Menüs selber:

Code

public enum Menus
{
     Menu1,Menu2,Menu3
}
public static class MenuRepo
{
       private static Dictionary<Menus,List<Option>> menus=new Dictionary<Menus,List<Option>>{{Menus.Menu1,new List<Option>{new Option("option1"),new Option("option2")}},{Menus.Menu2,new List<Option>{...}},...};
       public static List<Option> getMenuOptions(Menus menu)
       {
             return menus[menu];
       }
}

Alles anzeigen

maciek

Danke fuer das Brainstorming.

@Lists<> vs. Enums: Enums haben den eindeutigen Vorteil, dass Du die einzelnen Elemente deutlich netter ansprechen kannst und Du genau weisst, welche erlaubt sind, und welche nicht.

@Warum ich mir darueber den Kopf zerbreche: Teilweise sicher aus sportlich-akademischen Ehrgeiz. Ich moechte einfach wissen, ob es eine Moeglichkeit gibt eine (volle) Enum (nicht einzelne Elemente) als ("private") Parameter weiter zu reichen und als (public) Property in einer anderen Klasse zur Verfuegung zu stellen.

Die Loesung mit Lists<> klaert das Problem fuer mich nicht wirklich. Da wuerde ich schon eher bei meiner derzeitigen Loesung bleiben, und die Enum direkt durch die Klasse die das SubMenu object definiert (und die Enum definiert) accessible machen. Das hat fuer mich den Schoenheitsfehler, dass ich dann so auf die Properties zugreifen muss:

Code

class MenuWraper 
{
    *snip*
    public enum MenuOptions
    {
        option1,
        option2,
        option3
    }


    SubMenu<MenuOptions> myMenu = new SubMenu<MenuOptions>(MenuOptions.option2);
    *snip*
}


MenuWrapper wrapper = new MenuWrapper();
wrapper.SubMenu ...
if (currentOption == wrapper.MenuOptions.option1) ...

Alles anzeigen

Anstatt des eleganteren Zugriffs ueber:

Code

MenuWrapper wrapper = new MenuWrapper();
wrapper.SubMenu ...
if (currentOption == wrapper.SubMenu.Options.option1) ...

PS: Enums koennen uebrigens auch "dynamisch" = basierend auf Datenbankwerten sein, siehe hier.

fabs

Ja, wenn du es so machen willst, tu dir keinen Zwang an. Imho ist es aber voll am Konzept von Enumerations vorbei, siehe auch hier: http://msdn.microsoft.com/de-de/library/ms229058.aspx .
Die "dynamischen" Enums von deinem Link her sind auch immer nur zu einem bestimmten Zeitpunkt generiert. Änderst du was an der Datenbank, musst du das Programm neu bauen.
Wenn du noch immer unbedingt Enums verwenden willst, kannst du dir den Zugriff vielleicht mit Erweiterungsmethoden noch weiter verschönern. Dazu gibts in der MSDN-Library auch noch ein Enum-Beispiel.

EDIT: Grad hab ich das abgeschickt, hab ich noch was gefunden, was dein ursprüngliches Problem so lösen könnte, wie du es haben willst: http://msdn.microsoft.com/de-de/library/cc138362.aspx (Ganz unten: "Verwenden der System.Enum-Methoden zur Ermittlung und Behandlung von Enumerationswerten")

maciek

Danke fuer die Links. Wrapper fuer die System.Enum methoden, bzw. eine generische Klasse fuer Enums/Enumhandling hab ich bereits.

generic enum

Maximilian Rupp 27. Dezember 2024 um 00:26

Tags