As enumerações em C # devem ter seu próprio arquivo? [fechadas]

Eu tenho uma classe que usa uma enumeração, a enum está atualmente em seu próprio arquivo, o que parece um desperdício.

Qual é a opinião geral sobre enumerações sendo colocadas no espaço para nome de um arquivo em que elas são consumidas? Ou o enum deve realmente viver em seu próprio arquivo cs?

Editar

Devo mencionar que, embora a classe em questão use essas enumerações, os chamadores externos também. Em outras palavras, outra classe pode definir essas enumerações. Portanto, eles não são usados ​​internamente para a turma, caso contrário, essa pergunta seria um acéfalo.

Eu não diria "desperdício" (quanto custa um arquivo extra?), Mas muitas vezes é inconventiente. Geralmente, há uma classe que está mais intimamente associada à enumeração, e eu as coloco no mesmo arquivo.

Isso é realmente apenas uma questão de preferência.

Eu prefiro colocar cada enumeração em seu próprio arquivo (da mesma forma para cada interface, classe e estrutura, por menor que seja). Isso os torna mais fáceis de encontrar quando venho de outra solução ou caso contrário ainda não tem uma referência ao tipo em questão.

A inserção de um único tipo em cada arquivo também facilita a identificação de alterações nos sistemas de controle de origem sem diferenças.

Isso é inteiramente uma questão de estilo. O que costumo fazer é ter um arquivo chamado Enums.csna solução na qual as declarações de enum são coletadas.

Mas eles geralmente são encontrados através da F12chave.

A pergunta a ser feita seria: existe algo sobre um tipo de enumeração em C # que indica que eu deveria tratá-lo de maneira diferente de todos os outros tipos criados?

Se a enumeração for pública, ela deve ser tratada como qualquer outro tipo público. Se for privado, declare-o como um membro aninhado da classe usando-o. Não há motivo convincente para colocar dois tipos públicos no mesmo arquivo simplesmente porque um é uma enumeração. O fato de ser do tipo público é tudo o que importa; o sabor do tipo não.

Outra vantagem de colocar cada tipo (classe, estrutura, enum) em seu próprio arquivo é o controle de origem. Você pode facilmente obter todo o histórico do tipo.

Coloco principalmente dentro do namespace e fora da classe, para que seja facilmente acessível outras classes nesse namespace, como abaixo.

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

Geralmente, prefiro que minhas enumerações estejam no mesmo arquivo da classe da qual provavelmente será um atributo. Se, por exemplo, eu tiver uma classe Task, o enum TaskStatusestará no mesmo arquivo.

No entanto, se eu tiver enumerações de natureza mais genérica, eu as mantenho contextualmente em vários arquivos.

Depende do acesso necessário.

Se o enum é usado apenas por uma única classe, não há problema em declará-lo nessa classe porque você não precisa usá-lo em nenhum outro lugar.

Para enumerações usadas por várias classes ou em uma API pública, sempre manterei a definição em seu próprio arquivo no espaço de nomes apropriado. É muito mais fácil encontrar esse caminho, e a estratégia segue o padrão de um objeto por arquivo, o que também é bom para usar com classes e interfaces.

Eu acho que isso depende do escopo do enum. Por exemplo, se o enum é específico para uma classe, por exemplo, usado para evitar o cenário mágico constante, então eu diria que coloque-o no mesmo arquivo da classe:

enum SearchType { Forward, Reverse }

Se o enum é geral e pode ser usado por várias classes para diferentes cenários, então eu estaria inclinado a usá-lo em seu próprio arquivo. Por exemplo, o abaixo pode ser usado para várias finalidades:

enum Result { Success, Error }

Costumo colocar enumerações em seu próprio arquivo por um motivo muito simples: como nas classes e estruturas, é bom saber exatamente onde procurar se você deseja encontrar a definição de um tipo: no arquivo com o mesmo nome. (Para ser justo, no VS você sempre pode usar "Ir para a definição" também.)

Obviamente, pode ficar fora de controle. Um colega em que trabalho cria arquivos separados para os delegados.

Uma vantagem de usar um arquivo separado para enumerações é que você pode excluir a classe original que usou a enumeração e escrever uma nova classe usando a enumeração.

Se a enumeração for independente da classe original, colocá-la em um arquivo separado facilita as alterações futuras.

Se você estiver usando o suplemento USysWare File Browser para Visual Studio, poderá encontrar rapidamente arquivos de nomes específicos na sua solução. Imagine procurar um enum que não esteja em seu próprio arquivo, mas que esteja enterrado em algum arquivo em uma solução gigantesca.

Para pequenas soluções, não importa, mas para grandes, torna-se ainda mais importante manter classes e enums em seus próprios arquivos. Você pode encontrá-los rapidamente, editá-los e muito mais. Eu recomendo colocar seu enum em seu próprio arquivo.

E como foi afirmado ... Qual é o desperdício de um arquivo que acaba sendo apenas alguns kb?

Vantagem enorme muito simples para separar o arquivo. Quando qualquer objeto está em seu próprio arquivo MyObjectName.cs ... você pode acessar o Solution Explorer e digitar MyObjectName.cs e exibir exatamente 1 arquivo. Qualquer coisa que melhore a depuração é bom.

Outra vantagem em uma nota semelhante: se você pesquisar um nome em todos os arquivos ( ctrl+ shft+ F), poderá encontrar 20 referências ao nome no mesmo arquivo ... e esse nome encontrado fará parte de objetos diferentes. Na janela Resultados da Pesquisa, tudo o que você pode ver é o número da linha e o nome do arquivo. Você precisaria abrir o arquivo e rolar para descobrir em qual objeto a referência encontrada estava.

Qualquer coisa que facilite a depuração, eu gosto.

Se você tiver vários projetos em uma solução. Então é melhor criar outro projeto Utilities. Em seguida, crie uma pasta \Enumerationse crie um aninhado static class. E, em seguida, atribua cada classe estática onde você criará uma enumeração que corresponde ao nome de seus projetos. Por exemplo, se você tem um projeto chamado DatabaseReader e DatabaseUsers, pode nomear a classe 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

}

A enum inteira que pode ser usada em todas as soluções por projetos será declarada nela. Use # regionpara separar cada preocupação. Por isso, é mais fácil procurar enumerações

Eu gosto de ter um arquivo de enum público chamado E contendo cada enum separado, então qualquer enum pode ser acessado com E ... e eles estão em um local para gerenciar.