Czy wyliczenia w C # powinny mieć swój własny plik? [Zamknięte]

Mam klasę, która używa wyliczenia, wyliczenie jest obecnie w swoim własnym pliku, co wydaje się marnotrawstwem.

Jaka jest ogólna opinia na temat wyliczeń umieszczanych w przestrzeni nazw pliku, w którym są używane? A może wyliczenie powinno naprawdę znajdować się we własnym pliku cs?

Edytować

Powinienem wspomnieć, że podczas gdy omawiana klasa używa tych wyliczeń, tak samo robią dzwoniący zewnętrzni. Innymi słowy, inna klasa może ustawić te wyliczenia. Więc nie są używane wewnętrznie w klasie, w przeciwnym razie to pytanie byłoby oczywiste.

Nie powiedziałbym „marnotrawstwa” (ile kosztuje dodatkowy plik?), Ale często jest to niewygodne. Zwykle jest jedna klasa, która jest najbliżej powiązana z wyliczeniem i umieszczam je w tym samym pliku.

To naprawdę tylko kwestia preferencji.

Wolę umieścić każde wyliczenie w osobnym pliku (podobnie dla każdego interfejsu, klasy i struktury, nieważne jak małe). Dzięki temu łatwiej je znaleźć, gdy przechodzę z innego rozwiązania lub w inny sposób nie mam jeszcze odniesienia do danego typu.

Umieszczenie jednego typu w każdym pliku ułatwia również identyfikację zmian w systemach kontroli źródła bez różnicowania.

To całkowicie kwestia stylu. Zwykle mam plik o nazwieEnums.cs w rozwiązaniu, w którym są zbierane deklaracje wyliczeniowe.

Ale i tak zwykle można je znaleźć za pomocą F12klucza.

Pytanie, które należy sobie zadać, brzmi: czy jest coś na temat typu wyliczenia w C #, co wskazuje, że powinienem traktować go inaczej niż wszystkie inne typy, które tworzę?

Jeśli wyliczenie jest publiczne, powinno być traktowane jak każdy inny typ publiczny. Jeśli jest prywatny, zadeklaruj go jako zagnieżdżonego członka klasy, która go używa. Nie ma żadnego ważnego powodu, aby umieszczać dwa typy publiczne w tym samym pliku tylko dlatego, że jeden jest wyliczeniem. Liczy się tylko fakt, że jest to typ publiczny; smak typu nie.

Kolejną zaletą umieszczania każdego typu (klasy, struktury, wyliczenia) we własnym pliku jest kontrola źródła. Możesz łatwo uzyskać całą historię typu.

Umieszczam głównie w przestrzeni nazw i poza klasą, aby były łatwo dostępne inne klasy w tej przestrzeni nazw, jak poniżej.

namespace UserManagement
{
    public enum UserStatus { Active, InActive }
    class User
    {
        ...
    }
}

Generalnie wolę, aby moje wyliczenia znajdowały się w tym samym pliku, co klasa, której najprawdopodobniej będzie atrybutem. Jeśli na przykład mam klasę, Taskwyliczenie TaskStatusbędzie w tym samym pliku.

Jeśli jednak mam wyliczenia o bardziej ogólnym charakterze, przechowuję je kontekstowo w różnych plikach.

To zależy od tego, jaki dostęp jest potrzebny.

Jeśli wyliczenie jest używane tylko przez jedną klasę, można zadeklarować je w tej klasie, ponieważ nie ma potrzeby używania go nigdzie indziej.

W przypadku wyliczeń używanych przez wiele klas lub w publicznym interfejsie API zawsze będę przechowywać definicję we własnym pliku w odpowiedniej przestrzeni nazw. O wiele łatwiej jest znaleźć ten sposób, a strategia opiera się na schemacie jednego obiektu na plik, który jest dobry do użycia również z klasami i interfejsami.

Myślę, że to zależy od zakresu wyliczenia. Na przykład, jeśli wyliczenie jest specyficzne dla jednej klasy, na przykład używane w celu uniknięcia scenariusza magicznej stałej, to powiedziałbym, że umieść je w tym samym pliku co klasa:

enum SearchType { Forward, Reverse }

