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

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

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

Para versões .NET 5 e anteriores, o modelo de aplicativo de console gera o seguinte código:

using System;

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

No código anterior, o namespace real depende do nome do projeto.

Esses dois formulários representam o mesmo programa. Ambos são válidos em C#. Ao usar a versão mais recente, você só precisa escrever o corpo do método Main. O compilador gera uma Program classe 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ê. Para obter mais informações sobre o código que o compilador gera quando você usa instruções de nível superior, consulte instruções de nível superior na seção de conceitos básicos do Guia do C#.

Ao trabalhar com tutoriais que não foram atualizados para usar modelos do .NET 6+, use uma destas duas opções:

• 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 Program classe e um Main método.

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

Usar o novo estilo de programa

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

O termo instruções de nível superior significa que o compilador gera os elementos de classe e método para seu programa principal. O compilador declara a classe gerada e o método de ponto de entrada no namespace global. Examine o código do novo aplicativo e imagine que ele contém as instruções dentro do Main método gerado por modelos anteriores, mas no namespace global.

Adicione mais instruções ao programa, assim como você adiciona instruções ao seu Main método no estilo tradicional. Acesse args (argumentos de linha de comando),use awaite defina o código de saída. Você pode até mesmo adicionar funções. O compilador os cria 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 implícitas using simplificam o código que compõe seu aplicativo. Para seguir um tutorial existente, adicione novas instruções ao arquivo Program.cs gerado pelo modelo. Imagine que as declarações que você escreve estão entre as chaves de abertura e fechamento do método Main nas instruções do tutorial.

Se preferir o formato mais antigo, copie o código do segundo exemplo neste artigo e continue o tutorial como antes.

Para obter mais informações sobre instruções de nível superior, consulte a exploração do tutorial em instruções de nível superior.

Diretivas implícitas using

O termo diretivas implícitas using significa que o compilador adiciona automaticamente um conjunto de using diretivas 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 comuns para esses tipos de aplicativo.

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

Desativar diretivas implícitas using

Para remover esse comportamento e controlar manualmente todos os namespaces em seu projeto, adicione <ImplicitUsings>disable</ImplicitUsings> ao arquivo de projeto no <PropertyGroup> elemento, conforme mostrado no exemplo a seguir:

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

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

</Project>

Diretivas using globais

Uma diretiva global using importa um namespace para todo o aplicativo em vez de um único arquivo. Adicione essas diretivas globais incluindo um <Using> item no arquivo de projeto ou adicionando a global using diretiva a um arquivo de código.

Para remover uma diretiva implícita using específica, adicione um <Using> item com um atributo Remove ao arquivo de projeto. Por exemplo, se o recurso de diretivas implícitas using estiver ativado <ImplicitUsings>enable</ImplicitUsings>, adicionar o seguinte item <Using> removerá o namespace System.Net.Http daqueles que são importados implicitamente:

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

Usar o estilo de programa antigo

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

dotnet new console --use-program-main

O valor gerado Program.cs é o seguinte:

namespace MyProject;

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

Usar o estilo de programa antigo em Visual Studio

1. Quando você cria um novo projeto, as etapas de configuração redirecionam você para a página de configuração de 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 é o seguinte: Program.cs

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