Criando trechos de código em C# - Personalize o Visual Studio para maior eficiência

Por que os trechos de código são importantes

Tim começa compartilhando como ele usa frequentemente snippets para inserir elementos como propriedades automáticas, construtores e loops foreach. Ele demonstra como digitar "cw" e pressionar Tab duas vezes insere "Console.WriteLine()", colocando o cursor entre parênteses — um truque essencial para a saída de conteúdo de string.

Mas, como ele destaca, nem todo método útil possui um trecho de código integrado. Por exemplo, Console.ReadLine() não possui um. Qual foi a resposta de Tim? Crie o seu próprio.

Configurando um projeto de demonstração no Visual Studio

Para demonstrar em contexto, Tim configura um aplicativo web ASP.NET Core no Visual Studio. Embora o tipo de projeto não seja crucial, ter arquivos C# e HTML para trabalhar permite que ele mostre exemplos de ambas as linguagens.

Este é um lembrete importante: os snippets não se limitam ao C# — eles podem ser aplicados a várias linguagens suportadas pelo Visual Studio, incluindo HTML, XAML e muito mais.

Snippets integrados e o poder dos atalhos

Tim demonstra alguns trechos de código já existentes:

• cw + Tab Tab → Console.WriteLine()

• ctor + Tab Tab → Construtor

• prop + Tab Tab → Propriedade autoimplementada (ex: public string Test { get; definir; })

• propfull → Cria uma propriedade com um campo de suporte

Esses atalhos foram criados para eliminar repetições e aumentar o desempenho. Basta especificar um tipo, como string ou int, um nome, e deixar que o resto seja gerado automaticamente.

Esses trechos de código integrados também podem demonstrar interpolação, modificadores de acesso como public e elementos definidos pelo sistema, garantindo que seu código siga uma estrutura consistente.

Criando seu próprio snippet no VS Code

Em vez de usar uma ferramenta geradora de trechos de código, Tim opta pelo Visual Studio Code devido à sua simplicidade e ao realce de sintaxe XML.

Ele cria um arquivo chamado readline.snippet e mostra a estrutura XML essencial:

