Como funcionam namespaces e diretivas using?

Question

Accepted Answer

**Namespaces** organizam código em grupos lógicos e previnem colisões de nomes (como pastas para tipos). **Diretivas `using`** importam namespaces para que você possa se referir aos seus tipos por nome curto. Juntas, elas estruturam código C# e acessam a vasta biblioteca .NET. ## Declarando namespaces ```csharp // declare a namespace (conventionally matching the folder structure) namespace MyApp.Services; // file-scoped namespace (C# 10) — applies to the whole file public class UserService { } // fully-qualified name: MyApp.Services.UserService // or block-scoped (traditional) namespace MyApp.Models { public class User { } } ``` Um namespace agrupa tipos relacionados sob um nome (`MyApp.Services.UserService`), prevenindo colisões entre classes com o mesmo nome em namespaces diferentes. Namespaces com escopo de arquivo (C# 10) reduzem o aninhamento. ## Diretivas using — importar namespaces ```csharp using System; // import → use Console instead of System.Console using System.Collections.Generic; // → List, Dictionary using System.Linq; // → LINQ extension methods using MyApp.Services; // your own namespaces Console.WriteLine("hi"); // short name works thanks to `using System;` var list = new List(); // thanks to the Generic using ``` `using` no topo de um arquivo importa um namespace para que seus tipos estejam disponíveis por nome curto (em vez do nome totalmente qualificado). Você importa as bibliotecas .NET que precisa desta forma. ## Aliases using e global usings ```csharp using Project = MyApp.Models.Project; // ALIAS — resolve a name conflict or shorten // GLOBAL using (C# 10) — apply to the ENTIRE project, declared once global using System; global using System.Collections.Generic; // → no need to repeat common usings in every file (often auto-generated) ``` **Global usings** (C# 10) declaram importações uma vez para todo o projeto — .NET moderno inclui automaticamente as comuns (`ImplicitUsings`), então você raramente escreve `using System;` mais. ## Nota: diretiva using vs declaração using ```csharp using var file = File.OpenText("x.txt"); // using STATEMENT — auto-disposes (different feature!) ``` ## Por que isso importa Namespaces e diretivas using são fundamentais para organizar código C# e acessar o ecossistema .NET, então entendê-los é conhecimento essencial do dia a dia. **Namespaces** organizam tipos em grupos lógicos (espelhando a estrutura de pastas) e previnem **colisões de nomes** — sem eles, suas classes conflitariam umas com as outras e com a vasta biblioteca .NET e pacotes de terceiros. **Diretivas `using`** são como você acessa essa biblioteca: importando namespaces para que possa usar seus tipos (`Console`, `List`, métodos LINQ) por nome curto em vez de nomes totalmente qualificados — cada arquivo C# depende de usings para acessar a funcionalidade do framework. Saber como declarar namespaces (incluindo a sintaxe moderna com escopo de arquivo), importar com usings, usar aliases para resolver conflitos e aproveitar **global usings** (C# 10, declarando importações comuns uma vez para todo o projeto — agora frequentemente gerado automaticamente via ImplicitUsings, então você raramente escreve usings padronizados) é necessário para estruturar projetos e usar o framework. Entender namespaces e usings — organização de código, prevenção de colisões, acesso à biblioteca .NET, e os global/implicit usings modernos que reduzem boilerplate — é fundamental para qualquer desenvolvimento em C#, já que todo programa organiza código em namespaces e acessa funcionalidade através de usings. (Vale a pena distinguir da *declaração* `using`, um recurso diferente para limpeza automática de recursos.)