Executando verificação de segurança...
1
Centaurus
9 min de leitura ·

Guia Prático de Nomenclatura para Visual Basic .NET (cap 2)

Com foco no Visual Studio


  1. Princípios Gerais e Diretrizes de Nomenclatura
  2. Configurar o Visual Studio
  3. Dicas de Ouro
  4. Recomendações Além do .editorconfig
  5. Mais Conteúdos Relacionados



2. Configurar o Visual Studio

Configurar o Visual Studio para forçar esses padrões automaticamente é a melhor forma de garantir que seu código VB.NET esteja sempre profissional.
O segredo é um arquivo chamado .editorconfig.


2.1 Passo à Passo para Configuração

Passo 1: Criar o arquivo EditorConfig

O Visual Studio 2022 possui um assistente que facilita muito esse processo.

  1. Abra seu projeto ou solução no Visual Studio.
  2. No Gerenciador de Soluções (geralmente à direita), clique com o botão direito no nome da sua Solução (o item no topo da lista).
  3. Vá em Adicionar > Novo Item.
  4. Na barra de busca, digite editorconfig.
  5. Selecione Arquivo EditorConfig (padrão) e clique em Adicionar. Um arquivo chamado .editorconfig aparecerá no seu projeto.

Passo 2: Configurar as Regras de Nomenclatura

O Visual Studio abrirá uma interface visual (não apenas um arquivo de texto) para você configurar as regras.

  1. Com o arquivo .editorconfig aberto, clique na aba Estilo de Código na parte superior da janela de edição.
  2. Role até encontrar a seção Nomenclatura.
  3. Aqui você pode definir regras específicas para cada tipo de elemento:
    1. Classes, Métodos, Propriedades: Selecione o estilo PascalCase.
    2. Parâmetros e Variáveis Locais: Selecione o estilo camelCase.
    3. Campos Privados (Private): Crie ou edite uma regra para que comecem com _ (underscore) seguido de camelCase.

Passo 3: Definir a Severidade (O "Puxão de Orelha")

Ao lado de cada regra, você pode escolher o que o Visual Studio fará se você desrespeitar o padrão:

  • Sugestão: Apenas mostra três pontinhos cinzas sob o nome.
  • Aviso (Warning): Mostra um sublinhado verde e um alerta na "Lista de Erros". (Recomendado para iniciantes).
  • Erro: O código não compila até você corrigir o nome.

Passo 4: Aplicar Correções Automaticamente

Agora que as regras existem, você não precisa renomear tudo manualmente:

  1. Se você escrever Dim valortotal as Integer (tudo minúsculo), o Visual Studio mostrará um ícone de Lâmpada Amarela (ou pressione Ctrl + .).
  2. Ele sugerirá: "Corrigir violação de nomenclatura: ValorTotal".
  3. Basta dar Enter e ele corrige para você.

Passo 5: Formatação Automática ao Salvar

Para que o Visual Studio também ajuste espaços e indentações sozinho:

  1. Vá no menu Ferramentas > Opções.
  2. Procure por Editor de Texto > Code Cleanup (Limpeza de Código).
  3. Marque a opção "Executar perfil de Limpeza de Código ao salvar". Isso garantirá que, toda vez que você der um Ctrl + S, o Visual Studio organize a casa para você.


2.2 Modelo de .editorconfig para VB.NET

Aqui está um modelo de texto otimizado especificamente para VB.NET.
Este arquivo já inclui as regras de PascalCase para classes/métodos, camelCase para variáveis e o prefixo de underscore para campos privados.

Como usar

  1. Crie um novo arquivo de texto chamado .editorconfig (certifique-se de que não termine em .txt).
  2. Cole o conteúdo abaixo e salve na pasta da sua Solução, ou em uma pasta "mãe" (como C:\MeusProjetos\).
# =====================================================
# .editorconfig — Padrões de Nomenclatura VB.NET
#
# Objetivo:
#   - Garantir consistência semântica
#   - Refletir escopos do mais abrangente ao menos abrangente
#   - Tornar o código legível, previsível e auditável
#
# Base:
#   - .NET Design Guidelines (Microsoft)
#   - Ajustes conforme preferências pessoais
# =====================================================

root = true

# =====================================================
# Configurações globais (todas as linguagens)
# =====================================================
[*]
charset = utf-8
indent_style = space
indent_size = 4
insert_final_newline = true
trim_trailing_whitespace = true

# =====================================================
# Regras específicas para Visual Basic .NET
# =====================================================
[*.vb]

# =====================================================
# 1. Namespaces: PascalCase
#   - Namespace é o contêiner mais externo do código
#   - Deve ser claro, previsível e alinhado à estrutura de pastas
# =====================================================
dotnet_naming_rule.namespace_rule.symbols = namespace_group
dotnet_naming_rule.namespace_rule.style = pascal_case_style
dotnet_naming_rule.namespace_rule.severity = warning

dotnet_naming_symbols.namespace_group.applicable_kinds = namespace

