Passage des valeurs énumérées aux fonctions

Question

Dites que j'ai une fonction qui prend un entier comme argument. J'aimerais pouvoir utiliser une liste énumérée pour conserver les valeurs entières organisées.

Par exemple, je voudrais idéalement pouvoir définir ces (pseudo-code):

public enum days 
{ 
    monday, 
    tuesday, 
    etc... 
} 

public enum months 
{ 
    january, 
    february, 
    etc... 
} 

int doSomething(enum x) 
{ 
    return x + 1; 
} 

et être en mesure d'appeler la fonction en utilisant soit des listes énumérées comme suit:

int a = doSomething(days.monday); 
int y = doSomething(months.february); 

Cela évidemment ne fonctionnera pas comme-est parce que les besoins doSomething à définir en utilisant seulement l'un des énumérations (à savoir soit des jours ou des mois). Je connais quelques options. L'un est simplement jeté un int:

int a = doSomething((int)days.monday); 
int y = doSomething((int)months.february); 

Le seul problème est que cette fonction est appelée place beaucoup dans mon code, et il est maladroit de devoir continuer à mettre « (int) » s dans le place (l'une des principales motivations pour grouper ces valeurs int ensemble en enums est en premier lieu de rendre le code plus lisible).

Une autre option est d'éviter énumérations tout à fait, et regrouper plutôt les valeurs dans une classe de conteneur, quelque chose comme:

static class Days 
{ 
    static int x = 0; 

    static int monday = x++; 
    static int tuesday = x++; 
} 

Encore une fois, cela fonctionnera mais juste semble terriblement lourd quand j'ai beaucoup de ces conteneurs classes à définir.

La réponse pourrait très bien être qu'il n'y a pas de façon plus simple, et que je dois être un adulte et juste accepter une de ces options. Mais je pensais que j'obtiendrais un contrôle de santé avant de m'y engager. Y a-t-il une troisième option?

Answer 1

Quel est votre problème?

public enum Days : short 
{ 
    Monday = 1, 
    Tuesday = 2, 
    ... 
} 

DoSomething(Days.Monday); 

void DoSomething(Days day) 
{ 
    Days nextDay = day + 1; 
} 

Notez également already built-in enum System.DayOfWeek.

---

Je me suis point OP, mais autant que je sache ce n'est pas supporté par C# encore:

void DoSomething<T>(T e) where T : enum 
{ 
    T next = e + 1; 
} 

Answer 2

oui vous pouvez le faire

public enum days : int 
{ 
    monday, 
    tuesday, 
    ... 
} 

automatiquement lundi devient 0 et mardi devient 1 et ainsi sur

public enum months : int 
{ 
    january, 
    february, 
    ... 
} 

même pendant des mois

int doSomething(Enum x) 
{ 
    return (int)x + 1; 
} 

et l'appeler comme

int a = doSomething(days.monday); 

ou appelez comme

int a = doSomething(months.january); 

maintenant days.monday equals 0 et après la méthode a devient 1.

Answer 3

Tout problème avec System.DateTime?

Ce serait le type le plus pragmatique à utiliser.

Answer 4

Vous pourriez surcharger votre méthode, si vous voulez juste la valeur int, peut-être quelque chose comme ça?

int dosomething(enum x) 
{return dosomething((int)x)} 
int dosomething(int x) 
{return x+1} 

Answer 5

Ou si vous ne voulez pas changer toutes les énumérations existantes:

public static int DoSomething(Enum x) 
    { 
     int xInt = (int)Convert.ChangeType(x, x.GetTypeCode()); 
     DoSomething(xInt); 
    } 

comme indiqué ici: enums-returning-int-value

Answer 6

vous essayez de surcharger a fait une fonction par le paramètre:

int DoSomething(Enum1 value) 
int DoSomething(Enum2 value) 

Answer 7

public enum days : int 
{ monday, tuesday, 

} 

public enum months :int 
{ january, february, march, 

} 

public int doSomething(int z) 
{ 
    return z + 1; 
} 

// votre méthode d'appel int c = ee.doSomething ((int) testenums.months.march); int c = ee.doQuelque chose ((int) testenums.day.February);

code de travail que vous avez toujours passer ENUM et qui est de type int vous avez juste besoin d'analyser et d'envoyer ce code fonctionne parfaitement .. laissez-moi savoir

Answer 8

J'ai passé un temps « peu » à ce sujet, parce obtenu un même problème (solution). Voici donc ma solution qui fonctionne très bien sur (.NET 4), Windows Forms:

VB:NET 

      Private Function DoSomething(Of TEnum As {IComparable, IConvertible, IFormattable})(ByVal valueEnum As TEnum) As Int32 

       Dim i As Int32 = CInt(Convert.ChangeType(valueEnum, valueEnum.GetTypeCode())) 
       //Do something with int 
       i += 1 
       Return i 

      End Function 

    C# 

     private int DoSomething<TEnum>(TEnum valueEnum) where TEnum: IComparable, IConvertible, IFormattable 
        { 
         int i = 0; 
         i = (int)Convert.ChangeType(valueEnum, valueEnum.GetTypeCode()); 
         i++; 
         return i; 
        }