Os fundamentos do .NET para o desenvolvimento de aplicações modernas

Introdução ao .NET

.NET é uma plataforma de desenvolvimento livre e open source criada pela Microsoft, que permite construir diferentes tipos de aplicações: web, mobile, desktop, jogos, IoT e cloud. É um ecossistema completo que oferece aos desenvolvedores as ferramentas necessárias para criar aplicações modernas, performáticas e seguras.

Por que escolher o .NET?

• Versatilidade: desenvolva para Windows, Linux, macOS, iOS, Android e muito mais
• Desempenho: otimizado para velocidade e consumo de recursos
• Segurança: atualizações frequentes e recursos de segurança integrados
• Open Source: projeto open source apoiado pela Microsoft e por uma comunidade ativa
• Ecossistema rico: inúmeras bibliotecas e ferramentas de qualidade

Instalação e configuração

Instalar o SDK do .NET

O SDK (Software Development Kit) do .NET é necessário para desenvolver aplicações .NET.

Windows:

# Baixar a partir do site oficial
https://dotnet.microsoft.com/download

macOS (com Homebrew):

brew install --cask dotnet-sdk

Linux (Ubuntu):

wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
sudo apt-get update
sudo apt-get install -y apt-transport-https
sudo apt-get install -y dotnet-sdk-6.0

Verificar a instalação

dotnet --version

Os conceitos fundamentais

As linguagens de programação

O .NET suporta várias linguagens de programação, sendo as mais populares:

• C# - A linguagem principal, orientada a objetos e fortemente tipada
• F# - Uma linguagem funcional para programas mais concisos
• Visual Basic .NET - Uma versão modernizada do Visual Basic

Estrutura de um projeto .NET

Um projeto .NET geralmente contém os seguintes elementos:

• Arquivo .csproj / .fsproj / .vbproj - Configuração do projeto
• Program.cs - Ponto de entrada da aplicação
• Pastas: Models, Controllers, Views (para aplicações web), Services etc.
• appsettings.json - Configuração da aplicação

Criar um novo projeto

# Criar uma aplicação console
dotnet new console -n MonApplication

# Criar uma aplicação web ASP.NET Core
dotnet new webapp -n MonAppWeb

# Criar uma API web
dotnet new webapi -n MonAPI

A linguagem C#

Variáveis e tipos de dados

// Tipos básicos
int nombre = 42;
double prix = 19.99;
bool estActif = true;
string nom = "Jean Dupont";
char lettre = 'A';

// Coleções
int[] nombres = { 1, 2, 3, 4, 5 };
List<string> noms = new List<string> { "Alice", "Bob", "Charlie" };
Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 30 },
    { "Bob", 25 }
};

Estruturas de controle

// Condições
if (age >= 18)
{
    Console.WriteLine("Majeur");
}
else
{
    Console.WriteLine("Mineur");
}

// Switch
switch (jour)
{
    case "Lundi":
        Console.WriteLine("Début de semaine");
        break;
    case "Vendredi":
        Console.WriteLine("Bientôt le weekend");
        break;
    default:
        Console.WriteLine("Un autre jour");
        break;
}

// Laços
for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

foreach (var nom in noms)
{
    Console.WriteLine(nom);
}

while (compteur > 0)
{
    Console.WriteLine(compteur);
    compteur--;
}

Funções e métodos

// Método simples
void AfficherMessage(string message)
{
    Console.WriteLine(message);
}

// Método com retorno
int Additionner(int a, int b)
{
    return a + b;
}

// Método com parâmetros opcionais
void Configurer(string nom, int age = 18, bool estActif = true)
{
    // ...
}

// Método de extensão
public static class StringExtensions
{
    public static bool EstPalindrome(this string texte)
    {
        string inverse = new string(texte.Reverse().ToArray());
        return texte.Equals(inverse, StringComparison.OrdinalIgnoreCase);
    }
}

Programação Orientada a Objetos em C#

Classes e objetos

// Definição de uma classe
public class Personne
{
    // Propriedades
    public string Nom { get; set; }
    public string Prenom { get; set; }
    public int Age { get; set; }
    
