C# .NET — Estudos

Repositório de projetos e exercícios evoluindo de conceitos básicos até arquiteturas distribuídas.

---

Índice

• Estrutura do repositório
• Arquitetura por pasta
• Projetos
• Roadmap de conceitos
• Comandos dotnet
• Como rodar cada projeto
• Referências

---

Estrutura do repositório

Pasta	Tipo	Arquitetura / Padrão	Descrição
Curso_Basico	Exercícios	Console / procedural → POO	10 aulas com arquivos .cs (variáveis, loops, classes, herança, exceções)
Curso_Intermediario	Exercícios	Console / conceitos avançados	LINQ, async/await, generics, delegates, SOLID, xUnit
Curso_Avancado	Projeto console	DI + benchmarks + testes	Memory, patterns, microservices, reactive, source generators
Curso-WebAPI-CRUD	API	Minimal API monolítica	Primeiro CRUD com EF Core + SQLite + Swagger
Curso-WebAPI-CRUD-RepositoryPattern	API	Minimal API + Repository + Service Layer	Biblioteca (Author, Book) com separação de camadas
Projetos/E-Commerce	API	Controllers + Repository + Service Layer	E-commerce com estoque, enums e relacionamentos
Projetos/School	API multi-projeto	Clean Architecture + CQRS	Domain / Application / Infrastructure / WebAPI
Projetos/ReservEasy	API	Vertical Slices + CQRS + Domain Events + FastEndpoints

---

Arquitetura por pasta

Aula_N/
├── README.md          → teoria
└── Exercicios/        → arquivos .cs com Main()

• Padrão: scripts educacionais em console (sem .csproj por aula).
• Conceitos: sintaxe C#, POO, coleções, LINQ, async, design patterns básicos.

Curso_Avancado/
├── Curso_Avancado.csproj   → net8.0, console
└── Aula_N/                 → README + exercícios

• Padrão: console app com pacotes (DI, BenchmarkDotNet, xUnit, Reactive).
• Conceitos: performance, IoC, microservices, testes avançados.

Route Groups (Minimal API) → EF Core DbContext → SQLite

• Padrão: Minimal API monolítica.
• Entidades: Pessoa (CursoModel).

Routes → Service (regras) → Repository<T> → EF Core → SQLite

• Padrão: Minimal API + Repository Pattern + Service Layer.
• Entidades: Author, Book.

Controller → Service → Repository<T> → EF Core → SQLite

• Padrão: API tradicional com Controllers.
• Entidades: Product, Category, Order, OrderItem.

WebAPI (Controllers)
    ↓ MediatR
Application (Commands / Queries / Handlers / Validators)
    ↓ interfaces
Domain (Entities)
    ↓ implementação
Infrastructure (DbContext, Migrations, EF Configurations)

• Padrão: Clean Architecture + CQRS (MediatR) + FluentValidation.
• Projetos: Domain, Application, Infrastructure, WebAPI.
• Entidades: Student, Course, Enrollment.

Features/                    ← Vertical Slices
├── Properties/
├── Guests/
├── Bookings/
└── Payments/
    ├── *Endpoint.cs         ← FastEndpoints (REPR)
    ├── *Command / *Query    ← CQRS via MediatR
    ├── *Handler.cs
    └── *Validator.cs

Domain/   → Entities, Enums, Domain Events
Data/     → DbContext, EF Configurations
Common/   → Behaviors, Middleware, Exceptions

• Padrão: Vertical Slice Architecture + CQRS + Domain Events.
• Entidades: Property, Guest, Booking, Payment.

Notifica.Domain          → Entities, Interfaces, Events
Notifica.Application     → Services, DTOs
Notifica.Infrastructure  → EF (PostgreSQL), Redis, RabbitMQ, Repositories
Notifica.Api             → REST Controllers + SignalR + JWT
Notifica.Grpc            → gRPC (user.proto)
Notifica.Web             → Blazor WebAssembly + SignalR Client + gRPC Client
Notifica.Worker          → Background Service (consumer RabbitMQ)

• Padrão: Clean Architecture distribuída (multi-processo).
• Infra: PostgreSQL, Redis, RabbitMQ via docker-compose.yml.

Controllers → AuthService / ExpenseService → AppDbContext → PostgreSQL

• Padrão: monolito com Service Layer + JWT + Health Checks.
• Testes: FinControl.Tests (xUnit).
• Deploy: Dockerfile + docker-compose.