Jeśli wyliczenie jest ogólne i może być używane przez kilka klas w różnych scenariuszach, byłbym skłonny użyć umieszczenia go we własnym pliku. Na przykład poniższe mogą być użyte do kilku celów:

enum Result { Success, Error }

Zwykle umieszczam wyliczenia w ich własnym pliku z bardzo prostego powodu: tak jak w przypadku klas i struktur, dobrze jest wiedzieć dokładnie gdzie szukać, jeśli chcesz znaleźć definicję typu: w pliku o tej samej nazwie. (Aby być uczciwym, w VS zawsze możesz też użyć opcji „Przejdź do definicji”).

Oczywiście może wymknąć się spod kontroli. Kolega, u którego pracuję, nawet tworzy osobne pliki dla delegatów.

Jedną z zalet używania oddzielnego pliku dla wyliczeń jest to, że można usunąć oryginalną klasę, która używała wyliczenia, i napisać nową klasę przy użyciu wyliczenia.

Jeśli wyliczenie jest niezależne od oryginalnej klasy, umieszczenie go w oddzielnym pliku ułatwi przyszłe zmiany.

Jeśli używasz dodatku USysWare File Browser dla programu Visual Studio, możesz bardzo szybko znaleźć pliki o określonych nazwach w swoim rozwiązaniu. Wyobraź sobie, że szukasz wyliczenia, które nie znajduje się we własnym pliku, ale zamiast tego jest zakopane w jakimś pliku w gigantycznym rozwiązaniu.

W przypadku małych rozwiązań nie ma to znaczenia, ale w przypadku dużych coraz ważniejsze staje się przechowywanie klas i wyliczeń w ich własnych plikach. Możesz je szybko znaleźć, edytować i nie tylko. Bardzo, bardzo polecam umieszczenie twojego wyliczenia w jego własnym pliku.

I jak już zostało powiedziane ... Jak marnotrawstwem jest plik, który i tak kończy się tylko kilkoma KB?

Bardzo prosta, ogromna zaleta oddzielenia pliku. Kiedy jakikolwiek obiekt znajduje się we własnym pliku MyObjectName.cs ... możesz przejść do eksploratora rozwiązań i wpisać MyObjectName.cs i wyświetlić dokładnie 1 plik. Wszystko, co poprawia debugowanie, jest fajne.

Kolejna zaleta z podobnej notatki, jeśli przeszukasz wszystkie pliki ( ctrl+ shft+ F) pod kątem nazwy, możesz znaleźć 20 odniesień do nazwy w tym samym pliku ... i ta znaleziona nazwa będzie częścią różnych obiektów. W oknie Znajdź wyniki wszystko, co możesz zobaczyć, to numer linii i nazwa pliku. Musiałbyś otworzyć plik i przewinąć, aby dowiedzieć się, w którym obiekcie znajduje się znalezione odniesienie.

Podoba mi się wszystko, co ułatwia debugowanie.

Jeśli masz wiele projektów w jednym rozwiązaniu. Wtedy lepiej stwórz kolejny projekt Utilities. Następnie utwórz folder \Enumerationsi utwórz zagnieżdżony plik static class. Następnie przypisz każdą klasę statyczną, w której utworzysz wyliczenie odpowiadające nazwom Twoich projektów. Na przykład masz projekt o nazwie DatabaseReader i DatabaseUsers, a następnie możesz nazwać klasę statyczną, taką jak

public static class EnumUtility {
    #region --Database Readers Enum
    public static class EnumDBReader {
         public enum Actions { Create, Retrieve, Update, Delete}; 
    }
    #endregion

    #region --Database Users Enum
    public static class EnumDBUsers {
         public enum UserIdentity { user, admin }; 
    }
    #endregion

}

Następnie całe wyliczenie, które można wykorzystać w całych rozwiązaniach na projekty, zostanie na nim zadeklarowane. Użyj #, regionaby oddzielić każdy problem. Dzięki temu łatwiej jest szukać wyliczeń

Lubię mieć jeden publiczny plik wyliczeń o nazwie E, zawierający każde oddzielne wyliczenie, a następnie można uzyskać dostęp do dowolnego wyliczenia za pomocą E ... i można nimi zarządzać w jednym miejscu.