    // Construtor
    public Personne(string nom, string prenom, int age)
    {
        Nom = nom;
        Prenom = prenom;
        Age = age;
    }
    
    // Método
    public string ObtenirNomComplet()
    {
        return $"{Prenom} {Nom}";
    }
}

// Utilização
Personne personne = new Personne("Dupont", "Jean", 30);
Console.WriteLine(personne.ObtenirNomComplet());

Herança

public class Employe : Personne
{
    public string Poste { get; set; }
    public decimal Salaire { get; set; }
    
    public Employe(string nom, string prenom, int age, string poste, decimal salaire)
        : base(nom, prenom, age)
    {
        Poste = poste;
        Salaire = salaire;
    }
    
    public void AugmenterSalaire(decimal pourcentage)
    {
        Salaire += Salaire * (pourcentage / 100);
    }
}

Interfaces

public interface IPayable
{
    decimal CalculerPaiement();
}

public class Consultant : Personne, IPayable
{
    public decimal TarifHoraire { get; set; }
    public int HeuresTravaillees { get; set; }
    
    public Consultant(string nom, string prenom, int age, decimal tarifHoraire)
        : base(nom, prenom, age)
    {
        TarifHoraire = tarifHoraire;
    }
    
    public decimal CalculerPaiement()
    {
        return TarifHoraire * HeuresTravaillees;
    }
}

ASP.NET Core para o desenvolvimento web

ASP.NET Core é um framework web performático, multiplataforma e open source para construir aplicações web modernas.

Estrutura de uma aplicação web ASP.NET Core

MonAppWeb/
├── Controllers/     # Contrôleurs MVC ou d'API
├── Models/          # Classes de modèles
├── Views/           # Vues Razor (pour MVC)
├── wwwroot/         # Fichiers statiques (CSS, JS, images)
├── appsettings.json # Configuration de l'application
├── Program.cs       # Point d'entrée
└── Startup.cs       # Configuration des services et du pipeline

Criar uma API REST simples

// Controllers/PersonnesController.cs
[ApiController]
[Route("api/[controller]")]
public class PersonnesController : ControllerBase
{
    private static List<Personne> _personnes = new List<Personne>
    {
        new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean", Age = 30 },
        new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie", Age = 25 }
    };
    
    [HttpGet]
    public ActionResult<IEnumerable<Personne>> Get()
    {
        return _personnes;
    }
    
    [HttpGet("{id}")]
    public ActionResult<Personne> Get(int id)
    {
        var personne = _personnes.Find(p => p.Id == id);
        if (personne == null)
            return NotFound();
            
        return personne;
    }
    
    [HttpPost]
    public ActionResult<Personne> Post(Personne personne)
    {
        personne.Id = _personnes.Max(p => p.Id) + 1;
        _personnes.Add(personne);
        return CreatedAtAction(nameof(Get), new { id = personne.Id }, personne);
    }
}

Razor Pages para views simples

// Pages/Index.cshtml.cs
public class IndexModel : PageModel
{
    public List<Personne> Personnes { get; set; }
    
    public void OnGet()
    {
        Personnes = new List<Personne>
        {
            new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean", Age = 30 },
            new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie", Age = 25 }
        };
    }
}

<!-- Pages/Index.cshtml -->
@page
@model IndexModel
@{
    ViewData["Title"] = "Liste des personnes";
}

<h1>Liste des personnes</h1>

<table class="table">
    <thead>
        <tr>
            <th>ID</th>
            <th>Prénom</th>
            <th>Nom</th>
            <th>Âge</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var personne in Model.Personnes)
        {
            <tr>
                <td>@personne.Id</td>
                <td>@personne.Prenom</td>
                <td>@personne.Nom</td>
                <td>@personne.Age</td>
            </tr>
        }
    </tbody>
</table>

Entity Framework Core para acesso a dados

Entity Framework Core é um ORM (Object-Relational Mapping) que permite interagir com um banco de dados usando objetos C#.

Configuração básica

