Enum Naming Convention - liczba mnoga

Zadaję to pytanie, mimo że przeczytałem podobne, ale nie dokładnie to, czego chcę na konwencji nazewnictwa C # dla wyliczania i dopasowywania właściwości

Odkryłem, że mam tendencję do nazywania liczby mnogiej liczbą mnogą, a następnie „używania” jej w liczbie pojedynczej, na przykład:

public enum EntityTypes {
  Type1, Type2
}

public class SomeClass {
  /*
    some codes
  */

  public EntityTypes EntityType {get; set;}

}

Oczywiście to działa i to jest mój styl, ale czy ktoś może znaleźć potencjalny problem z taką konwencją? Mam jednak „brzydką” nazwę ze słowem „Status”:

public enum OrderStatuses {
  Pending, Fulfilled, Error, Blah, Blah
}

public class SomeClass {
  /*
    some codes
  */

  public OrderStatuses OrderStatus {get; set;}

}

Informacje dodatkowe: Może moje pytanie nie było wystarczająco jasne. Często muszę intensywnie myśleć, nazywając zmienne moich zdefiniowanych typów wyliczeń. Znam najlepszą praktykę, ale nie ułatwia to nazywania tych zmiennych.

Nie mogę ujawnić wszystkich moich właściwości wyliczania (powiedz „Status”) jako „MyStatus”.

Moje pytanie: Czy ktoś może znaleźć potencjalny problem z opisaną powyżej konwencją? NIE chodzi o najlepszą praktykę.

Przeformułowanie pytania:

Cóż, myślę, że powinienem zadać pytanie w ten sposób: Czy ktoś może wymyślić dobry ogólny sposób nazywania typu wyliczeniowego, tak że przy użyciu nazewnictwo „wystąpienia” wyliczenia będzie dość proste?

Microsoft zaleca używanie liczby pojedynczej dla Enums, chyba że Enumreprezentuje pola bitowe (użyj FlagsAttributerównież). Zobacz Konwencje nazewnictwa typów wyliczeń (podzbiór Wytycznych nazewnictwa Microsoft ).

Aby odpowiedzieć na twoje wyjaśnienie, nie widzę nic złego w żadnym z poniższych:

public enum OrderStatus { Pending, Fulfilled, Error };

public class SomeClass { 
    public OrderStatus OrderStatus { get; set; }
}

lub

public enum OrderStatus { Pending, Fulfilled, Error };

public class SomeClass {
    public OrderStatus Status { get; set; }
}

Zacząłem nazywać wyliczenia w liczbie mnogiej, ale od tego czasu zmieniłem się na liczbę pojedynczą. Po prostu wydaje się mieć większy sens w kontekście miejsca ich użycia.

enum Status { Unknown = 0, Incomplete, Ready }

Status myStatus = Status.Ready;

Porównać do:

Statuses myStatus = Statuses.Ready;

Uważam, że pojedyncza forma brzmi bardziej naturalnie w kontekście. Zgadzamy się, że deklarując wyliczenie, które ma miejsce w jednym miejscu, myślimy „to grupa wielorybów”, ale kiedy go używamy, przypuszczalnie w wielu miejscach, myślimy, że „to jest wszystko jedno” .

Sytuacja tak naprawdę nigdy nie dotyczy liczby mnogiej.

enumPokazuje atrybut coś lub inny. Podam przykład:

enum Humour
{
  Irony,
  Sarcasm,
  Slapstick,
  Nothing
}

Możesz mieć jeden typ, ale spróbuj pomyśleć o nim w wielu, a nie w liczbie mnogiej:

Humour.Irony | Humour.Sarcasm

Zamiast

Humours { Irony, Sarcasm }

Masz poczucie humoru, nie masz humoru.

Ogólnie rzecz biorąc, zalecenie dotyczące najlepszych praktyk jest liczbą pojedynczą, z wyjątkiem tych wyliczeń, które mają przypisany atrybut [Flagi] (i które dlatego mogą zawierać pola bitowe), które powinny być w liczbie mnogiej.

Po przeczytaniu edytowanego pytania mam wrażenie, że możesz pomyśleć, że nazwa właściwości lub nazwa zmiennej musi być inna niż nazwa typu wyliczeniowego ... Nie. Następujące jest całkowicie w porządku ...

  public enum Status { New, Edited, Approved, Cancelled, Closed }

  public class Order
  {
      private Status stat;
      public Status Status
      { 
         get { return stat; }
         set { stat = value; }
      }
  }

To jedno z niewielu miejsc, w których nie zgadzam się z konwencją na tyle, aby przeciwstawić się jej. TBH, NIENAWIDZĘ, że definicja wyliczenia i jego instancja mogą mieć tę samą nazwę. Po dodaniu wszystkich moich Enums wstawiam „Enum”, ponieważ wyjaśnia, w jakim kontekście jest ono używane. IMO sprawia, że ​​kod jest znacznie bardziej czytelny.

public enum PersonTypesEnum {
    smart,
    sad,
    funny,
    angry
}


public class Person {   
    public PersonTypesEnum PersonType {get; set;}
}

Nikt nigdy nie pomyli, co to jest wyliczenie i jakie jest jego wystąpienie.

Jeśli próbujesz napisać prosty, ale zabroniony kod, taki jak ten:

    public class Person
    {
        public enum Gender
        {
            Male,
            Female
        }
        //Won't compile: auto-property has same name as enum
        public Gender Gender { get; set; }  
    }

Twoje opcje to:

1. Zignoruj ​​zalecenie MS i użyj prefiksu lub sufiksu w nazwie wyliczenia:

   public class Person
   {
       public enum GenderEnum
       {
           Male,
           Female
       }
       public GenderEnum Gender { get; set; }
   }

2. Przenieś definicję wyliczenia poza klasę, najlepiej do innej klasy. Oto proste rozwiązanie powyższego:

   public class Characteristics
   {
       public enum Gender
       {
           Male,
           Female
       }
   }
   public class Person
   {
       public Characteristics.Gender Gender { get; set; }  
   }

Najlepsza praktyka - używaj liczby pojedynczej. Masz listę przedmiotów, które tworzą Enum. Używanie pozycji na liście brzmi dziwnie, kiedy mówisz Versions.1_0. Bardziej sensowne jest stwierdzenie, Version.1_0ponieważ istnieje tylko jedna wersja 1_0.

Spóźniamy się trochę ...

Istnieje ważna różnica między twoim pytaniem a tym , o którym wspomniałeś (które zadałem ;-):

Umieszczasz definicję wyliczenia poza klasą, co pozwala mieć taką samą nazwę dla wyliczenia i właściwości:

public enum EntityType { 
  Type1, Type2 
} 

public class SomeClass { 
  public EntityType EntityType {get; set;} // This is legal

}

W tym przypadku zastosowałbym się do wytycznych MS i użyłem pojedynczej nazwy dla wyliczenia (liczba mnoga dla flag). To chyba najłatwiejsze rozwiązanie.

Mój problem (w drugim pytaniu ) dotyczy tego, kiedy wyliczenie jest zdefiniowane w zakresie klasy, co uniemożliwia użycie właściwości nazwanej dokładnie po wyliczeniu.

W drugim wątku konwencja nazewnictwa C # dla wyliczania i dopasowywania właściwości ktoś wskazał, co uważam za bardzo dobry pomysł:

„Wiem, że moja sugestia jest sprzeczna z konwencjami nazewnictwa .NET, ale osobiście poprzedzam wyliczenia literą„ E ”, a flagi wyliczeń literą„ F ”(podobnie jak w przypadku interfejsów„ I ”).”