Métodos dentro de enum en C #

En Java, es posible tener métodos dentro de una enumeración.

¿Existe tal posibilidad en C # o es solo una colección de cadenas y eso es todo?

Traté de anular ToString()pero no se compila. ¿Alguien tiene una muestra de código simple?

Puede escribir métodos de extensión para tipos de enumeración:

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

Puede escribir un método de extensión para su enumeración:

Cómo: Crear un nuevo método para una enumeración (Guía de programación de C #)

Otra opción es usar la clase de enumeración creada por Jimmy Bogard .

Básicamente, debes crear una clase que herede de la suya Enumeration. Ejemplo:

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}!";
    }
}

Luego puede usarlo como una enumeración, con la posibilidad de poner métodos dentro de él (entre otras cosas):

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

Puedes descargarlo con NuGet .

Aunque esta implementación no es nativa en el lenguaje, la sintaxis (construcción y uso) está bastante cerca de los lenguajes que implementan enumeraciones de forma nativa mejor que C # ( Kotlin, por ejemplo).

No Puede crear una clase, a continuación, añadir un montón de propiedades a la clase a un tanto emular una enumeración, pero eso no es realmente lo mismo .

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 mejor patrón sería colocar sus métodos en una clase separada de su emum.

Desde que me encontré, y necesitaba exactamente lo contrario de enum a string, aquí hay una solución genérica:

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

Esto también ignora mayúsculas y minúsculas y es muy útil para analizar REST-Response a su enumeración para obtener más seguridad de tipo. Espero que ayude a alguien

C # no permite el uso de métodos en enumeradores, ya que no es un principio basado en clases, sino más bien una matriz bidimensional con una cadena y un valor.

El uso de clases es altamente desaconsejado por Microsoft en este caso, utilice estructuras (ures) (datos) en su lugar; El STRUCT está pensado como una clase ligera para datos y sus manejadores y puede manejar funciones perfectamente. C # y su compilador no tienen las capacidades de seguimiento y eficiencia como se sabe de JAVA, donde cuantas más veces se usa una determinada clase / método, más rápido se ejecuta y su uso se vuelve 'anticipado'. C # simplemente no tiene eso, así que para diferenciar, use STRUCT en lugar de CLASS.