// Models/Personne.cs
public class Personne
{
    public int Id { get; set; }
    public string Nom { get; set; }
    public string Prenom { get; set; }
    public int Age { get; set; }
}

// Data/ApplicationDbContext.cs
public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<Personne> Personnes { get; set; }
}

// Program.cs
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

Operações CRUD simples

// Services/PersonneService.cs
public class PersonneService
{
    private readonly ApplicationDbContext _context;
    
    public PersonneService(ApplicationDbContext context)
    {
        _context = context;
    }
    
    public async Task<List<Personne>> ObtenirToutesAsync()
    {
        return await _context.Personnes.ToListAsync();
    }
    
    public async Task<Personne> ObtenirParIdAsync(int id)
    {
        return await _context.Personnes.FindAsync(id);
    }
    
    public async Task AjouterAsync(Personne personne)
    {
        _context.Personnes.Add(personne);
        await _context.SaveChangesAsync();
    }
    
    public async Task MettreAJourAsync(Personne personne)
    {
        _context.Entry(personne).State = EntityState.Modified;
        await _context.SaveChangesAsync();
    }
    
    public async Task SupprimerAsync(int id)
    {
        var personne = await _context.Personnes.FindAsync(id);
        if (personne != null)
        {
            _context.Personnes.Remove(personne);
            await _context.SaveChangesAsync();
        }
    }
}

Boas práticas em .NET

Arquitetura em camadas

Uma estrutura clássica de uma aplicação .NET:

1. Camada de Apresentação: UI, API etc.
2. Camada de Aplicação: serviços, lógica de negócio
3. Camada de Domínio: entidades, lógica de negócio essencial
4. Camada de Infraestrutura: acesso a dados, serviços externos

Injeção de dependências

// Registro dos serviços no Program.cs
builder.Services.AddScoped<IPersonneService, PersonneService>();
builder.Services.AddScoped<IPersonneRepository, PersonneRepository>();

// Utilização em um controller
public class PersonnesController : ControllerBase
{
    private readonly IPersonneService _personneService;
    
    public PersonnesController(IPersonneService personneService)
    {
        _personneService = personneService;
    }
    
    // ...
}

Testes unitários

// Tests/PersonneServiceTests.cs
public class PersonneServiceTests
{
    [Fact]
    public async Task ObtenirToutesAsync_RetourneToutesLesPersonnes()
    {
        // Arrange
        var mockRepository = new Mock<IPersonneRepository>();
        mockRepository.Setup(repo => repo.ObtenirToutesAsync())
            .ReturnsAsync(new List<Personne>
            {
                new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean" },
                new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie" }
            });
            
        var service = new PersonneService(mockRepository.Object);
        
        // Act
        var resultat = await service.ObtenirToutesAsync();
        
        // Assert
        Assert.Equal(2, resultat.Count);
    }
}

.NET na nuvem

Azure e .NET

O Azure oferece excelente suporte para aplicações .NET:

• Azure App Service: implantação fácil de aplicações web
• Azure Functions: funções serverless
• Azure SQL Database: banco de dados SQL compatível com o Entity Framework
• Azure Storage: armazenamento em nuvem (blobs, tabelas, filas)

Docker e .NET

# Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MonApp.csproj", "./"]
RUN dotnet restore "MonApp.csproj"
COPY . .
RUN dotnet publish "MonApp.csproj" -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MonApp.dll"]

Recursos para continuar aprendendo

• Documentação oficial: docs.microsoft.com/dotnet
• Microsoft Learn: learn.microsoft.com
• GitHub .NET: github.com/dotnet
• Canal do YouTube do .NET: youtube.com/dotnet

Conclusão

O .NET é uma plataforma madura, performática e em constante evolução, que oferece um excelente ambiente de desenvolvimento para criar aplicações modernas. Sua versatilidade permite atingir diferentes plataformas e desenvolver diversos tipos de aplicações, da web ao mobile, passando pelo desktop e pela nuvem. Ao dominar esses fundamentos, você terá uma base sólida para explorar ainda mais as possibilidades oferecidas pelo ecossistema .NET.