O modelo de aplicativo de console do C# gera instruções de nível superior

Do .NET 6 em diante, o modelo de projeto para novos aplicativos de console do C# gera o seguinte código no arquivo Program.cs:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

A nova saída usa recursos recentes do C# que simplificam o código que você precisa escrever para um programa. Para o .NET 5 e versões anteriores, o modelo de aplicativo de console gera o seguinte código:

using System;

namespace MyApp // Note: actual namespace depends on the project name.
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Essas duas formas representam o mesmo programa. Ambos são válidos com C# 10.0. Ao usar a versão mais recente, você só precisa escrever o corpo do método Main. O compilador gera uma classe Program com um método de ponto de entrada e coloca todas as instruções de nível superior nesse método. O nome do método gerado não é Main, é um detalhe de implementação que seu código não pode referenciar diretamente. Você não precisa incluir os outros elementos do programa, o compilador os gera para você. Você pode saber mais sobre o código gerado pelo compilador ao usar instruções de nível superior no artigo sobre Instruções de nível superior, na seção de conceitos básicos do Guia do C#.

Você tem duas opções para trabalhar com tutoriais que não foram atualizados para usar modelos do .NET 6+:

• Use o novo estilo de programa, adicionando novas instruções de nível superior à medida que você adiciona recursos.
• Converta o novo estilo de programa no estilo mais antigo, com uma classe Program e um método Main.

Se você quiser usar os modelos antigos, confira Usar o antigo estilo de programa mais adiante neste artigo.

Usar o novo estilo de programa

Os recursos que tornam o novo programa mais simples são as instruções de nível superior, as diretivas using globais e as diretivas using implícitas.

O termo instruções de nível superior significa que o compilador gera os elementos de classe e método para o programa principal. A classe gerada pelo compilador e o método de ponto de entrada são declarados no namespace global. Você pode examinar o código do novo aplicativo e imaginar que ele contém as instruções dentro do método Main gerado por modelos anteriores, mas no namespace global.

Você pode adicionar mais instruções ao programa, assim como pode adicionar mais instruções ao seu método Main no estilo tradicional. Você pode acessar args (argumentos de linha de comando), usar await e definir o código de saída. Você pode até adicionar funções. Eles são criados como funções locais aninhadas dentro do método de ponto de entrada gerado. As funções locais não podem incluir modificadores de acesso (por exemplo, public ou protected).

As instruções de nível superior e as diretivas using implícitas simplificam o código que compõe seu aplicativo. Para seguir um tutorial existente, adicione as novas instruções ao arquivo Program.cs gerado pelo modelo. Você pode imaginar que as instruções que você escreve estão entre as chaves de abertura e fechamento no método Main nas instruções do tutorial.

Se preferir usar o formato mais antigo, copie o código do segundo exemplo deste artigo e prossiga com o tutorial como antes.

Você pode saber mais sobre as instruções de nível superior explorando o tutorial sobre esse assunto.

Diretivas using implícitas

O termo diretivas using implícitas significa que o compilador adiciona automaticamente um conjunto de diretivas using com base no tipo de projeto. Para aplicativos de console, as seguintes diretivas são incluídas implicitamente no aplicativo:

• using System;
• using System.IO;
• using System.Collections.Generic;
• using System.Linq;
• using System.Net.Http;
• using System.Threading;
• using System.Threading.Tasks;

Outros tipos de aplicativo incluem mais namespaces, que são comuns para esses tipos de aplicativo.

Se precisar de diretivas using não incluídas implicitamente, você poderá adicioná-las ao arquivo .cs que contém instruções de nível superior ou a outros arquivos .cs. Para diretivas using, necessárias em todos os arquivos .cs de um aplicativo, use as diretivas using globais.

Desabilitar diretivas using implícitas

Se você quiser remover esse comportamento e controlar manualmente todos os namespaces em seu projeto, adicione <ImplicitUsings>disable</ImplicitUsings> ao arquivo de projeto no elemento <PropertyGroup>, conforme mostrado no seguinte exemplo:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    ...
    <ImplicitUsings>disable</ImplicitUsings>
  </PropertyGroup>

</Project>

Diretivas using globais

Uma diretiva using global importa um namespace para todo o aplicativo, e não para um só arquivo. Essas diretivas globais podem ser adicionadas incluindo um item <Using> ao arquivo de projeto ou adicionando a diretiva global using a um arquivo de código.

Você também pode adicionar um item <Using> com um atributo Remove ao arquivo de projeto para remover uma diretiva using implícita específica. Por exemplo, se o recurso de diretivas using implícitas estiver ativado com <ImplicitUsings>enable</ImplicitUsings>, adicionar o seguinte item <Using> removerá o namespace System.Net.Http daqueles que tiverem sido importados implicitamente:

<ItemGroup>
  <Using Remove="System.Net.Http" />
</ItemGroup>

Usar o antigo estilo de programa

A partir do SDK do .NET 6.0.300, o modelo console tem uma opção --use-program-main. Use-o para criar um projeto de console que não usa instruções de nível superior e tem um método Main.

dotnet new console --use-program-main

O Program.cs gerado é o seguinte:

namespace MyProject;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
    }
}

Usar o antigo estilo de programa no Visual Studio

1. Ao criar um projeto, as etapas de configuração levam você à página Informações adicionais. Nesta página, marque a caixa de seleção Não usar instruções de nível superior.

   

2. Depois que o projeto é criado, o conteúdo do Program.cs é o seguinte:

   namespace MyProject;
   class Program
   {
       static void Main(string[] args)
       {
           Console.WriteLine("Hello, World!");
       }
   }
   

Observação

O Visual Studio preservará o valor das opções da próxima vez que você criar o projeto com base no mesmo modelo. Portanto, por padrão, ao criar o projeto de Aplicativo de Console da próxima vez, a caixa de seleção "Não usar instruções de nível superior" será marcada. O conteúdo do arquivo Program.cs pode ser diferente para corresponder ao estilo de código definido nas configurações globais do editor de texto do Visual Studio ou no arquivo EditorConfig.

Para obter mais informações, confira Criar configurações do editor portáteis e personalizadas com EditorConfig e Opções, Editor de Texto, C#, Avançado.