Por que você deve remover o C # desnecessário usando diretivas?

Por exemplo, raramente preciso de:

using System.Text;

mas está sempre lá por padrão. Presumo que o aplicativo usará mais memória se o seu código contiver diretivas desnecessárias . Mas há mais alguma coisa que eu deva estar ciente?

Além disso, faz alguma diferença se a mesma diretiva de uso for usada em apenas um arquivo versus a maioria / todos os arquivos?

Edit: Observe que esta pergunta não é sobre o conceito não relacionado chamado de declaração using , projetado para ajudar a gerenciar recursos, garantindo que quando um objeto sai do escopo, seu método IDisposable.Dispose seja chamado. Consulte Usos de "using" em C # .

Não mudará nada quando o seu programa for executado. Tudo o que é necessário é carregado sob demanda. Portanto, mesmo se você tiver essa instrução using, a menos que você realmente use um tipo nesse namespace / assembly, o assembly ao qual a instrução está correlacionada não será carregado.

Principalmente, é apenas para limpar a preferência pessoal.

Não são poucas razões para remover não utilizado usando (s) / namespaces, além de codificação preferência:

• a remoção de cláusulas não utilizadas em um projeto pode acelerar a compilação porque o compilador possui menos espaços de nomes para os tipos de pesquisa a serem resolvidos. (isso é especialmente verdadeiro para o C # 3.0 devido aos métodos de extensão, nos quais o compilador deve procurar todos os espaços de nomes em busca de métodos de extensão para possíveis correspondências melhores, inferência de tipo genérico e expressões lambda envolvendo tipos genéricos)
• pode ajudar a evitar a colisão de nomes em futuras compilações quando novos tipos são adicionados aos espaços para nome não utilizados que têm o mesmo nome que alguns tipos nos espaços para nome usados.
• reduzirá o número de itens na lista de preenchimento automático do editor durante a codificação, levando possivelmente a uma digitação mais rápida (no C # 3.0, isso também pode reduzir a lista de métodos de extensão mostrados)

O que remover os namespaces não utilizados não fará:

• alterar de qualquer forma a saída do compilador.
• alterar de qualquer forma a execução do programa compilado (carregamento mais rápido ou melhor desempenho).

O conjunto resultante é o mesmo com ou sem os usos não utilizados removidos.

A limpeza do código é importante.

Começamos a ter a sensação de que o código pode não ser mantido e no caminho da browfield quando vemos usos supérfluos. Em essência, quando vejo algumas declarações de uso não utilizadas, uma pequena bandeira amarela aparece no fundo do meu cérebro, dizendo-me para "prosseguir com cautela". E a leitura do código de produção nunca deve lhe dar essa sensação.

Então limpe seus usos. Não seja desleixado. Inspire confiança. Deixe seu código bonito. Dê a outro desenvolvedor aquela sensação de aconchegante.

Não há nenhuma construção de IL que corresponda using. Portanto, as usinginstruções não aumentam a memória do aplicativo, pois não há código ou dados gerados para ele.

Usingé usado no momento da compilação apenas para fins de resolução de nomes curtos de tipos para nomes de tipos completos. Assim, o único efeito negativo desnecessário que usingpode ter é diminuir o tempo de compilação e consumir um pouco mais de memória durante a compilação. Eu não ficaria preocupado com isso.

Portanto, o único efeito negativo real de ter usinginstruções que você não precisa é no intellisense, pois a lista de possíveis correspondências para conclusão enquanto você digita aumenta.

Você pode ter conflitos de nome se chamar suas classes como as classes (não usadas) no espaço para nome. No caso do System.Text, você terá um problema se definir uma classe chamada "Encoder".

De qualquer forma, isso geralmente é um problema menor e detectado pelo compilador.

Seu aplicativo não usará mais memória. É para o compilador encontrar classes que você usa nos arquivos de código. Realmente não dói além de não estar limpo.

É preferência pessoal principalmente. Eu também os limpo (o Resharper faz um bom trabalho em me dizer quando há necessidade de usar declarações).

Pode-se dizer que isso pode diminuir o tempo de compilação, mas com a velocidade do computador e do compilador atualmente, isso não causaria nenhum impacto perceptível.

Deixar usingdiretivas extras é bom. Há pouco valor em removê-los, mas não muito. Por exemplo, torna minhas listas de conclusão do IntelliSense mais curtas e, portanto, mais fáceis de navegar.

Os assemblies compilados não são afetados por usingdiretivas externas .

Às vezes, coloco-os dentro de um #regione deixo-o em colapso; isso torna a visualização do arquivo um pouco mais limpa. OMI, este é um dos poucos bons usos de #region.

se você deseja manter seu código limpo, as usinginstruções não usadas devem ser removidas do arquivo. os benefícios aparecem muito claros quando você trabalha em uma equipe colaborativa que precisa entender seu código, acha que todo o seu código deve ser mantido, menos código = menos trabalho, os benefícios são de longo prazo.

Eles são usados ​​apenas como um atalho. Por exemplo, você teria que escrever: System.Int32 toda vez que você não tivesse um System usando; em cima.

Remover os não utilizados apenas faz com que seu código pareça mais limpo.

A instrução using apenas impede que você qualifique os tipos que você usa. Eu pessoalmente gosto de limpá-los. Realmente depende de como uma métrica loc é usada

Ter apenas os espaços para nome que você realmente usa permite manter seu código documentado.

Você pode encontrar facilmente quais partes do seu código estão se chamando por qualquer ferramenta de pesquisa.

Se você tiver namespaces não utilizados, isso não significa nada ao executar uma pesquisa.

Estou trabalhando na limpeza de espaços para nome agora, porque constantemente me perguntam quais partes do aplicativo estão acessando os mesmos dados de uma maneira ou de outra.

Eu sei quais partes estão acessando dados de qualquer maneira devido ao acesso a dados ser separado por namespaces, por exemplo, diretamente através de um banco de dados e diretamente através de um serviço da web.

Não consigo pensar em uma maneira mais simples de fazer isso de uma só vez.

Se você apenas deseja que seu código seja uma caixa preta (para os desenvolvedores), sim, não importa. Mas se você precisar mantê-lo ao longo do tempo, é uma documentação valiosa como todos os outros códigos.

A instrução 'using' não afeta o desempenho, pois é apenas um auxiliar na qualificação dos nomes dos seus identificadores. Portanto, em vez de precisar digitar System.IO.Path.Combine (...) , você pode simplesmente digitar Path.Combine (...) se estiver usando o System.IO .

Não esqueça que o compilador trabalha muito para otimizar tudo ao criar seu projeto. Usar isso é usado em muitos lugares ou 1 não deve ser diferente uma vez compilado.