Соглашение об именовании C# для перечисления и соответствующего свойства



Я часто обнаруживаю, что реализую класс, поддерживающий какое-то собственное свойство статуса в качестве перечисления: у меня есть перечисление статуса и одно свойство статуса типа Status. Как мне решить этот конфликт?

public class Car
{
  public enum Status
  {
    Off,
    Starting,
    Moving
  };

  Status status = Status.Off;

  public Status Status // <===== Won't compile =====
  {
    get { return status; }
    set { status = value; DoSomething(); }
  }
}

Если бы перечисление состояний было общим для разных типов, я бы поставил его вне класса, и проблема была бы решена. Но статус применяется только к автомобилю, поэтому нет смысла объявлять перечисление вне класса.

какое соглашение об именах вы используете в данном случае?

NB: этот вопрос частично обсуждался в комментариях ответа этот вопрос. Так как это был не главная вопрос, он не получил много видимости.

EDIT: Филип Экберг предлагает отличный обходной путь IMO для конкретного случая "статуса". Тем не менее, мне было бы интересно прочитать о решениях, где имя перечисления/свойства отличается, как в Майкле Прювецки ответ.

EDIT2 (май 2010): мое любимое решение состоит в том, чтобы плюрализовать имя типа перечисления, как предложил Крис С. Согласно рекомендациям MS, это должно использоваться только для перечислений флагов. Но мне это нравится все больше и больше. Теперь я использую его и для обычных перечислений.

173   8  

8 ответов:

Я добавлю свой 1 евро к обсуждению, но это, вероятно, не добавляет ничего нового.

очевидное решение состоит в том, чтобы переместить статус из вложенное перечисление. Большинство перечислений .NET (за исключением, возможно, некоторых в Windows.Forms namespace) не являются вложенными, и это делает его раздражающим для использования разработчиком, потребляющим ваш API, имея префикс имени класса.

одна вещь, которая не упоминается это флаг перечисления в соответствии с руководящими принципами MSDN должны будет множественное число существительных который вы, вероятно, уже знаете (статус-это простое перечисление, поэтому следует использовать единственные существительные).

State (enum called States) - это вокатив, "статус" - это именительный падеж существительного, которое англичане, как и большинство наших языков, впитали из латыни. Вокатив - это то, что вы называете существительным для его состояния, а номинатив-это предмет глагола.

другими словами, когда автомобиль движется, это глагол-перемещение-это его статус. Но машина не заглохла, заглох ее двигатель. И он не запускается, двигатель делает (вы, вероятно, выбрали пример здесь, так что это может быть неуместно).

public class Car
{
  VehicleState _vehicleState= VehicleState.Stationary;

  public VehicleState VehicleState 
  {
    get { return _vehicleState; }
    set { _vehicleState = value; DoSomething(); }
  }
}

public enum VehicleState
{
    Stationary, Idle, Moving
}

State - это такое обобщенное существительное, не лучше ли описать, к какому состоянию оно относится? Как я сделал выше

пример типа также, на мой взгляд, не относится к типу читателя, а к его базе данных. Я бы предпочел, чтобы вы описывали продукт базы данных читателя, который не обязательно относится к типу читателя (например, тип читателя может быть только вперед, кэшируется и так далее). Так что

reader.Database = Databases.Oracle;

на самом деле это никогда не происходит, поскольку они реализованы как драйверы и цепочка наследования вместо использования перечислений, поэтому строка выше не выглядит естественной.

определение "Off", "Starting" и "Moving" - это то, что я бы назвал "состоянием". И когда вы подразумеваете, что используете "состояние", это ваш "статус". Итак!

public class Car
{
  public enum State
  {
    Off,
    Starting,
    Moving
  };

  State state = State.Off;

  public State Status
  {
    get { return state ; }
    set { state= value; DoSomething(); }
  }
}

если мы возьмем другой пример из того, где вы хотели бы использовать слово " тип " такой в этом случае:

public class DataReader
{
    public enum Type
    {
        Sql,
        Oracle,
        OleDb
    }

    public Type Type { get; set; } // <===== Won't compile =====

}

