Перечисление С# в интерфейсе/базовом классе?

Не существует такой вещи, как абстрактное перечисление (которое может иметь разные реализации в подклассах), но дженерики могут быть вариантом:

class Base<T> where T : struct {
    private T value;
    public void Foo(T value) {
        this.value = value;
    }
}
class Parent1 : Base<Parent1.Enum1> {
    public enum Enum1 {A, B, C};
}
class Parent2 : Base<Parent2.Enum2> {
    public enum Enum2 { J, H, K };
}

Единственная проблема заключается в том, что это не гарантирует, что можно использовать только перечисления - вы можете сделать это во время выполнения, например, в инициализаторе типа:

static Base() {
    if (!typeof(T).IsEnum) throw new InvalidOperationException(
         typeof(T).Name + " is not an enum");
}

Удивительно, как часто я встречаю людей, которые спорят о том, почему что-то требуется, вместо того, чтобы отвечать на заданный вопрос или хранить сплетни — и то, и другое было бы полезнее, чем тратить время на вопросы почему. заданный вопрос был сделан вместо другого вопроса, на который респондент действительно знает ответ. Отвечать на вопросы, которые не были заданы, никоим образом не помогает, хорошо, ребята?!

Возвращаясь к обсуждаемой теме, сегодня утром я столкнулся именно с описанным выше сценарием и могу понять, почему было бы полезно определить Enum в интерфейсе или базовом классе, а затем переопределить Enum с тем же именем. в классе, производном от базового или интерфейса. Одно из применений такого дизайна — объектно-реляционное сопоставление и привязка элементов управления. У вас может быть набор перечислений, описывающих, какие свойства ваших производных классов можно привязать к каким типам элементов управления, например:

    public enum WebControlTextBoxProperties { }

    public enum WebControlLabelProperties { }

...и так далее.

Поскольку вы точно не знаете, какие свойства будут существовать для данного производного класса до тех пор, пока не вступит в силу соответствующее наследование, но поскольку вы также можете захотеть иметь согласованные методы, которые используют вышеуказанные перечисления в вашей базе или интерфейсе, это совершенно правильный дизайн ожидать возможности определить, что Enum будет существовать в базе/интерфейсе, но точно определить, какие члены он имеет в конкретном контексте в любых производных классах.

Я действительно хотел бы, чтобы это было возможно в C#, как в VB, потому что это было бы действительно полезной функцией.

Вы должны иметь возможность объявить перечисление в базовом классе, а затем изменить значения для каждого производного класса, т.е.

class MyClass
{
    public enum TestEnum { }

    public MyClass()
    {
    }
}

class MyDerivedClass
{
    public enum TestEnum { value1, value2, value3 }

    public MyDerivedClass()
    {
    }
}

Класс MyDervied будет иметь доступ к TestEnum.value1, TestEnum.value2, TestEnum.value3, тогда как MyClass будет иметь доступ только к типу.

Однако лично я не вижу в этом преимущества. Я бы объявил ВСЕ значения перечисления в базовом классе и использовал только те, которые мне нужны для каждого класса.

Джеймс.

Почему вы не можете определить перечисление в базовом классе:

class Base 
{
   public enum Test {A, B, C, J, H, K};
}

И использовать только соответствующие члены enum в производных классах?

Нет, это невозможно.

Обратите внимание, что многие перечисления часто указывают на проблему с дизайном (например, многие конструкции switch). Перейдите по этой ссылке, чтобы увидеть пример рефакторинга: Заменить условное выражение на полиморфизм.

Нет, нет никакого способа принудительно применить что-либо статичное в интерфейсе.

Возможно, вам нужно переосмыслить свой дизайн.

Я на работе, поэтому не могу подробно рассказать, но это возможно до определенного момента. Недостатком приведенного ниже кода является то, что вы не можете объединять перечисления, такие как TextBoxProperties и MyCustomTextBoxProperties : TextboxProperties

Вот код.

    public enum Test
    {

    }

    public enum ThisTest
    {
        MyVal1,
        MyVal2,
        MyVal3
    }

    public abstract class MyBase
    {
        public Test MyEnum { get; set; }
    }

    public class MyDerived : MyBase
    {
        public new ThisTest MyEnum { get; set; }
    }

ВЫ МОЖЕТЕ АБСТРАКТИРОВАНИЕ ПЕРЕЧИСЛЕНИЯ!

Почему люди настаивают на том, что что-то невозможно, ничего не проверив?

Конечно, документация .NET немного расплывчата по этому поводу, но класс System.Enum ЯВЛЯЕТСЯ абстракцией перечисления. Вы можете использовать System.Enum как переменную, которая будет принимать ТОЛЬКО значения перечисления, и вы можете получить доступ к имени или значению типа значения перечисления через этот класс.

Например:

        // abstracted enumeration value
        Enum abstractEnum = null;

        // set to the Console-Color enumeration value "Blue";
        abstractEnum = System.ConsoleColor.Blue;

        // the defined value of "ConsoleColor.Blue" is "9":
        // you can get the value via the ToObject method:
        Console.WriteLine((int)Enum.ToObject(abstractEnum.GetType(), abstractEnum));

        // or via the GetHashCode() method:
        Console.WriteLine(abstractEnum.GetHashCode());

        // the name can also be acessed:
        Console.WriteLine(Enum.GetName(abstractEnum.GetType(), abstractEnum));

Вывод из приведенного выше кода:

9

9

Синий

Мне нравится принятый ответ @Marc Gravell. Поскольку я новичок в stackoverflow, мне не разрешено комментировать. Но я хотел бы добавить, что полезно также проверить базовый тип перечисления, особенно если вы используете атрибут флага и выполняете побитовые операции тестирования флагов...

if ( !typeof(T).IsEnum || typeof(int) != Enum.GetUnderlyingType(typeof(T)) )
{
     throw new InvalidOperationException( typeof(T).Name + " is not an enum");
}

Вот решение, которое работает для меня:

в родительском классе объявите поле как int, а не как enum:

protected int state;

поэтому родительский класс все еще может использовать это значение как int, чтобы обеспечить сериализацию и десериализацию этого значения на диск.

Затем, кто переопределяет класс, может сделать это:

enum states{
  state1, state2
}

this.state = state1.toInt();

и может получить доступ к фактическому значению следующим образом:

...
if (this.state == states.state1.toInt()){
      ...
}
else{
     ...
}

где toInt() определен в статическом классе следующим образом:

public static class Utils
{

    public static int toInt(this state s)
    {
        return (int)s;
    }
 }