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

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?

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();
    }
}

Vous pouvez écrire une méthode d'extension pour votre enum:

Comment: créer une nouvelle méthode pour une énumération (Guide de programmation C #)

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).

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.

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

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.