[GUIDE] Ressources développeurs .NET, VS Code, PowerShell, GitHub

Développement & Outils Pro
1

[GUIDE] Ressources developpeurs .NET, VS Code, PowerShell, GitHub

Guide complet des outils, frameworks et bonnes pratiques pour les developpeurs de l’ecosysteme Microsoft. De .NET 9 a GitHub Copilot, en passant par PowerShell et Azure DevOps.

1. .NET & C# — L’ecosysteme moderne

.NET 9 — Nouveautes majeures

.NET 9 (novembre 2024) apporte des ameliorations significatives :

  • Performances : amelioration du JIT, du GC (Garbage Collector) et du runtime
  • AOT natif : compilation Ahead-of-Time pour les API minimales, applications console et workers
  • Serialisation JSON : System.Text.Json ameliore avec le support des types supplementaires
  • LINQ : nouvelles methodes CountBy, AggregateBy, Index
  • Bibliotheque de base : TimeProvider pour les tests temporels, SearchValues pour la recherche optimisee
// Exemple .NET 9 : CountBy et AggregateBy
var mots = new[] { "bonjour", "monde", "bonjour", "france", "monde", "monde" };
foreach (var (mot, count) in mots.CountBy(m => m))
{
    Console.WriteLine($"{mot} : {count} fois");
}

ASP.NET Core

Framework Usage Quand l’utiliser
API minimale API REST legeres Microservices, API simples
API Controllers API REST completes API complexes avec conventions
MVC Sites web avec vues Razor Applications web traditionnelles
Blazor Server SPA cote serveur Apps interactives, connexion permanente
Blazor WebAssembly SPA cote client Apps offline, distribution CDN
Blazor United (.NET 8+) Rendu hybride SSR + interactif Nouveau standard recommande 
// API minimale .NET 9
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<AppDbContext>();
var app = builder.Build();

app.MapGet("/api/produits", async (AppDbContext db) =>
    await db.Produits.ToListAsync());

app.MapPost("/api/produits", async (Produit produit, AppDbContext db) =>
{
    db.Produits.Add(produit);
    await db.SaveChangesAsync();
    return Results.Created($"/api/produits/{produit.Id}", produit);
});

app.Run();

.NET MAUI — Applications cross-platform

.NET MAUI (Multi-platform App UI) permet de creer des applications natives pour Windows, macOS, Android et iOS avec un seul code C# :

// Page MAUI simple
public class MainPage : ContentPage
{
    public MainPage()
    {
        Content = new VerticalStackLayout
        {
            new Label { Text = "Bienvenue sur MAUI !", FontSize = 24 },
            new Button { Text = "Cliquez-moi", Command = new Command(() =>
                DisplayAlert("Info", "MAUI fonctionne !", "OK")) }
        };
    }
}

Entity Framework Core

// Migration EF Core
// 1. Ajouter une migration
// dotnet ef migrations add InitialCreate
// 2. Appliquer a la base de donnees
// dotnet ef database update

public class AppDbContext : DbContext
{
    public DbSet<Produit> Produits => Set<Produit>();
    public DbSet<Categorie> Categories => Set<Categorie>();

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlServer("Server=.;Database=MaBase;Trusted_Connection=true;TrustServerCertificate=true;");
}

Migration .NET Framework vers .NET moderne

  1. Utilisez l’outil upgrade-assistant :
dotnet tool install -g upgrade-assistant
upgrade-assistant upgrade ./MonProjet.sln
  1. Analysez les incompatibilites avec apiport (API Portability Analyzer)
  2. Migrez les packages NuGet System.Web vers les equivalents ASP.NET Core
  3. Remplacez Web.config par appsettings.json
  4. Convertissez Global.asax vers Program.cs / Startup.cs

2. Visual Studio — Productivite maximale

Raccourcis essentiels

Raccourci Action
Ctrl+Maj+B Compiler la solution
F5 / Ctrl+F5 Demarrer avec/sans debogage
Ctrl+. Actions rapides et refactoring
Ctrl+T Rechercher fichiers, types, membres
Ctrl+Maj+F Rechercher dans tous les fichiers
F12 Aller a la definition
Alt+F12 Definition en apercu (peek)
Ctrl+K, Ctrl+D Formater le document
Ctrl+K, Ctrl+C/U Commenter/Decommenter
Ctrl+R, Ctrl+R Renommer (refactoring)
Maj+Alt+Entree Plein ecran
Ctrl+Maj+V Historique du presse-papiers