# =====================================================
# 2. Tipos (Classes, Structs, Delegates, Enums, Interfaces): PascalCase
#   - Tipos definem a estrutura do domínio
#   - Delegates são tipos de primeira classe no .NET
# =====================================================
dotnet_naming_rule.types_rule.symbols = types_group
dotnet_naming_rule.types_rule.style = pascal_case_style
dotnet_naming_rule.types_rule.severity = warning

dotnet_naming_symbols.types_group.applicable_kinds = class, struct, delegate, interface, enum

# =====================================================
# 3. Campos não-privados (e não constantes): PascalCase
#   - Representam estado exposto fora do tipo
#   - Incluem: Public, Protected, Friend e Protected Friend
# =====================================================
dotnet_naming_rule.public_fields_rule.symbols = public_fields_group
dotnet_naming_rule.public_fields_rule.style = pascal_case_style
dotnet_naming_rule.public_fields_rule.severity = warning

dotnet_naming_symbols.public_fields_group.applicable_kinds = field
dotnet_naming_symbols.public_fields_group.applicable_accessibilities = public
dotnet_naming_symbols.public_fields_group.required_modifiers = !const

dotnet_naming_rule.non_private_fields_rule.symbols = non_private_fields_group
dotnet_naming_rule.non_private_fields_rule.style = pascal_case_style
dotnet_naming_rule.non_private_fields_rule.severity = warning

dotnet_naming_symbols.non_private_fields_group.applicable_kinds = field
dotnet_naming_symbols.non_private_fields_group.applicable_accessibilities = protected, friend, protected_friend
dotnet_naming_symbols.non_private_fields_group.required_modifiers = !const

# =====================================================
# 4. Membros (Métodos, Propriedades, Eventos): PascalCase
#   - Aplicável a TODAS as acessibilidades (public, private, protected, etc.)
#   - Representam comportamento e estado exposto do tipo
# =====================================================
dotnet_naming_rule.members_rule.symbols = members_group
dotnet_naming_rule.members_rule.style = pascal_case_style
dotnet_naming_rule.members_rule.severity = warning

dotnet_naming_symbols.members_group.applicable_kinds = method, property, event

# =====================================================
# 5. Constantes (Const): SCREAMING_SNAKE_CASE
#   - Conforme preferências pessoais, excessão às diretrizes .NET
#   - Facilita distinção visual imediata
#   - Familiar para programadores que trabalham com várias linguagens
# =====================================================
dotnet_naming_rule.constants_rule.symbols = constants_group
dotnet_naming_rule.constants_rule.style = screaming_snake_case_style
dotnet_naming_rule.constants_rule.severity = warning

dotnet_naming_symbols.constants_group.applicable_kinds = field
dotnet_naming_symbols.constants_group.required_modifiers = const

# =====================================================
# 6. Campos privados: _camelCase
#   - Convenção de equipe, não é regra da linguagem
#   - Representam estado interno do tipo
#   - Underscore evita colisão em linguagem case-insensitive
# =====================================================
dotnet_naming_rule.private_fields_rule.symbols = private_fields_group
dotnet_naming_rule.private_fields_rule.style = private_field_style
dotnet_naming_rule.private_fields_rule.severity = warning

dotnet_naming_symbols.private_fields_group.applicable_kinds = field
dotnet_naming_symbols.private_fields_group.applicable_accessibilities = private
dotnet_naming_symbols.private_fields_group.required_modifiers = !const

# =====================================================
# 7. Parâmetros e variáveis locais: camelCase
#   - Elementos de suporte
#   - Escopo restrito ao método
#   - Natureza passiva (dados)
# =====================================================
dotnet_naming_rule.locals_rule.symbols = locals_group
dotnet_naming_rule.locals_rule.style = camel_case_style
dotnet_naming_rule.locals_rule.severity = warning

dotnet_naming_symbols.locals_group.applicable_kinds = parameter, local

# =====================================================
# 8. Funções locais (Local Functions): PascalCase
#   - Comportamento encapsulado em escopo mínimo
#   - Mini-métodos sem exposição externa
# =====================================================
dotnet_naming_rule.local_functions_rule.symbols = local_functions_group
dotnet_naming_rule.local_functions_rule.style = pascal_case_style
dotnet_naming_rule.local_functions_rule.severity = warning

dotnet_naming_symbols.local_functions_group.applicable_kinds = local_function

# =====================================================
# DEFINIÇÃO DOS ESTILOS
# =====================================================

# PascalCase
dotnet_naming_style.pascal_case_style.capitalization = pascal_case

# camelCase
dotnet_naming_style.camel_case_style.capitalization = camel_case

# _camelCase para campos privados
dotnet_naming_style.private_field_style.capitalization = camel_case
dotnet_naming_style.private_field_style.required_prefix = _

# Estilo SCREAMING_SNAKE_CASE
dotnet_naming_style.screaming_snake_case_style.capitalization = all_upper
dotnet_naming_style.screaming_snake_case_style.word_separator = _

Padrão Global

