Bonnes pratiques avec les fichiers en .NET

// Fragile : séparateur en dur, non portable Linux/Windows
var path = baseDir + "\\" + "subfolder" + "\\" + "file.txt";

// Fragile : les slashes peuvent ne pas correspondre à l'OS
var path = baseDir + "/subfolder/file.txt";

var path = Path.Combine(baseDir, "subfolder", "file.txt");

Path.Combine("C:\\data", "C:\\other", "file.txt"); // → "C:\\other\\file.txt"

var path = Path.Join(baseDir, "subfolder", "file.txt");

// Avec des Span<char> pour éviter les allocations
var path = Path.Join(baseDir.AsSpan(), "subfolder".AsSpan(), "file.txt".AsSpan());

// Résout les ".." et les doubles séparateurs
var normalized = Path.GetFullPath(path);

// Résoudre relativement à une base
var full = Path.GetFullPath("../config.json", baseDir);

// Lecture complète
string content = await File.ReadAllTextAsync(path, Encoding.UTF8);
byte[] bytes    = await File.ReadAllBytesAsync(path);
string[] lines  = await File.ReadAllLinesAsync(path, Encoding.UTF8);

// Écriture complète
await File.WriteAllTextAsync(path, content, Encoding.UTF8);
await File.WriteAllBytesAsync(path, bytes);
await File.WriteAllLinesAsync(path, lines, Encoding.UTF8);

await using var reader = new StreamReader(path, Encoding.UTF8);
while (!reader.EndOfStream)
{
    var line = await reader.ReadLineAsync();
    // traiter line
}

await using var writer = new StreamWriter(path, append: false, Encoding.UTF8);
await writer.WriteLineAsync("première ligne");
await writer.WriteLineAsync("deuxième ligne");
// flush automatique à la fin du using

await using var fs = new FileStream(
    path,
    FileMode.Create,
    FileAccess.Write,
    FileShare.None,
    bufferSize: 4096,
    useAsync: true);

await fs.WriteAsync(buffer.AsMemory(0, bytesRead));

// Synchrone
using var stream = File.OpenRead(path);

// Asynchrone — préférez await using
await using var stream = File.OpenReadAsync(path);

var stream = File.OpenRead(path);
// ... oubli de Dispose → le fichier reste verrouillé

// Crée physiquement un fichier de 0 octet dans le dossier Temp de l'OS
// et retourne son chemin — risque de collision si mal géré
var tempFile = Path.GetTempFileName();

var tempPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.tmp");
try
{
    await File.WriteAllTextAsync(tempPath, content);
    // ... traitements
}
finally
{
    File.Delete(tempPath); // garanti même en cas d'exception
}

public sealed class TempFile : IDisposable
{
    public string Path { get; } = System.IO.Path.Combine(
        System.IO.Path.GetTempPath(),
        $"{Guid.NewGuid()}.tmp");

    public void Dispose()
    {
        if (File.Exists(Path))
            File.Delete(Path);
    }
}

// Utilisation
using var temp = new TempFile();
await File.WriteAllTextAsync(temp.Path, data);
// Suppression automatique à la sortie du using

// BOM inclus par défaut avec new UTF8Encoding(true)
await File.WriteAllTextAsync(path, content, Encoding.UTF8);

// Sans BOM (courant pour les échanges inter-systèmes)
await File.WriteAllTextAsync(path, content, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));

// Fichier
if (File.Exists(path))
{
    // ...
}

// Répertoire
if (Directory.Exists(dirPath))
{
    // ...
}

// Créer le répertoire si absent (idempotent)
Directory.CreateDirectory(dirPath);

var filePath = Path.Join(baseDir, "reports", "2026", "rapport.pdf");

// Crée tous les répertoires intermédiaires en une seule instruction (idempotent)
Directory.CreateDirectory(Path.GetDirectoryName(filePath)!);

await File.WriteAllBytesAsync(filePath, pdfBytes);

public static async Task WriteAllTextSafeAsync(string filePath, string content, Encoding? encoding = null)
{
    Directory.CreateDirectory(Path.GetDirectoryName(filePath)!);
    await File.WriteAllTextAsync(filePath, content, encoding ?? Encoding.UTF8);
}

public string GetSecurePath(string baseDir, string userInput)
{
    // Normaliser pour résoudre les ".."
    var fullPath = Path.GetFullPath(Path.Join(baseDir, userInput));

    // Vérifier que le chemin résultant reste sous baseDir
    if (!fullPath.StartsWith(Path.GetFullPath(baseDir) + Path.DirectorySeparatorChar,
                              StringComparison.OrdinalIgnoreCase))
    {
        throw new UnauthorizedAccessException("Accès refusé : chemin hors du répertoire autorisé.");
    }

    return fullPath;
}

using var watcher = new FileSystemWatcher(dirPath)
{
    Filter = "*.json",
    NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName,
    IncludeSubdirectories = false,
    EnableRaisingEvents = true
};

watcher.Changed += (_, e) => Console.WriteLine($"Modifié : {e.FullPath}");
watcher.Created += (_, e) => Console.WriteLine($"Créé    : {e.FullPath}");
watcher.Deleted += (_, e) => Console.WriteLine($"Supprimé: {e.FullPath}");

// Éviter les événements en double (le Changed se déclenche parfois deux fois)
watcher.Changed += OnChangedDebounced;

// Lister les fichiers (non récursif)
var files = Directory.GetFiles(dirPath, "*.txt");

// Lister récursivement sans tout charger en mémoire
foreach (var file in Directory.EnumerateFiles(dirPath, "*.txt", SearchOption.AllDirectories))
{
    // traiter file
}

// Copier un répertoire entier (non intégré nativement avant .NET 8)
// À partir de .NET 8 :
// Pas d'API built-in, mais on peut utiliser DirectoryInfo
new DirectoryInfo(sourceDir).CopyTo(destinationDir); // ⚠ n'existe pas

// Pattern manuel
foreach (var file in Directory.EnumerateFiles(sourceDir, "*", SearchOption.AllDirectories))
{
    var relativePath = Path.GetRelativePath(sourceDir, file);
    var destFile     = Path.Join(destinationDir, relativePath);
    Directory.CreateDirectory(Path.GetDirectoryName(destFile)!);
    File.Copy(file, destFile, overwrite: true);
}

// Emplacement portable pour les données d'application
var appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
var configPath = Path.Join(appData, "MonApp", "config.json");