C#: Alternative zu enum

[Enum (Gast)]

Hallo!

Habe ein kleines Umsetzungsproblem und hoffe ihr könnte mir helfen.
Ich habe in einem kleinen Tool eine Enumeration definiert, dessen Typ 
als Variable in Klassen und Funktionsparametern verwendet wird.
Nun gibt es eine kleine Änderung und es sind neue Zustände mit dem 
selben wert dazu gekommen. Welcher Zustand zu interpretieren ist, wird 
übergeordnet festgelegt.
Nun ist aber -logischerweise- nicht möglich in einer Enumeration den 
selben Wert mehren Elementen der Enumeration zuzuweisen.

public enum Direction
{
   Forward = 0,
   Up = 0,
   Backward = 1,
   Down = 1,   
   Left = 2,
   RollLeft = 2,
   Right = 3,
   RollRight = 3
}

Die "Optionen" in zwei enums aufzuteilen ist keine Lösung, da es ja 
weiterhin eine Variable geben soll ("Direction dir").

Gibt es für dieses Dilemma eine Lösung?

Danke & Grüße
Enum

[Rufus Τ. F. (rufus)]

Enum schrieb:
> Nun gibt es eine kleine Änderung und es sind neue Zustände mit dem
> selben wert dazu gekommen.

Das ist kaputt. So etwas vermeidet man.

Bereits Dein "Enum" ist kaputt, da dort Werte doppelt verwendet werden.

[Framulestigo (Gast)]

Es gibt doch sicherlich eine zusätzliche Eigenschaft ('mode', oder so), 
die zwischen den neuen und alten Funktionen in Zusammenhang mit 'dir' 
umschaltet?
Entweder kann man dann den enum auf acht Einstellungen aufbohren, die 
dir-Eigenschaft zusammen mit der mode als readonly definieren und die 
wahre Funktion über eine neue Eigenschaft mit setter einstellbar 
gestalten.
Oder man baut die mode-Eigenschaft mit setter dazu, belässt den enum der 
dir-Eigenschaft auf vier Elemente (mit unverfänglicheren Bezeichnungen) 
und dokumentiert die Umschaltung ("In Abhängigkait von 'mode' hat 'dir' 
die folgende Funktion: bla bla"). Mehr als RTFM ist dann für den User 
nicht drin.

[Dirk K. (merciless)]

Ist die Änderung einmalig oder hast du es jetzt
immer mit 2 "Varianten" des enums zu tun?

Im letzteren Fall würde ich Interface + 2 Klassen
definieren, und zur Laufzeit die korrekte
Implementierung über das Interface benutzen.

merciless

[sven (Gast)]

Wie wäre es mit einem Dictionary?
https://www.dotnetperls.com/dictionary

Du nimmst die vordefinierten Werte aus dem enum raus und definierst sie 
im Dictionary:
var dictionary = new Dictionary<Direction, int>();

[Cyblord -. (cyblord)]

Die Lösung ist ein OBJEKT welches den aktuellen Zustand kennt. Man muss 
ihn sinnvoll umschalten  können und es muss den Zustand sinnvoll 
ausgeben können. Überlege dir die Schnittstellen zu diesem Objekt als 
erstes. Dann erst überlegst du dir WIE das Objekt das im inneren genau 
macht.

Ob es dann mit enum + mode Variable arbeitet ist zweitrangig. Du kannst 
diesen inneren Aufbau dann auch jederzeit noch optimieren ohne den Rest 
der Anwendung zu tangieren.

C# ist objektorientiert. Arbeite auch so.

[Hans-Georg L. (h-g-l)]

In C# gibts doch auch namespaces, dafür sind die da.

[Cyblord -. (cyblord)]

Hans-Georg L. schrieb:
> In C# gibts doch auch namespaces, dafür sind die da.

Nein. Sicher nicht dafür.

[bluppdidupp (Gast)]

Mir ist das Problem noch nicht ganz klar.

public enum Direction
{
   Forward = 0,
   Up = 0,
   Backward = 1,
   Down = 1,   
   Left = 2,
   RollLeft = 2,
   Right = 3,
   RollRight = 3
}

...ist in C# erlaubt (man würde dann allerdings eher noch einen 
[Flags()]-Marker drüber setzen)

Direction x = Direction.Up;
Debug.WriteLine(x);

Direction y = Direction.Forward;
Debug.WriteLine(y);

würde allerdings vermutlich in beiden Fällen "Up" oder in beiden Fällen 
"Forward" ausgeben.
D.h. wenn man beim auslesen einer Variable mit einem der Direction-Werte 
wieder zwischen z.B. Forward und Up unterscheiden können muss, wären 
enums der falsche (oder nicht ausreichende) Weg.

[Rufus Τ. F. (rufus)]

bluppdidupp schrieb:
> würde allerdings vermutlich in beiden Fällen "Up" oder in beiden Fällen
> "Forward" ausgeben.

Nein, es gibt 0 aus.

[bluppdidupp (Gast)]

Forward
Forward
...kommt kurz ausprobiert raus (bei ".net-Framework 4.6.1" als Target in 
der Visual Studio 2017 Community Edition) - Aber ob er da 0 oder einer 
der beiden dazugehörigen Enum-Bezeichner ausgibt, macht für das Problem 
ja ohnehin keinen Unterschied ;D

[Frank O. (fop)]

Mir fällt da eine grausame Lösung mit Modulo bzw. Und-Verknüpfung ein :

public enum Direction:ushort
{
   Forward = 0,
   Up = 256,
   Backward = 1,
   Down = 257,   
   Left = 2,
   RollLeft = 258,
   Right = 3,
   RollRight = 259
}

public void ohweih(Direction wohin)
{
            switch ((Direction)((ushort)wohin & 255U))
            {
                case Direction.Forward:
                    break;
                case Direction.Backward:
                    break;
                case Direction.Left:
                    break;
                case Direction.Right:
                    break;
            }
}