Extensions indispensables

  • ReSharper : analyse de code avancee, refactoring puissant
  • CodeMaid : nettoyage et organisation du code
  • Fine Code Coverage : couverture de code gratuite
  • GitHub Copilot : suggestions IA en temps reel
  • Markdown Editor : edition Markdown avec apercu
  • SlowCheetah : transformations de fichiers de configuration

Debogage avance

// Breakpoint conditionnel : clic droit sur le breakpoint > Conditions
// Expression : produit.Prix > 100 && produit.Stock == 0

// Point de trace (Tracepoint) : affiche un message sans arreter l'execution
// Message : "Produit {produit.Nom} - Prix: {produit.Prix}"

// DebuggerDisplay pour un affichage personnalise dans le debogueur
[DebuggerDisplay("{Nom} (Id={Id}, Prix={Prix}€)")]
public class Produit
{
    public int Id { get; set; }
    public string Nom { get; set; }
    public decimal Prix { get; set; }
}
  • IntelliTrace (Enterprise) : enregistrement de l’historique d’execution pour revenir en arriere dans le debogage
  • Profiling : Debogage > Profileur de performances > choisir CPU, memoire, base de donnees

3. VS Code — L’editeur incontournable

Extensions Microsoft recommandees

Extension Description
C# Dev Kit IntelliSense, debogage, tests pour C#
PowerShell Edition et debogage PowerShell
Azure Tools Pack complet pour Azure (Functions, App Service, Storage…)
GitHub Copilot Autocompletion IA
GitHub Copilot Chat Chat IA integre dans l’editeur
Remote - SSH Developper sur un serveur distant
Remote - WSL Developper dans WSL
Dev Containers Developper dans des conteneurs Docker
Python Support complet Python
Thunder Client Client REST API integre
Live Share Collaboration en temps reel

settings.json optimise

{
    "editor.fontSize": 14,
    "editor.fontFamily": "'Cascadia Code', 'Fira Code', Consolas, monospace",
    "editor.fontLigatures": true,
    "editor.formatOnSave": true,
    "editor.minimap.enabled": false,
    "editor.bracketPairColorization.enabled": true,
    "editor.guides.bracketPairs": true,
    "editor.stickyScroll.enabled": true,
    "editor.inlineSuggest.enabled": true,
    "terminal.integrated.defaultProfile.windows": "PowerShell",
    "terminal.integrated.fontFamily": "'Cascadia Mono', Consolas",
    "files.autoSave": "afterDelay",
    "files.autoSaveDelay": 1000,
    "workbench.colorTheme": "Default Dark Modern",
    "git.autofetch": true,
    "git.confirmSync": false,
    "omnisharp.enableRoslynAnalyzers": true,
    "dotnet.defaultSolution": "auto",
    "[csharp]": {
        "editor.defaultFormatter": "ms-dotnettools.csharp"
    },
    "[json]": {
        "editor.defaultFormatter": "esbenp.prettier-vscode"
    }
}

Multi-root Workspaces

Creez un fichier .code-workspace pour regrouper plusieurs projets :

{
    "folders": [
        { "path": "./frontend", "name": "Frontend React" },
        { "path": "./backend", "name": "API .NET" },
        { "path": "./shared", "name": "Bibliotheque partagee" }
    ],
    "settings": {
        "dotnet.defaultSolution": "backend/MonAPI.sln"
    }
}

Remote Development

  • SSH : Ctrl+Maj+P > “Remote-SSH: Connect to Host” — developpez sur un serveur Linux distant
  • WSL : ouvrez un dossier WSL directement — code /mnt/c/projets/monapp depuis WSL
  • Dev Containers : ajoutez un .devcontainer/devcontainer.json pour un environnement reproductible

4. PowerShell — Automatisation et scripts

Scripts d’automatisation courants

