Méthodes à l'intérieur d'énumération en C #

165

En Java, il est possible d'avoir des méthodes dans une énumération.

Existe-t-il une telle possibilité en C # ou est-ce juste une collection de chaînes et c'est tout?

J'ai essayé de remplacer ToString()mais il ne compile pas. Quelqu'un a-t-il un exemple de code simple?

Eya
la source
Je ne pense pas que vous puissiez avoir des méthodes dans un Enum en C #. Qu'essayez-vous de faire?
Duncan Howe
essayer d'obtenir le comportement de Java et encapsuler la logique proche des Enums. de toute façon, je vois des réponses que ce n'est pas possible - je vais mettre en œuvre des extensions.
Eya

Réponses:

272

Vous pouvez écrire des méthodes d'extension pour les types enum:

enum Stuff
{
    Thing1,
    Thing2
}

static class StuffMethods
{

    public static String GetString(this Stuff s1)
    {
        switch (s1)
        {
            case Stuff.Thing1:
                return "Yeah!";
            case Stuff.Thing2:
                return "Okay!";
            default:
                return "What?!";
        }
    }
}

class Program
{


    static void Main(string[] args)
    {
        Stuff thing = Stuff.Thing1;
        String str = thing.GetString();
    }
}
MarkPflug
la source
11

Une autre option consiste à utiliser la classe d'énumération créée par Jimmy Bogard .

Fondamentalement, vous devez créer une classe qui hérite de la sienne Enumeration. Exemple:

public class EmployeeType : Enumeration
{
    public static readonly EmployeeType Manager 
        = new EmployeeType(0, "Manager");
    public static readonly EmployeeType Servant 
        = new EmployeeType(1, "Servant");
    public static readonly EmployeeType Assistant
        = new EmployeeType(2, "Assistant to the Regional Manager");

    private EmployeeType() { }
    private EmployeeType(int value, string displayName) : base(value, displayName) { }

    // Your method...
    public override string ToString()
    {
        return $"{value} - {displayName}!";
    }
}

Ensuite, vous pouvez l'utiliser comme une énumération, avec la possibilité de mettre des méthodes à l'intérieur (entre autres):

EmployeeType.Manager.ToString();
//0 - Manager
EmployeeType.Servant.ToString();
//1 - Servant
EmployeeType.Assistant.ToString();
//2 - Assistant to the Regional Manager

Vous pouvez le télécharger avec NuGet .

Bien que cette implémentation ne soit pas native dans le langage, la syntaxe (construction et utilisation) est assez proche des langages qui implémentent les énumérations nativement mieux que C # ( Kotlin par exemple).

fabriciorissetto
la source
3

Nan. Vous pouvez créer une classe, puis ajouter un tas de propriétés à la classe pour émuler un peu une énumération, mais ce n'est pas vraiment la même chose .

class MyClass
{
    public string MyString1 { get{ return "one";} }
    public string MyString2 { get{ return "two";} }
    public string MyString3 { get{ return "three";} }

    public void MyMethod()
    {
        // do something.
    }
}

Un meilleur modèle serait de mettre vos méthodes dans une classe distincte de votre emum.

Kyle Trauberman
la source
0

Depuis que je suis tombé sur et que j'avais besoin de l'exact opposé de enum à string, voici une solution générique:

static class EnumExtensions {
    public static T GetEnum<T>(this string itemName) {
        return (T) Enum.Parse(typeof(T), itemName, true);
    }
}

Cela ignore également la casse et est très pratique pour analyser REST-Response dans votre énumération afin d'obtenir plus de sécurité de type. Espérons que cela aide quelqu'un

scrat84
la source
-15

C # Ne permet pas l'utilisation de méthodes dans les énumérateurs car il ne s'agit pas d'un principe basé sur une classe, mais plutôt d'un tableau à 2 dimensions avec une chaîne et une valeur.

L'utilisation de classes est fortement déconseillée par Microsoft dans ce cas, utilisez plutôt (data) struct (ures); Le STRUCT est conçu comme une classe légère pour les données et ses gestionnaires et peut gérer des fonctions très bien. C # et son compilateur n'ont pas les capacités de suivi et d'efficacité comme on le sait de JAVA, où plus une certaine classe / méthode est utilisée, plus elle s'exécute rapidement et son utilisation devient «anticipée». C # n'a tout simplement pas cela, donc pour différencier, utilisez STRUCT au lieu de CLASS.

user236800
la source
7
Sept votes contre sans un seul commentaire pour expliquer ce qui ne va pas avec cette réponse? Allez les gars ...
Good Night Nerd Pride
Toutes les informations fournies dans cet article sont-elles fausses?
VK
5
Cette partie est vraie: C # n'autorise pas l'utilisation de méthodes dans les énumérateurs. Je ne suis pas sûr que le raisonnement soit correct, et le deuxième paragraphe semble totalement hors de propos pour la question. S'il existe un moyen d'utiliser une structure pour simuler une énumération avec un comportement, il serait préférable de fournir un exemple.
Mishelle
3
Je pense que les implications sont assez claires ici. Ne remplacez pas une énumération (qui est un type valeur) par une classe (qui est un type référence) juste pour ajouter des méthodes, car les structs peuvent également avoir des méthodes et sont également des types valeur.
smelch