Vamos mergulhar em um projeto C#

1. Estrutura geral de um projeto C#

Seu programa não é só um arquivo, mas sim um conjunto de arquivos, pastas e configs. C# é uma linguagem fortemente tipada, então pra apps grandes é importante manter tudo bem organizado. Se você ignorar a estrutura do projeto, seu código rapidinho vira um labirinto digital onde nem você acha aquela linha de saída "Hello, World!".

Além disso, entender a estrutura do projeto é uma daquelas skills que a galera valoriza na entrevista. Tipo saber onde ficam as chaves e o controle da TV em casa — a vida fica bem mais fácil!

Pra ficar mais claro, imagina que nosso projeto C# é uma caixa cheia de compartimentos:

MyFirstConsoleApp/
├── MyFirstConsoleApp.csproj
├── Program.cs
├── Properties/
│    └── launchSettings.json
├── bin/
│    └── ... (aqui vai o programa compilado)
├── obj/
│    └── ... (aqui ficam os arquivos intermediários da compilação)

Detalhes da estrutura:

MyFirstConsoleApp.csproj

Program.cs

Properties/

bin/

obj/

2. Arquivo do projeto (.csproj)

O arquivo com extensão .csproj é o coração e o cérebro do projeto. É aqui que ficam todas as configs globais: versão da linguagem, dependências, quais arquivos compilar, quais pacotes estão conectados e por aí vai. Troca pra aba Solution Explorer e clica em Files.

Exemplo de arquivo pra um app de console:

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

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

</Project>

• <TargetFramework>net9.0</TargetFramework> — diz que o projeto é pra .NET 9.
• <OutputType>Exe</OutputType> — significa que vai sair um executável (.exe no Windows).
• No bloco <PropertyGroup> ficam os parâmetros principais.
• Nesse arquivo você pode adicionar pacotes NuGet, mudar configs de compilação, ligar/desligar features.

3. Arquivo principal do programa: Program.cs

Se o projeto fosse um teatro, o Program.cs seria o palco, e o resto dos arquivos, o backstage. É aqui que fica o tal "ponto de entrada" do app — o método Main.

// Program.cs
using System;

namespace MyFirstConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Oi, mundo!");
        }
    }
}

• namespace — espaço de nomes, ajuda a agrupar classes e evitar conflito de nomes.
• class Program — classe principal, onde fica o método Main.
• static void Main(string[] args) — ponto de entrada obrigatório — é daqui que o programa começa a rodar.
• Console.WriteLine() — aquele jeito já conhecido de contar pro mundo o que você tá pensando.

Atualizando nosso app

Lembra que nas aulas passadas a gente já fez um mini-app que perguntava o nome do usuário e dava um oi? Olha só:

// Program.cs
using System;

namespace MyFirstConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Por favor, digite seu nome: ");
            string name = Console.ReadLine();
            Console.WriteLine($"Bem-vindo, {name}! Vida longa e próspera.");
        }
    }
}

Rode o projeto: clica no botão verde ▶️ Run.

Se tudo der certo, vai aparecer a aba Run lá embaixo. Você vai ver que o programa rodou e tá esperando sua resposta pra Por favor, digite seu nome:. Digita qualquer nome (tipo "Gato") direto nesse console e aperta Enter.

Assim que você apertar Enter, o programa vai processar o que você digitou e mostrar a mensagem final com seu nome. O programa terminou, e você vê o resultado.

4. Como escrever seu código: regras básicas

Onde escrever o código?

No começo, é melhor escrever a lógica principal no arquivo Program.cs dentro do método Main. Conforme o app cresce, você vai criar novos arquivos e classes, mas por enquanto, fica tranquilo — o mais legal acontece aqui mesmo.

O que pode (e o que não pode) fazer no Main?

• Pode: declarar variáveis, fazer contas, chamar métodos, mostrar/ler dados.
• Não pode: escrever código "fora" de métodos ou classes (tipo jogar um Console.WriteLine("Hello"); solto fora do Main — não rola!).

Comentários

Comenta seu código pra você mesmo e pra galera. Pra comentários de uma linha, usa //, pra vários usa /* ... */. Quanto mais fácil entender depois por que você escreveu aquele trecho misterioso, melhor.

// Esse é um comentário de uma linha

/*
 Esse aqui —
 é de várias linhas.
*/

5. Como o programa roda?

Seu programa sempre começa a rodar pelo método Main. Tudo que tá antes disso é ignorado. Quer que algo aconteça ao iniciar? Joga dentro do Main.

Exemplo — fluxograma simplificado (código → execução):

Início do programa
     |
     v
Método Main
     |
     v
Executa as instruções dentro do Main (na ordem)
     |
     v
Fim do programa

6. Como seu app cresce: adicionando novos arquivos

Quando criar um novo arquivo?

Quando seu código não cabe mais numa tela só e as variáveis já tão fugindo da cabeça, é hora de dividir o código em partes.

Exemplo: se você tá fazendo uma calculadora, pode criar um arquivo Calculator.cs e jogar lá uma classe separada.

MyFirstConsoleApp/
├── Program.cs
├── Calculator.cs  // Novo arquivo com a lógica da calculadora

Como adicionar um novo arquivo no Rider

1. No Solution Explorer, clica com o direito no projeto → "Add" → "New File" (ou "New Class").
2. Dá um nome que faça sentido pro arquivo.
3. Escreve uma nova classe ou função nesse arquivo.

// Calculator.cs
namespace MyFirstConsoleApp
{
    class Calculator
    {
        public static int Add(int a, int b)
        {
            return a + b;
        }
    }
}

Agora bora usar ela no Program.cs:

// Program.cs
using System;

namespace MyFirstConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = Calculator.Add(2, 3);        //Usando a função Add da classe Calculator
            Console.WriteLine($"2 + 3 = {sum}");
        }
    }
}

7. "Compilar" e "Rodar" — o que rola por trás dos panos?

Quando você clica em Run (ou F5), a IDE:

• Checa o código e compila pra um arquivo binário (.exe ou .dll) na pasta bin/Debug/net9.0/ ou bin/Release/net9.0/.
• Roda o arquivo compilado.
• Mostra o resultado no terminal/console que você vê.

bin/ e obj/: pra que servem essas pastas?

• bin/ — aqui fica seu produto pronto (os programas compilados).
• obj/ — aqui ficam arquivos temporários que o compilador usa pra cálculos intermediários.

Normalmente você pode ignorar essas pastas, o conteúdo delas é recompilado automaticamente se precisar.

8. Erros comuns ao escrever código e mexer no projeto

Programar não é só sair batendo no teclado. Quando aparecem erros tipo CS5001: Program does not contain a static 'Main' method suitable for an entry point, a galera começa a googlar em massa e a IDE reclama num idioma ainda mais estranho.

• Um erro comum é código fora de método ou classe. Em C# não dá pra jogar uma expressão solta no arquivo. Tudo tem que estar dentro de uma classe e de um método!
• Nomes diferentes pra arquivos e classes. Até dá pra fazer, mas é melhor dar nomes iguais e claros — pra você (e pro colega do futuro) não se perder.
• Confusão com namespaces. Se você criou uma classe em outro namespace, não esquece de importar com using.
• Esqueceu do ponto de entrada. Se você apagou ou renomeou o método Main, o programa não vai rodar.