Generic enum jako parametr metoda

Question

Biorąc konstruktor

public MyObject(int id){ 
    ID = id; 
} 

A dwa teksty stałe:

public enum MyEnum1{ 
    Something = 1, 
    Anotherthing = 2 
} 

public enum MyEnum2{ 
    Dodo = 1, 
    Moustache= 2 
} 

Czy to możliwe, aby przejść w rodzajowe enum jako parametr konstruktora? Szukam rozwiązania wzdłuż linii:

public MyObject(enum someEnum){ 
    ID = (int)someEnum; 
} 

Więc można zrobić:

var newObject = new MyObject(MyEnum1.Something); 
var anotherObject = new MyObject(MyEnum2.Dodo); 

Answer 1

Dlaczego chcesz przekazać teksty stałe, podczas gdy można przekazać liczb całkowitych?

var newObject = new MyObject((int)MyEnum1.Something); 
var anotherObject = new MyObject((int)MyEnum2.Dodo); 

i wykorzystywać swój pierwszy konstruktor:

public MyObject(int id){ 
    ID = id; 
} 

Answer 2

Innym rozwiązaniem byłoby:

public MyObject(Enum someEnum){ 
    ID = Convert.ToInt32(someEnum); 
} 

ten sposób można go używać jak prosiłeś bez konieczności oddanych do int każdorazowym zadzwoń do swoich konstruktorów:

var newObject = new MyObject(MyEnum1.Something); 
var anotherObject = new MyObject(MyEnum2.Dodo); 

Answer 3

Wystarczy użyć rodzajowe konstruktora:

class MyObject<T> { 

    public MyObject(T someEnum) where T : struct, IConvertible 
    { 
     if (!typeof(T).IsEnum) 
      throw new ArgumentException("Not an enum"); 
     ID = Convert.ToInt32(someEnum); 
    } 
} 

Teraz można łatwo nazwać tak:

var m = new MyObject<MyEnum>(MyEnum1.Something); 

Ale łatwiej byłoby przekazać enum jako liczba całkowita do konstruktora, jak wspomniano w innych odpowiedzi.

Answer 4

Czy używasz wyliczenia właściwości lub parametrów.

public enum Enum1{} 
public Enum1 enum1 { get;set; } 
public MyObject() 
{ 
    ID = (int)enum1; 
} 

Po prostu spróbuj. Mam nadzieję, że jest to przydatne.

Answer 5

Dobrze, jeśli naprawdę potrzebujesz, aby ta rozmowa rodzajowy dla szerokiej gamy typów, to IMHO należy użyć:

1. Type.IsEnum aby sprawdzić, czy argument jest naprawdę Enum;
2. Enum.GetUnderlyingType wiedzieć, na jakim typie argumentu jest oparty (niekoniecznie musi to być Int32);

3. Teraz rzuć swój obiekt.

   public static Int32 GetAnInt<T>(T arg) where T : struct 
   { 
       if ((typeof(T).IsEnum)) 
       { 
        var underlyingType = typeof(T).GetEnumUnderlyingType(); 
        if (underlyingType == typeof(Int32) 
        || underlyingType == typeof(Int16)) //etc. 
        { 
         try 
         { 
          dynamic value = arg; 
          var result = (Int32)value; // can throw InvalidCast! 
          return result; 
         } 
         catch 
         { 
          throw; 
         } 
        } 
        else 
        { 
         throw new InvalidCastException("Underlying type 
            is certainly not castable to Int32!"); 
        } 
       } 
       else 
       { 
        throw new InvalidCastException("Not an Enum!"); 
       } 
   } 
   

   W ten sposób można osiągnąć piękny składnię: var j = GetAnInt(MyEnum.FirstValue);