<CodeSnippets>
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Console.ReadLine</Title>
      <Shortcut>cr</Shortcut>
      <Description>Creates Console.ReadLine()</Description>
      <Author>Tim Corey</Author>
    </Header>
    <Snippet>
      <Code Language="csharp"><!-- [CDATA[
Console.ReadLine();
]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

<CodeSnippets>
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Console.ReadLine</Title>
      <Shortcut>cr</Shortcut>
      <Description>Creates Console.ReadLine()</Description>
      <Author>Tim Corey</Author>
    </Header>
    <Snippet>
      <Code Language="csharp"><!-- [CDATA[
Console.ReadLine();
]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Este é um trecho básico, usando<!-- [CDATA[]]> para encapsular o código C# bruto. O atalho cr agora aciona a inserção do método Console.ReadLine() com duas teclas Tab pressionadas.

Tim destaca que a formatação é herdada do ambiente Visual Studio do usuário, o que significa que o recuo e o espaçamento corresponderão às suas configurações.

Importando trechos de código para o Visual Studio

Tim demonstra como importar um arquivo .snippet usando Ferramentas > Gerenciador de Snippets de Código. Ele seleciona a localização de "Meus Snippets de Código", garantindo que o snippet apareça quando necessário.

Após a importação, digitar cr + Tab insere a linha Console.ReadLine(), pronta para atribuir seu valor a uma variável ou usá-la dentro de um bloco de tratamento de exceções.

Cabeçalhos de documentação reutilizáveis

Em seguida, Tim demonstra um trecho de documentação — uma necessidade frequente em projetos empresariais ou equipes colaborativas. Ele cria um trecho de código com o atalho docme que gera um bloco de comentários:

/// Title:
/// Author:
/// Date:
/// Purpose:

/// Title:
/// Author:
/// Date:
/// Purpose:

Isso é ideal para rastrear alterações, autoria e contexto do arquivo. Embora ferramentas como o Git lidem com o versionamento, os cabeçalhos oferecem referências visuais rápidas, especialmente em equipes grandes.

Trechos de HTML: Exemplo de formulário Bootstrap

Os snippets não servem apenas para código C#. Tim mostra como usá-los em HTML — perfeitos para criar formulários, elementos de entrada e coleções de tags estruturadas.

Ele copia um exemplo de formulário Bootstrap e o envolve no mesmo formato de trecho XML, alterando a linguagem para HTML. Após a importação, digitar o atalho sampleform insere uma estrutura HTML pronta, evitando que você precise referenciar URLs externas repetidamente ou copiar código padrão.

Snippet avançado com marcadores de posição e variáveis

É aqui que as coisas ficam mais avançadas — e mais poderosas. Tim cria um trecho de código que recupera um valor de configuração:

_config.GetValue<string>("values:myTest");

_config.GetValue<string>("values:myTest");

Ele mostra como usar marcadores de posição tanto para o tipo (string, int, bool) quanto para o caminho (values:myTest), para que o desenvolvedor precise preencher apenas o que for diferente.

No XML, ele usa:

<Declarations>
  <Literal>
    <id>ValType</id>
    <Default>string</Default>
    <ToolTip>Data type of the value</ToolTip>
  </Literal>
  <Literal>
    <id>Path</id>
    <Default>values:myTest</Default>
    <ToolTip>Config path</ToolTip>
  </Literal>
</Declarations>

<Declarations>
  <Literal>
    <id>ValType</id>
    <Default>string</Default>
    <ToolTip>Data type of the value</ToolTip>
  </Literal>
  <Literal>
    <id>Path</id>
    <Default>values:myTest</Default>
    <ToolTip>Config path</ToolTip>
  </Literal>
</Declarations>

No corpo do trecho:

_config.GetValue<$ValType$>("$Path$")

_config.GetValue<$ValType$>("$Path$")

Essa utilização de variáveis ​​e declarações permite a geração de código flexível, expressivo e conciso. É ideal para tarefas como recuperação de configurações de segurança, acesso a dicionários ou leitura de valores aninhados em arquivos JSON.

Por que os snippets melhoram o desempenho?

Tim conclui explicando como os snippets não se resumem apenas à velocidade — eles promovem práticas consistentes, reduzem erros e melhoram a legibilidade do código em toda a equipe. Com o tempo, mesmo economizar alguns segundos por trecho de código pode resultar em horas economizadas.

Ele enfatiza que os trechos ajudam com:

• Inicialização de tarefas comuns

• Tratamento de exceções padronizado com try-catch-finally

• Criação de modelos de turmas inteiras

• Trabalhando com blocos finally, blocos catch estruturados e sobrescrita de métodos.

Considerações finais: A vantagem do desenvolvedor

Seja para criar sistemas complexos ou aplicativos simples, os trechos de código podem ajudá-lo a escrever código C ou C# de forma mais rápida e consistente. Elas permitem que você:

• Eliminar repetições

• Foco na lógica de negócios

• Manter uma base de código limpa, interpolada e bem documentada

Como Tim sugere em seu vídeo abrangente, explore seus próprios hábitos de programação. Descubra onde você digita as mesmas coisas repetidamente. Em seguida, escolha uma abordagem: crie um trecho de código.

Em breve você perceberá que transformou seu fluxo de trabalho, tornando o desenvolvimento mais eficiente, organizado e agradável.

Ideias rápidas de trechos para começar

• tryfinally – Gera blocos try + finally

• logerror – Insira a lógica de registro com Log.Error()

• propnotify – Propriedade com INotifyPropertyChanged

• filecheck – Verificação de arquivo – Se File.Exists(caminho) com lógica embutida

• foreachdict – Percorrer um dicionário<TKey, TValue>

Dica do Tim: Não copie e cole de outro arquivo sem antes criar um trecho de código e nunca mais digitar tudo novamente.