¿Deben las enumeraciones en C # tener su propio archivo? [cerrado]

Tengo una clase que usa una enumeración, la enumeración está actualmente en su propio archivo que parece un desperdicio.

¿Cuál es la opinión general sobre las enumeraciones que se colocan dentro del espacio de nombres de un archivo en el que se consumen? ¿O debería la enumeración realmente vivir en su propio archivo cs?

Editar

Debo mencionar que si bien la clase en cuestión usa estas enumeraciones, también lo hacen las personas que llaman externas. En otras palabras, otra clase puede establecer estas enumeraciones. Por lo tanto, no se utilizan internamente para la clase, de lo contrario esta pregunta sería obvia.

No diría "derrochador" (¿cuánto cuesta un archivo adicional?), Pero a menudo no es conveniente. Por lo general, hay una clase que se asocia más estrechamente con la enumeración, y las pongo en el mismo archivo.

Esto es realmente solo una cuestión de preferencia.

Prefiero poner cada enumeración en su propio archivo (del mismo modo para cada interfaz, clase y estructura, por pequeña que sea). Los hace más fáciles de encontrar cuando vengo de otra solución o de lo contrario no tengo una referencia al tipo en cuestión.

Poner un solo tipo en cada archivo también facilita la identificación de cambios en los sistemas de control de código fuente sin diferir.

Esto es completamente una cuestión de estilo. Lo que tiendo a hacer es tener un archivo llamadoEnums.cs en la solución en la que se recopilan las declaraciones de enumeración.

Pero normalmente se encuentran a través de la F12clave de todos modos.

La pregunta que debería hacerse sería: ¿hay algo sobre un tipo de enumeración en C # que indique que debería tratarlo de manera diferente a todos los demás tipos que creo?

Si la enumeración es pública, debe tratarse como cualquier otro tipo público. Si es privado, declararlo como un miembro anidado de la clase que lo usa. No hay una razón convincente para poner dos tipos públicos en el mismo archivo simplemente porque uno es una enumeración. El hecho de que sea de tipo público es lo único que importa; el sabor del tipo no.

Otra ventaja de poner cada tipo (clase, estructura, enumeración) en su propio archivo es el control de origen. Puede obtener fácilmente el historial completo del tipo.

Coloco principalmente dentro del espacio de nombres y fuera de la clase para que sea fácilmente accesible a otras clases en ese espacio de nombres como a continuación.

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

En general, prefiero que mis enumeraciones estén en el mismo archivo que la Clase de la que probablemente será un atributo. Si, por ejemplo, tengo una clase Task, la enumeración TaskStatusestará en el mismo archivo.

Sin embargo, si tengo enumeraciones de naturaleza más genérica, las guardo contextualmente en varios archivos.

Depende de qué acceso se necesita.

Si la enumeración solo es utilizada por una sola clase, está bien declararla dentro de esa clase porque no necesita usarla en ningún otro lugar.

Para las enumeraciones utilizadas por varias clases o en una API pública, siempre mantendré la definición en su propio archivo en el espacio de nombres apropiado. Es mucho más fácil encontrarlo de esa manera, y la estrategia sigue el patrón de un objeto por archivo, que también es bueno para usar con clases e interfaces.

Creo que eso depende del alcance de la enumeración. Por ejemplo, si la enumeración es específica de una clase, por ejemplo, utilizada para evitar el escenario de la constante mágica, entonces diría que la coloque en el mismo archivo que la clase:

enum SearchType { Forward, Reverse }

Si la enumeración es general y puede ser utilizada por varias clases para diferentes escenarios, me inclinaría a ponerla en su propio archivo. Por ejemplo, lo siguiente podría usarse para varios propósitos:

enum Result { Success, Error }

Tiendo a poner enumeraciones en su propio archivo por una razón muy simple: al igual que con las clases y estructuras, es bueno saber exactamente dónde buscar si desea encontrar la definición de un tipo: en el archivo del mismo nombre. (Para ser justos, en VS siempre puedes usar "Ir a definición").

Obviamente, puede salirse de control. Un colega donde trabajo incluso crea archivos separados para los delegados.

Una ventaja de usar un archivo separado para las enumeraciones es que puede eliminar la clase original que utilizó la enumeración y escribir una nueva clase utilizando la enumeración.

Si la enumeración es independiente de la clase original, colocarla en un archivo separado facilita los cambios futuros.

Si está utilizando el complemento USysWare File Browser para Visual Studio, puede encontrar rápidamente archivos de nombres particulares en su solución. Imagine buscar una enumeración que no está en su propio archivo, sino que está enterrada en algún archivo en una solución gigantesca.

Para soluciones pequeñas, no importa, pero para las grandes, se vuelve aún más importante mantener las clases y enumeraciones en sus propios archivos. Puede encontrarlos rápidamente, editarlos y más. Recomiendo encarecidamente poner su enumeración en su propio archivo.

Y como se dijo ... ¿Qué tan inútil es un archivo que termina siendo solo un par de kb?

Muy simple gran ventaja para separar el archivo. Cuando cualquier objeto está en su propio archivo MyObjectName.cs ... puede ir al explorador de soluciones y escribir MyObjectName.cs y ver exactamente 1 archivo. Cualquier cosa que mejore la depuración es agradable.

Otra ventaja en una nota similar, si busca un nombre en todos los archivos ( ctrl+ shft+ F), puede encontrar 20 referencias al nombre en el mismo archivo ... y ese nombre encontrado será parte de diferentes objetos. En la ventana Buscar resultados, todo lo que puede ver es el número de línea y el nombre del archivo. Tendría que abrir el archivo y desplazarse para averiguar en qué objeto estaba la referencia encontrada.

Cualquier cosa que facilite la depuración, me gusta.

Si tienes múltiples proyectos en una solución. Entonces mejor crear otro proyecto Utilities. Luego cree una carpeta \Enumerationsy cree un anidado static class. Y luego asigne cada clase estática donde creará una enumeración que corresponda al nombre de sus proyectos. Por ejemplo, si tiene un proyecto llamado DatabaseReader y DatabaseUsers, puede nombrar la clase estática como

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

}

Luego, se declarará toda la enumeración que se puede usar en las soluciones completas por proyecto. Use # regionpara separar cada preocupación. Con esto, es más fácil buscar enumeraciones

Me gusta tener un archivo de enumeraciones público llamado E que contenga cada enumeración separada, luego se puede acceder a cualquier enumeración con E ... y están en un solo lugar para administrar.