# Inventaire des logiciels installes
Get-CimInstance -ClassName Win32_Product |
  Select-Object Name, Version, Vendor |
  Sort-Object Name |
  Export-Csv "$env:USERPROFILE\Desktop\logiciels.csv" -NoTypeInformation -Encoding UTF8

# Nettoyage des fichiers temporaires
$dossiers = @("$env:TEMP", "$env:SystemRoot\Temp", "$env:SystemRoot\Prefetch")
foreach ($dossier in $dossiers) {
    Get-ChildItem $dossier -Recurse -Force -ErrorAction SilentlyContinue |
      Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-7) } |
      Remove-Item -Force -Recurse -ErrorAction SilentlyContinue
}
Write-Host "Nettoyage termine." -ForegroundColor Green

# Surveillance d'un service avec redemarrage automatique
$service = "Spooler"
if ((Get-Service $service).Status -ne 'Running') {
    Start-Service $service
    Send-MailMessage -To "[email protected]" -From "[email protected]" `
      -Subject "Service $service redemarre" -SmtpServer "smtp.example.com"
}

Modules essentiels

Module Usage Installation
Az Gestion Azure Install-Module Az
Microsoft.Graph API Microsoft 365 Install-Module Microsoft.Graph
ActiveDirectory Gestion AD DS Fonctionnalite RSAT
ImportExcel Lire/ecrire Excel sans Office Install-Module ImportExcel
Pester Tests unitaires PowerShell Install-Module Pester
PSScriptAnalyzer Linter PowerShell Install-Module PSScriptAnalyzer
Terminal-Icons Icones dans le terminal Install-Module Terminal-Icons

Profil PowerShell

# Editer le profil : notepad $PROFILE
# Contenu recommande :

# Modules
Import-Module Terminal-Icons
Import-Module posh-git

# Alias utiles
Set-Alias -Name g -Value git
Set-Alias -Name k -Value kubectl
Set-Alias -Name tf -Value terraform

# Fonctions personnalisees
function which($name) { Get-Command $name -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Path }
function mkcd($path) { New-Item -ItemType Directory -Path $path -Force; Set-Location $path }
function tail { Get-Content -Tail 20 -Wait @args }

# Prompt personnalise avec Oh My Posh
oh-my-posh init pwsh --config "$env:POSH_THEMES_PATH\paradox.omp.json" | Invoke-Expression

Pester — Tests unitaires

# Fichier : Get-Factorielle.Tests.ps1
Describe "Get-Factorielle" {
    It "Retourne 1 pour 0" {
        Get-Factorielle -Nombre 0 | Should -Be 1
    }
    It "Retourne 120 pour 5" {
        Get-Factorielle -Nombre 5 | Should -Be 120
    }
    It "Lance une erreur pour un nombre negatif" {
        { Get-Factorielle -Nombre -1 } | Should -Throw
    }
}
# Executer : Invoke-Pester ./Get-Factorielle.Tests.ps1 -Output Detailed

5. GitHub & GitHub Copilot

Git workflow recommande

# Creer une branche feature
git checkout -b feature/ma-fonctionnalite

# Travailler, committer regulierement
git add .
git commit -m "feat: ajout du module d'authentification"

# Pousser et creer une Pull Request
git push -u origin feature/ma-fonctionnalite
gh pr create --title "feat: module authentification" --body "Description detaillee..."

# Apres la revue de code, fusionner
gh pr merge --squash --delete-branch

Conventions de commit (Conventional Commits) :

  • feat: — nouvelle fonctionnalite
  • fix: — correction de bug
  • docs: — documentation
  • refactor: — refactoring sans changement fonctionnel
  • test: — ajout ou modification de tests
  • chore: — maintenance (dependances, CI, config)

GitHub Actions — CI/CD

# .github/workflows/dotnet.yml
name: .NET CI/CD

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4

    - name: Setup .NET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: '9.0.x'

    - name: Restaurer les dependances
      run: dotnet restore

    - name: Compiler
      run: dotnet build --no-restore --configuration Release

    - name: Tests
      run: dotnet test --no-build --configuration Release --verbosity normal
        --collect:"XPlat Code Coverage"

    - name: Publier
      if: github.ref == 'refs/heads/main'
      run: dotnet publish -c Release -o ./publish

    - name: Deployer sur Azure
      if: github.ref == 'refs/heads/main'
      uses: azure/webapps-deploy@v3
      with:
        app-name: 'mon-api-production'
        publish-profile: ${{ secrets.AZURE_PUBLISH_PROFILE }}
        package: ./publish

GitHub Copilot — Prompts efficaces

  • Commentaire descriptif : ecrivez un commentaire clair avant le code, Copilot generera l’implementation
  • Chat inline : Ctrl+I pour demander une modification dans le contexte du fichier
  • Commandes slash :
    • /explain — expliquer le code selectionne
    • /fix — corriger un bug
    • /tests — generer des tests unitaires
    • /doc — generer la documentation
    • @workspace — poser une question sur tout le projet

GitHub Codespaces

Environnement de developpement cloud complet base sur VS Code :

  • Disponible en quelques secondes depuis n’importe quel depot
  • Configuration via .devcontainer/devcontainer.json
  • 60 heures/mois gratuites pour les comptes personnels
  • Forwarding de ports automatique pour les applications web

6. SQL Server

Requetes d’optimisation essentielles

-- Top 10 des requetes les plus couteuses en CPU
SELECT TOP 10
    qs.total_worker_time / qs.execution_count AS avg_cpu_time,
    qs.execution_count,
    SUBSTRING(qt.text, (qs.statement_start_offset/2) + 1,
        ((CASE qs.statement_end_offset
            WHEN -1 THEN DATALENGTH(qt.text)
            ELSE qs.statement_end_offset END
        - qs.statement_start_offset) / 2) + 1) AS query_text
FROM sys.dm_exec_query_stats qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) qt
ORDER BY avg_cpu_time DESC;

-- Index manquants suggeres par SQL Server
SELECT
    d.name AS base_de_donnees,
    OBJECT_NAME(mid.object_id, mid.database_id) AS table_name,
    mid.equality_columns,
    mid.inequality_columns,
    mid.included_columns,
    migs.avg_user_impact AS amelioration_estimee_pct
FROM sys.dm_db_missing_index_details mid
JOIN sys.dm_db_missing_index_groups mig ON mid.index_handle = mig.index_handle
JOIN sys.dm_db_missing_index_group_stats migs ON mig.index_group_handle = migs.group_handle
JOIN sys.databases d ON mid.database_id = d.database_id
ORDER BY migs.avg_user_impact DESC;

Sauvegarde et restauration

-- Sauvegarde complete
BACKUP DATABASE MaBase TO DISK = 'C:\Backups\MaBase_Full.bak'
WITH COMPRESSION, CHECKSUM, INIT;

-- Restauration
RESTORE DATABASE MaBase FROM DISK = 'C:\Backups\MaBase_Full.bak'
WITH RECOVERY, REPLACE,
MOVE 'MaBase' TO 'C:\Data\MaBase.mdf',
MOVE 'MaBase_Log' TO 'C:\Data\MaBase_log.ldf';

7. Azure DevOps

Pipeline YAML type

# azure-pipelines.yml
trigger:
  branches:
    include:
      - main
      - develop

pool:
  vmImage: 'windows-latest'

variables:
  buildConfiguration: 'Release'
  dotnetVersion: '9.0.x'

stages:
- stage: Build
  jobs:
  - job: BuildAndTest
    steps:
    - task: UseDotNet@2
      inputs:
        version: $(dotnetVersion)

    - script: dotnet restore
      displayName: 'Restaurer les packages'

    - script: dotnet build --configuration $(buildConfiguration)
      displayName: 'Compiler'

    - script: dotnet test --configuration $(buildConfiguration) --logger trx --results-directory $(Agent.TempDirectory)
      displayName: 'Executer les tests'

    - task: PublishTestResults@2
      inputs:
        testResultsFormat: 'VSTest'
        testResultsFiles: '$(Agent.TempDirectory)/**/*.trx'

    - task: PublishBuildArtifacts@1
      inputs:
        PathtoPublish: '$(Build.ArtifactStagingDirectory)'
        ArtifactName: 'drop'

- stage: Deploy
  dependsOn: Build
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  jobs:
  - deployment: DeployProduction
    environment: 'production'
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploiement en production..."
            displayName: 'Deployer'

Azure DevOps — Composants

Composant Description
Repos Depots Git avec Pull Requests et politiques de branche
Pipelines CI/CD avec YAML ou editeur visuel
Boards Gestion de projet Agile (Scrum, Kanban)
Artifacts Flux NuGet, npm, Maven prives
Test Plans Tests manuels et exploratoires

8. Outils complementaires

NuGet — Gestion des packages

# Ajouter un package
dotnet add package Newtonsoft.Json
dotnet add package Serilog.AspNetCore --version 8.0.0

# Lister les packages obsoletes
dotnet list package --outdated

# Mettre a jour tous les packages
dotnet outdated --upgrade  # necessite dotnet-outdated-tool

Docker pour developpeurs .NET

# Dockerfile multi-stage pour une API .NET
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY *.csproj ./
RUN dotnet restore
COPY . ./
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS runtime
WORKDIR /app
COPY --from=build /app ./
EXPOSE 8080
ENTRYPOINT ["dotnet", "MonAPI.dll"]

# Construire et executer
docker build -t mon-api .
docker run -d -p 8080:8080 --name mon-api-container mon-api

Windows Terminal & WSL2

  • Installez Windows Terminal depuis le Microsoft Store
  • Ajoutez des profils pour PowerShell, CMD, WSL (Ubuntu), Azure Cloud Shell
  • WSL2 : wsl --install pour installer Ubuntu, puis wsl --set-default-version 2
  • Interoperabilite : accedez aux fichiers Windows depuis WSL via /mnt/c/ et aux fichiers WSL depuis Windows via \\wsl$\

9. Certifications developpeur Microsoft

Certification Sujet Niveau
AZ-204 Developpement de solutions Azure Associe
AZ-400 Solutions DevOps Azure Expert
MS-600 Applications et solutions Microsoft 365 Associe
AI-102 Solutions IA Azure Associe
DP-420 Azure Cosmos DB Specialite

Ressources gratuites :

  • Microsoft Learn : parcours d’apprentissage gratuits et interactifs
  • .NET Learn : tutoriels debutants a avances
  • Microsoft Virtual Training Days : sessions gratuites avec bon d’examen parfois inclus

10. Tableau recapitulatif des commandes

dotnet CLI

dotnet new webapi -n MonAPI           # Creer un projet API
dotnet new blazor -n MonApp           # Creer un projet Blazor
dotnet run                            # Executer le projet
dotnet watch                          # Hot reload en developpement
dotnet build -c Release               # Compiler en mode Release
dotnet test                           # Lancer les tests
dotnet publish -c Release -o ./dist   # Publier pour le deploiement
dotnet ef migrations add NomMigration # Creer une migration EF
dotnet ef database update             # Appliquer les migrations
dotnet tool install -g dotnet-ef      # Installer l'outil EF globalement

Git

git log --oneline --graph -20         # Historique graphique
git stash / git stash pop             # Mettre de cote / restaurer
git rebase main                       # Rebaser sur main
git cherry-pick <hash>                # Appliquer un commit specifique
git bisect start                      # Trouver un commit fautif
git reflog                            # Historique de toutes les actions

Azure CLI (az)

az login                              # Se connecter
az group create -n MonRG -l westeurope # Creer un resource group
az webapp create -g MonRG -p MonPlan -n MonApp  # Creer une Web App
az webapp deploy -g MonRG -n MonApp --src-path ./dist.zip  # Deployer
az acr build --registry MonACR --image monapp:v1 .  # Build image

PowerShell (pwsh)

Get-Command *-Service*                # Trouver des commandes
Get-Help Get-Process -Examples        # Aide avec exemples
Get-Process | Sort-Object CPU -Desc | Select-Object -First 10  # Top CPU
Measure-Command { script.ps1 }        # Mesurer le temps d'execution
Test-Connection google.com -Count 4   # Equivalent de ping

Liens utiles : learn.microsoft.com | github.com/dotnet | devblogs.microsoft.com

Pour un accompagnement professionnel : ayinedjimi-consultants.fr