вам действительно нужно увидеть, что есть разница между перечислениями и перечислениями, не так ли? Но при создании фреймворка или разговоре об архитектуре вам нужно сосредоточиться на подобия, ОК позволяет найти их:

когда что-то устанавливается в состояние, оно определяется как статус "вещи"

пример: состояние автомобиля находится в запущенном состоянии, остановленном состоянии и так далее.

что вы хотите достичь во втором примере несколько это:

myDataReader.Type = DataReader.Database.OleDb

вы можете подумать, что это говорит против того, что я проповедовал другим, что вам нужно следовать стандарту. Но, вы следуете стандарту! Этот В SQL-кейс-это конкретная ситуация, а поэтому нужно несколько конкретных решений.

однако перечисление будет повторно использоваться в вашем System.Data пространство, и это то, что шаблоны все О.

еще один случай, чтобы посмотреть на "тип" - это" животное", где тип определяет вид.

public class Animal
    {
        public enum Type
        {
            Mammal,
            Reptile,
            JonSkeet
        }

        public Type Species{ get; set; }

    }

Это следует за шаблоном, вам конкретно не нужно "знать" объект для этого, и вы не указываете "AnimalType" или "DataReaderType", вы можете повторно использовать перечисления в выбранном пространстве имен.

Я думаю, что реальная проблема здесь заключается в том, что статус enum инкапсулируется в вашем классе, так что Car.Status неоднозначно для обоих свойств Status и перечисления Status

еще лучше, поставьте перечисление вне класса:

public enum Status
{
    Off,
    Starting,
    Moving
}

public class Car
{
    public Status Status
    { ... }
}

обновление

из-за комментариев ниже, я объясню свой дизайн выше.

Я тот, кто не верит, что перечисления или классы или любой другой объект должен находиться внутри другой класс, если он будет полностью частным в этом классе. Возьмем приведенный выше пример, например:

public class Car
{
    public enum Status
    {...}
    ...
    public Status CarStatus { get; set;}
}

хотя некоторые комментаторы утверждают, что статус не имеет никакого значения за пределами класса автомобиля, тот факт, что вы устанавливаете общественные свойства означает, что есть и другие части программы, что будет использовать enum типа:

public Car myCar = new Car();
myCar.CarStatus = Car.Status.Off;

и это для меня-это запах кода. Если я собираюсь посмотреть на этот статус за пределами на Car, я мог бы также определить его за пределами как хорошо.

как таковой, я, вероятно, просто переименую его как:

public enum CarStatus
{...}

public class Car
{
    ...
    public CarStatus Status { get; set; }
}

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

Я знаю, что мое предложение противоречит соглашениям об именах .NET, но я лично префикс перечислений с " E "и флагами перечисления с" F "(аналогично тому, как мы префиксируем интерфейсы с "I"). Я действительно не понимаю, почему это не конвенции. Перечисления / флаги-это особый случай, как интерфейсы, которые никогда не изменят свой тип. Это не только дает понять, что это такое, но и очень легко ввести intellisense, так как префикс будет фильтровать большинство других типов/переменных/и т. д., И у вас их не будет именование столкновений.

и это также решит другую проблему, когда для примеров в WPF они используют статические классы, такие как перечисления (например, FontWeights), которые имеют предопределенные экземпляры типов, но вы не знаете, если вы не ищете его. Если они просто префикс их с 'E', все, что вам нужно будет сделать, это ввести на символ, чтобы найти эти специальные статические классы.

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

public class Car
{
  public enum StatusEnum
  {
    Off,
    Starting,
    Moving
  };

  public StatusEnum Status { get; set; }

}

Я бы изменил имя свойства на что-то вроде "CurrentStatus". Быстрый легкий :)

Я предлагаю добавить "Option" к имени типа (или флагу, если он содержит битовые флаги), т. е. тип-Car.StatusOption и свойство-автомобиль.Статус.

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

Я обычно префикс перечислений, например CarStatus. Я полагаю, что все зависит от команды, с которой вы работаете (если у них есть какие-либо правила/ процессы для такого рода вещей) и использования объектов. Просто мои 2 цента (:

    Ничего не найдено.

Добавить ответ:
Отменить.