O modelo de aplicativo de console 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 sintetiza uma classe Program com um método Main e coloca todas as instruções de nível superior nesse método Main. 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 e o método Main gerados pelo compilador 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. Elas são criadas como funções locais aninhadas dentro do método Main 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 tem uma --use-program-main opçãoconsole. Use-o para criar um projeto de console que não usa instruções de nível superior e tem um Main método .

dotnet new console --use-program-main

O gerado Program.cs é 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 .

    Caixa de seleção Instruções de nível superior não usam o Visual Studio

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

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

Observação

O Visual Studio preserva o valor das opções na 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 na próxima vez, a caixa de seleção "Não usar instruções de nível superior" será marcada. O conteúdo do Program.cs arquivo pode ser diferente para corresponder ao estilo de código definido nas configurações globais do editor de texto do Visual Studio ou no EditorConfig arquivo.

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

Comentários sobre modelos

Instruções de nível superior foram introduzidas no .NET 6. Adicione um voto a favor ou contra no Problema do GitHub nº 27420 para nos informar se você apoia o uso desse recurso nos modelos de projeto.