Controller → AuthService / TableService / MenuService / OrderService / PaymentService / ReservationService → AppDbContext → SQLite

• Padrão: monolito com Service Layer + JWT, herdado do FinControl.
• Entidades: 9 (User, Table, Category, MenuItem, Order, OrderItem, Payment, PaymentMethod, Reservation).
• DTOs: 27 records organizados por módulo.
• Banco: SQLite (sem Docker).

---

Projetos

#	Projeto	Arquitetura	Entidades	Destaque
1	Curso-WebAPI-CRUD	Minimal API	Pessoa	Primeiro contato com Minimal API + EF Core
2	Biblioteca-Aula	Minimal API + Repository + Service	Author, Book	Repository Pattern, Service Layer, validações
3	E-Commerce	Controller + Repository + Service	Product, Category, Order, OrderItem	Controllers, enum, estoque, relacionamentos
4	School	Clean Architecture + CQRS	Student, Course, Enrollment	Multi-projeto, MediatR, FluentValidation
5	ReservEasy	Vertical Slices + CQRS + Event-Driven	Property, Guest, Booking, Payment	FastEndpoints, Domain Events, Serilog
6	Notifica	Clean Architecture + distribuída	User, Notification, Message	SignalR, gRPC, Blazor WASM, RabbitMQ, Redis
7	FinControl	Monolito + Service Layer + JWT	User, Expense	PostgreSQL, Health Checks, Docker, testes xUnit
8	Restaurant-System

---

Roadmap de conceitos

Console / POO
  → Minimal API
    → Repository Pattern
      → Service Layer
        → Controllers
          → Clean Architecture + CQRS
            → Vertical Slices + Domain Events + FastEndpoints
              → Sistema distribuído (API + gRPC + Worker + Frontend)

Cada projeto adiciona uma camada nova em relação ao anterior, evoluindo de exercícios simples até arquiteturas modulares e orientadas a eventos.

---

Comandos dotnet

Ambiente

dotnet --version
dotnet --list-sdks
dotnet --info

Ciclo de vida (qualquer projeto)

dotnet restore
dotnet build
dotnet run
dotnet watch run          # recarrega ao salvar
dotnet clean
dotnet publish -c Release

Criar projetos

dotnet new console -n MeuProjeto
dotnet new webapi -n MinhaApi
dotnet new classlib -n MinhaLib
dotnet new xunit -n MeuProjeto.Tests
dotnet new blazorwasm -n MeuFrontend

Solution (.sln / .slnx)

dotnet sln Projetos/School/School.slnx list
dotnet build Projetos/School/School.slnx
dotnet test Projetos/FinControl/FinControl.slnx

Entity Framework Core

Instale a ferramenta global uma vez: dotnet tool install --global dotnet-ef

# Criar migration
dotnet ef migrations add Initial --project <caminho-do-projeto>

# Aplicar no banco
dotnet ef database update --project <caminho-do-projeto>

# Remover última migration
dotnet ef migrations remove --project <caminho-do-projeto>

Testes

dotnet test
dotnet test --filter "FullyQualifiedName~ExpenseService"
dotnet test --collect:"XPlat Code Coverage"

---

Como rodar cada projeto

Os exercícios são arquivos .cs isolados. Para executar:

dotnet new console -n ExercicioTemp
# copie o .cs do exercício como Program.cs
cd ExercicioTemp
dotnet run

cd Curso_Avancado
dotnet restore
dotnet run
dotnet test

cd Curso-WebAPI-CRUD
dotnet run
# Swagger: http://localhost:5253/swagger

cd Curso-WebAPI-CRUD-RepositoryPattern/Biblioteca-Aula
dotnet run
# Swagger: http://localhost:5134/swagger

cd Projetos/E-Commerce
dotnet run

cd Projetos/School
dotnet restore
dotnet run --project WebAPI

cd Projetos/ReservEasy
dotnet restore
dotnet run --project src/ReservEasy.Api
# https://localhost:7001

cd Projetos/Notifica
docker compose up -d          # PostgreSQL, Redis, RabbitMQ

dotnet run --project src/Notifica.Api       # REST + SignalR
dotnet run --project src/Notifica.Grpc      # gRPC
dotnet run --project src/Notifica.Web         # Blazor WASM
dotnet run --project src/Notifica.Worker      # Consumer RabbitMQ

dotnet test --project tests/Notifica.IntegrationTests