Se você quiser que todos os seus códigos sigam esse padrão, independentemente do projeto (ou solução):

  • Coloque o .editorconfig em uma pasta "mãe" (como C:\MeusProjetos\).
  • O Visual Studio busca o arquivo na pasta atual e vai subindo nos diretórios até encontrar um. Se ele encontrar um arquivo com a linha root = true, ele para a busca ali e aplica aquelas definições.

Dica: Como "Bloquear" o Padrão

No topo do seu arquivo .editorconfig, você verá o comando root = true.
Isso indica ao Visual Studio que ele deve parar de procurar outros arquivos de configuração em pastas superiores e usar estritamente as regras deste arquivo.
Isso garante que sua equipe (ou você no futuro) use sempre o mesmo padrão.

O que acontece agora?

Assim que você salvar este arquivo, o Visual Studio passará a monitorar seu código.
Se você escrever algo fora do padrão, como Dim nome as String, ele sublinhará o erro e, ao clicar na Lâmpada Amarela (ou Ctrl+.), oferecerá a correção automática baseada na Documentação de Estilo de Código da Microsoft.


2.3 Organização Multilinguagem

O arquivo .editorconfig é inteligente e permite especificar quais regras se aplicam a quais linguagens através dos cabeçalhos de seção.

No modelo, note a linha: [*.vb]
Isso já informa ao Visual Studio que as regras abaixo daquela linha são exclusivas para arquivos do Visual Basic.

Como o comportamento funciona na prática

  1. Se você abrir um arquivo C# (.cs): O Visual Studio ignorará as regras que estão dentro do bloco [*.vb]. Ele usará as regras globais (como o indent_size = 4) ou procurará por uma seção [*.cs].
  2. Se você abrir um arquivo VB (.vb): Ele aplicará tanto as regras globais quanto as específicas do VB.
  3. Conflitos: Se houver uma regra geral e uma específica, a específica vence. Por exemplo, se você definir que arquivos em geral usam 2 espaços, mas em [*.vb] definir 4, o VB usará 4.

Exemplo de organização multilinguagem:

Se você trabalha com várias linguagens na mesma solução, o seu arquivo ficaria organizado assim:

# Configurações globais (todas as linguagens)
[*]
indent_style = space

# Configurações EXCLUSIVAS para VB.NET
[*.vb]
dotnet_naming_rule.types_rule.style = pascal_case_style
# (outras regras que te passei...)

# Configurações EXCLUSIVAS para C#
[*.cs]
csharp_prefer_braces = true
# (regras específicas de C#...)

Para garantir que o Visual Studio sempre siga o padrão correto, você pode gerenciar essas configurações através das Opções de Estilo de Código no Visual Studio.


2.4 Portabilidade do .editorconfig entre IDEs

Embora este capítulo foque na configuração do Visual Studio, o arquivo .editorconfig não é exclusivo dessa IDE.

O .editorconfig é um padrão amplamente adotado e pode ser utilizado por diversas IDEs e editores de código.
Entretanto, é importante compreender que existem níveis diferentes de suporte, dependendo do tipo de regra definida.

Regras portáveis (EditorConfig Core)

As configurações básicas de formatação são suportadas pela maioria das ferramentas modernas, incluindo:

  • Indentação (indent_style, indent_size)
  • Final de linha (end_of_line)
  • Charset (charset)
  • Espaços em branco (trim_trailing_whitespace)
  • Nova linha final (insert_final_newline)

Essas regras funcionam de forma consistente em praticamente todas as IDEs e editores populares.

Regras específicas do ecossistema .NET

As regras mais avançadas usadas neste guia — como:

  • dotnet_naming_rule.*
  • dotnet_naming_symbols.*
  • dotnet_naming_style.*
  • dotnet_style_*
  • dotnet_diagnostic.*

não fazem parte do padrão EditorConfig original.
Elas são extensões implementadas pelo compilador Roslyn e pelo SDK do .NET.

Por isso, essas regras são plenamente interpretadas apenas por IDEs que utilizam o ecossistema .NET para análise de código, como:

  • Visual Studio: suporte nativo, habilitado automaticamente
  • Visual Studio Code: requer a extensão C# e configuração manual no settings.json: 
    {
  "omnisharp.enableEditorConfigSupport": true,
  "omnisharp.enableRoslynAnalyzers": true
}
    (Sem essas configurações, apenas as regras básicas do EditorConfig funcionarão)
  • JetBrains Rider: suporte nativo, habilitado automaticamente

Outros editores podem ler o .editorconfig, mas aplicarão apenas as regras básicas de formatação.


2.5 Conclusão

Ao configurar corretamente o .editorconfig, você estabelece um contrato técnico de estilo que:

  • Garante consistência no Visual Studio
  • Mantém compatibilidade com outras IDEs
  • Escala bem em times, repositórios e ambientes heterogêneos

O Visual Studio é apenas o ponto de partida — o padrão definido é maior do que a ferramenta.


🔝 (Voltar para o Início)

Carregando publicação patrocinada...