Elysia Tools

Parcourez outils, exemples, explications visuelles et guides thématiques dans un espace clair.

Catégories populaires

Dossiers

Langue
ZHESPTRUFRDEEN

Elysia Tools

Navigation mobile

C#

Opérations de Fichiers Windows - Exemples C#

Exemples complets d'opérations de fichiers C# pour plateforme Windows incluant E/S texte, copie, parcours de répertoires et opérations système de fichiers

Exemples

Entrées de cette collection

Code sourcecsharpSimple

Opérations de Lecture et Écriture de Fichiers Texte

Opérations de base de lecture et écriture de fichiers texte utilisant la classe File de C#

Difficulté

2/10

Temps estimé

15 min

Étiquettes

csharp, file, io, windows, system

Prérequis

Basic C# syntax, Understanding of file paths

csharp
using System;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

class FileOperations
{
    // 1. Write text to file (simple)
    public static void WriteSimpleText()
    {
        string filePath = "simple.txt";
        string content = "Hello, Windows! This is a simple text file.";

        File.WriteAllText(filePath, content);
        Console.WriteLine($"Text written to {filePath}");
    }

    // 2. Write text to file with encoding
    public static void WriteTextWithEncoding()
    {
        string filePath = "encoded.txt";
        string content = "Unicode text: 你好世界 🌍";

        File.WriteAllText(filePath, content, Encoding.UTF8);
        Console.WriteLine($"UTF-8 encoded text written to {filePath}");
    }

    // 3. Append text to file
    public static void AppendToFile()
    {
        string filePath = "append.txt";

        // Create file with initial content
        File.WriteAllText(filePath, "First line\n");

        // Append more content
        File.AppendAllText(filePath, "Second line\n");
        File.AppendAllText(filePath, "Third line\n");

        Console.WriteLine("Text appended to file");
    }

    // 4. Read entire file
    public static void ReadEntireFile()
    {
        string filePath = "simple.txt";

        if (File.Exists(filePath))
        {
            string content = File.ReadAllText(filePath);
            Console.WriteLine($"File content: {content}");
        }
        else
        {
            Console.WriteLine("File does not exist");
        }
    }

    // 5. Read file with encoding
    public static void ReadFileWithEncoding()
    {
        string filePath = "encoded.txt";

        if (File.Exists(filePath))
        {
            string content = File.ReadAllText(filePath, Encoding.UTF8);
            Console.WriteLine($"UTF-8 file content: {content}");
        }
        else
        {
            Console.WriteLine("Encoded file does not exist");
        }
    }

    // 6. Read file line by line
    public static void ReadFileByLines()
    {
        string filePath = "append.txt";

        if (File.Exists(filePath))
        {
            string[] lines = File.ReadAllLines(filePath);
            Console.WriteLine("File read line by line:");

            for (int i = 0; i < lines.Length; i++)
            {
                Console.WriteLine($"Line {i + 1}: {lines[i]}");
            }
        }
        else
        {
            Console.WriteLine("File does not exist");
        }
    }

    // 7. Advanced file reading with StreamReader
    public static void ReadWithStreamReader()
    {
        string filePath = "largefile.txt";

        // Create a large file for demonstration
        using (StreamWriter writer = new StreamWriter(filePath))
        {
            for (int i = 1; i <= 100; i++)
            {
                writer.WriteLine($"Line {i}: This is a test line with some content");
            }
        }

        // Read using StreamReader
        Console.WriteLine("Reading file with StreamReader:");
        using (StreamReader reader = new StreamReader(filePath))
        {
            string line;
            int lineNumber = 1;

            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine($"Line {lineNumber}: {line}");
                lineNumber++;

                // Read only first 10 lines for demo
                if (lineNumber > 10)
                {
                    Console.WriteLine("... (skipping remaining lines)");
                    break;
                }
            }
        }
    }

    // 8. Write multiple lines at once
    public static void WriteMultipleLines()
    {
        string filePath = "multiline.txt";
        string[] lines = {
            "First line of text",
            "Second line with numbers: 123",
            "Third line with symbols: !@#$",
            "Fourth line empty:",
            "",
            "Last line of text"
        };

        File.WriteAllLines(filePath, lines);
        Console.WriteLine($"Multiple lines written to {filePath}");
    }

    // 9. Read and write with async operations
    public static async Task AsyncFileOperations()
    {
        string filePath = "async.txt";
        string content = "This file was written asynchronously!";

        // Async write
        await File.WriteAllTextAsync(filePath, content);
        Console.WriteLine($"Async write completed to {filePath}");

        // Async read
        string readContent = await File.ReadAllTextAsync(filePath);
        Console.WriteLine($"Async read content: {readContent}");
    }

    // 10. File backup operation
    public static void CreateFileBackup()
    {
        string originalFile = "important.txt";
        string backupFile = "important_backup.txt";

        // Create original file
        string content = $"Important data created at {DateTime.Now}\n" +
                       "This is critical information that needs backup\n" +
                       "Line 3: More important data";

        File.WriteAllText(originalFile, content);

        // Create backup
        File.Copy(originalFile, backupFile, true);
        Console.WriteLine($"Backup created: {backupFile}");
    }

    // Main method to demonstrate all operations
    static async Task Main(string[] args)
    {
        Console.WriteLine("=== C# File Operations Demo ===\n");

        try
        {
            // Basic write operations
            WriteSimpleText();
            WriteTextWithEncoding();
            AppendToFile();
            WriteMultipleLines();

            Console.WriteLine("\n=== Reading Operations ===\n");

            // Reading operations
            ReadEntireFile();
            ReadFileWithEncoding();
            ReadFileByLines();
            ReadWithStreamReader();

            Console.WriteLine("\n=== Async Operations ===\n");

            // Async operations
            await AsyncFileOperations();

            Console.WriteLine("\n=== Backup Operations ===\n");

            // Backup operations
            CreateFileBackup();

            Console.WriteLine("\nAll file operations completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in file operations: {ex.Message}");
        }
        finally
        {
            // Cleanup demo files
            string[] demoFiles = {
                "simple.txt", "encoded.txt", "append.txt",
                "largefile.txt", "multiline.txt", "async.txt",
                "important.txt", "important_backup.txt"
            };

            Console.WriteLine("\nCleaning up demo files...");
            foreach (string file in demoFiles)
            {
                if (File.Exists(file))
                {
                    File.Delete(file);
                    Console.WriteLine($"Deleted: {file}");
                }
            }
        }
    }
}
Code sourcecsharpSimple

Opérations de Copie et Déplacement de Fichiers

Opérations de copie, déplacement et renommage de fichiers avec gestion d'erreurs

Difficulté

3/10

Temps estimé

20 min

Étiquettes

csharp, file, copy, move, windows

Prérequis

Basic C# file operations, Path manipulation

csharp
using System;
using System.IO;

class FileCopyMoveOperations
{
    // 1. Simple file copy
    public static void SimpleFileCopy()
    {
        string sourceFile = "source.txt";
        string destinationFile = "copy.txt";

        // Create source file
        File.WriteAllText(sourceFile, "This file will be copied");
        Console.WriteLine($"Created source file: {sourceFile}");

        // Copy file
        File.Copy(sourceFile, destinationFile);
        Console.WriteLine($"File copied to: {destinationFile}");

        // Verify copy
        if (File.Exists(destinationFile))
        {
            Console.WriteLine("Copy verified successfully");
        }
    }

    // 2. File copy with overwrite
    public static void FileCopyWithOverwrite()
    {
        string sourceFile = "source.txt";
        string destinationFile = "overwrite.txt";

        // Create initial destination file
        File.WriteAllText(destinationFile, "This will be overwritten");
        Console.WriteLine($"Initial content in {destinationFile}");

        // Copy with overwrite
        File.Copy(sourceFile, destinationFile, true);
        Console.WriteLine($"File copied with overwrite to: {destinationFile}");
    }

    // 3. Safe file copy with error handling
    public static bool SafeFileCopy(string source, string destination, bool overwrite = false)
    {
        try
        {
            // Check if source exists
            if (!File.Exists(source))
            {
                Console.WriteLine($"Error: Source file '{source}' does not exist");
                return false;
            }

            // Check if destination exists and overwrite is false
            if (File.Exists(destination) && !overwrite)
            {
                Console.WriteLine($"Warning: Destination file '{destination}' already exists. Use overwrite=true to replace.");
                return false;
            }

            // Perform copy
            File.Copy(source, destination, overwrite);
            Console.WriteLine($"Successfully copied '{source}' to '{destination}'");
            return true;
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine("Error: Access denied. Check file permissions.");
            return false;
        }
        catch (DirectoryNotFoundException)
        {
            Console.WriteLine("Error: Directory not found.");
            return false;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error copying file: {ex.Message}");
            return false;
        }
    }

    // 4. Simple file move
    public static void SimpleFileMove()
    {
        string sourceFile = "move_source.txt";
        string destinationFile = "moved.txt";

        // Create source file
        File.WriteAllText(sourceFile, "This file will be moved");
        Console.WriteLine($"Created source file: {sourceFile}");

        // Move file
        File.Move(sourceFile, destinationFile);
        Console.WriteLine($"File moved to: {destinationFile}");

        // Verify move
        if (!File.Exists(sourceFile) && File.Exists(destinationFile))
        {
            Console.WriteLine("Move verified successfully");
        }
    }

    // 5. File rename (using Move)
    public static void FileRename()
    {
        string oldName = "old_name.txt";
        string newName = "new_name.txt";

        // Create file with old name
        File.WriteAllText(oldName, "File content for rename test");
        Console.WriteLine($"Created file: {oldName}");

        // Rename using Move
        File.Move(oldName, newName);
        Console.WriteLine($"File renamed to: {newName}");
    }

    // 6. Batch file operations
    public static void BatchFileOperations()
    {
        // Create multiple files
        for (int i = 1; i <= 5; i++)
        {
            string fileName = $"batch_{i}.txt";
            File.WriteAllText(fileName, $"Content of file {i}");
        }
        Console.WriteLine("Created 5 batch files");

        // Create directory and move files
        string batchDir = "batch_files";
        Directory.CreateDirectory(batchDir);
        Console.WriteLine($"Created directory: {batchDir}");

        // Move all batch files to directory
        for (int i = 1; i <= 5; i++)
        {
            string sourceFile = $"batch_{i}.txt";
            string destinationFile = Path.Combine(batchDir, $"batch_{i}.txt");

            if (File.Exists(sourceFile))
            {
                File.Move(sourceFile, destinationFile);
                Console.WriteLine($"Moved {sourceFile} to {destinationFile}");
            }
        }
    }

    // 7. File backup with timestamp
    public static void CreateBackupWithTimestamp(string sourceFile)
    {
        if (!File.Exists(sourceFile))
        {
            Console.WriteLine($"Source file '{sourceFile}' not found");
            return;
        }

        // Create backup filename with timestamp
        string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
        string backupFile = $"{Path.GetFileNameWithoutExtension(sourceFile)}_{timestamp}{Path.GetExtension(sourceFile)}";

        File.Copy(sourceFile, backupFile);
        Console.WriteLine($"Backup created: {backupFile}");
    }

    // 8. Directory copy
    public static void CopyDirectory(string sourceDir, string destDir)
    {
        try
        {
            // Get the subdirectories for the specified directory.
            DirectoryInfo dir = new DirectoryInfo(sourceDir);

            if (!dir.Exists)
            {
                Console.WriteLine($"Source directory does not exist: {sourceDir}");
                return;
            }

            // If the destination directory doesn't exist, create it.
            if (!Directory.Exists(destDir))
            {
                Directory.CreateDirectory(destDir);
            }

            // Get the files in the directory and copy them to the new location.
            FileInfo[] files = dir.GetFiles();
            foreach (FileInfo file in files)
            {
                string temppath = Path.Combine(destDir, file.Name);
                file.CopyTo(temppath, false);
                Console.WriteLine($"Copied file: {file.Name}");
            }

            // Copy subdirectories
            DirectoryInfo[] dirs = dir.GetDirectories();
            foreach (DirectoryInfo subdir in dirs)
            {
                string temppath = Path.Combine(destDir, subdir.Name);
                CopyDirectory(subdir.FullName, temppath);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error copying directory: {ex.Message}");
        }
    }

    // 9. Safe file move with validation
    public static bool SafeFileMove(string source, string destination)
    {
        try
        {
            // Validate source
            if (!File.Exists(source))
            {
                Console.WriteLine($"Error: Source file '{source}' does not exist");
                return false;
            }

            // Check if destination exists
            if (File.Exists(destination))
            {
                Console.WriteLine($"Warning: Destination file '{destination}' already exists");
                return false;
            }

            // Ensure destination directory exists
            string destDir = Path.GetDirectoryName(destination);
            if (!string.IsNullOrEmpty(destDir) && !Directory.Exists(destDir))
            {
                Directory.CreateDirectory(destDir);
                Console.WriteLine($"Created destination directory: {destDir}");
            }

            // Move file
            File.Move(source, destination);
            Console.WriteLine($"Successfully moved '{source}' to '{destination}'");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error moving file: {ex.Message}");
            return false;
        }
    }

    // 10. File operations with progress (for large files)
    public static void CopyWithProgress(string sourceFile, string destinationFile)
    {
        try
        {
            using (FileStream source = new FileStream(sourceFile, FileMode.Open))
            using (FileStream destination = new FileStream(destinationFile, FileMode.Create))
            {
                byte[] buffer = new byte[1024 * 1024]; // 1MB buffer
                long totalBytes = source.Length;
                long totalRead = 0;
                int bytesRead;

                Console.WriteLine($"Copying {totalBytes:N0} bytes...");

                while ((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0)
                {
                    destination.Write(buffer, 0, bytesRead);
                    totalRead += bytesRead;

                    // Show progress
                    double progress = (double)totalRead / totalBytes * 100;
                    Console.Write($"\rProgress: {progress:F1}% ({totalRead:N0} / {totalBytes:N0} bytes)");
                }

                Console.WriteLine("\nCopy completed successfully!");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"\nError during copy: {ex.Message}");
        }
    }

    static async Task Main(string[] args)
    {
        Console.WriteLine("=== C# File Copy and Move Operations Demo ===\n");

        try
        {
            // Basic operations
            Console.WriteLine("=== Basic File Operations ===");
            SimpleFileCopy();
            FileCopyWithOverwrite();
            SimpleFileMove();
            FileRename();

            Console.WriteLine("\n=== Safe Operations ===");
            SafeFileCopy("source.txt", "safe_copy.txt");
            SafeFileMove("moved.txt", "safe_moved.txt");

            Console.WriteLine("\n=== Batch Operations ===");
            BatchFileOperations();

            Console.WriteLine("\n=== Backup Operations ===");
            CreateBackupWithTimestamp("copy.txt");

            Console.WriteLine("\n=== Directory Operations ===");
            Directory.CreateDirectory("test_dir");
            File.WriteAllText("test_dir\file1.txt", "File 1 content");
            File.WriteAllText("test_dir\file2.txt", "File 2 content");
            CopyDirectory("test_dir", "test_dir_backup");

            Console.WriteLine("\nAll operations completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
        finally
        {
            // Cleanup
            Console.WriteLine("\nCleaning up...");
            string[] filesToClean = {
                "source.txt", "copy.txt", "overwrite.txt", "moved.txt", "new_name.txt",
                "safe_copy.txt", "safe_moved.txt", "important.txt", "important_backup.txt"
            };

            foreach (string file in filesToClean)
            {
                if (File.Exists(file))
                {
                    File.Delete(file);
                    Console.WriteLine($"Deleted: {file}");
                }
            }

            string[] dirsToClean = { "batch_files", "test_dir", "test_dir_backup" };
            foreach (string dir in dirsToClean)
            {
                if (Directory.Exists(dir))
                {
                    Directory.Delete(dir, true);
                    Console.WriteLine($"Deleted directory: {dir}");
                }
            }
        }
    }
}
Code sourcecsharpIntermédiaire

Parcours de Répertoires et Listage de Fichiers

Techniques de parcours de répertoires pour obtenir listes de fichiers, structures de dossiers et opérations récursives

Difficulté

5/10

Temps estimé

25 min

Étiquettes

csharp, directory, filesystem, search, recursive

Prérequis

C# file operations, LINQ basics, Recursion

csharp
using System;
using System.IO;
using System.Collections.Generic;

class DirectoryTraversal
{
    // 1. Get files in current directory
    public static void GetCurrentDirectoryFiles()
    {
        string currentDir = Directory.GetCurrentDirectory();
        Console.WriteLine($"Current directory: {currentDir}");

        string[] files = Directory.GetFiles(currentDir);
        Console.WriteLine($"Files in current directory ({files.Length} files):");

        foreach (string file in files)
        {
            FileInfo fileInfo = new FileInfo(file);
            Console.WriteLine($"  {fileInfo.Name} - {fileInfo.Length:N0} bytes");
        }
    }

    // 2. Get directories in current directory
    public static void GetCurrentDirectorySubdirs()
    {
        string currentDir = Directory.GetCurrentDirectory();
        string[] directories = Directory.GetDirectories(currentDir);

        Console.WriteLine($"Subdirectories in current directory ({directories.Length} directories):");

        foreach (string dir in directories)
        {
            DirectoryInfo dirInfo = new DirectoryInfo(dir);
            Console.WriteLine($"  {dirInfo.Name}");
        }
    }

    // 3. Get files with specific pattern
    public static void GetFilesByPattern(string pattern = "*.txt")
    {
        string currentDir = Directory.GetCurrentDirectory();
        string[] files = Directory.GetFiles(currentDir, pattern);

        Console.WriteLine($"Files matching '{pattern}' ({files.Length} files):");

        foreach (string file in files)
        {
            Console.WriteLine($"  {Path.GetFileName(file)}");
        }
    }

    // 4. Recursive directory traversal
    public static void RecursiveDirectoryTraversal(string rootPath, string indent = "")
    {
        try
        {
            // Get all files in current directory
            string[] files = Directory.GetFiles(rootPath);
            foreach (string file in files)
            {
                FileInfo fileInfo = new FileInfo(file);
                Console.WriteLine($"{indent}📄 {fileInfo.Name} ({fileInfo.Length:N0} bytes)");
            }

            // Get all subdirectories
            string[] directories = Directory.GetDirectories(rootPath);
            foreach (string dir in directories)
            {
                DirectoryInfo dirInfo = new DirectoryInfo(dir);
                Console.WriteLine($"{indent}📁 {dirInfo.Name}/");

                // Recursively traverse subdirectory
                RecursiveDirectoryTraversal(dir, indent + "  ");
            }
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine($"{indent}🔒 Access denied");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"{indent}❌ Error: {ex.Message}");
        }
    }

    // 5. Get directory size
    public static long GetDirectorySize(string path)
    {
        long size = 0;

        try
        {
            // Add file sizes
            string[] files = Directory.GetFiles(path, "*", SearchOption.AllDirectories);
            foreach (string file in files)
            {
                size += new FileInfo(file).Length;
            }
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine($"Access denied to some files in {path}");
        }

        return size;
    }

    // 6. List files by size
    public static void ListFilesBySize(string path)
    {
        List<FileInfo> files = new List<FileInfo>();

        try
        {
            // Get all files in directory and subdirectories
            string[] filePaths = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories);

            foreach (string filePath in filePaths)
            {
                files.Add(new FileInfo(filePath));
            }

            // Sort by size (descending)
            files.Sort((a, b) => b.Length.CompareTo(a.Length));

            Console.WriteLine($"Files in {path} sorted by size:");
            Console.WriteLine("Size".PadRight(15) + "File");
            Console.WriteLine("".PadRight(50, '-'));

            foreach (FileInfo file in files.Take(20)) // Show top 20
            {
                Console.WriteLine($"{FormatFileSize(file.Length).PadRight(15)}{file.Name}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error listing files by size: {ex.Message}");
        }
    }

    // 7. Find recently modified files
    public static void FindRecentlyModifiedFiles(string path, TimeSpan timeSpan)
    {
        DateTime cutoffTime = DateTime.Now - timeSpan;
        List<FileInfo> recentFiles = new List<FileInfo>();

        try
        {
            string[] filePaths = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories);

            foreach (string filePath in filePaths)
            {
                FileInfo file = new FileInfo(filePath);
                if (file.LastWriteTime >= cutoffTime)
                {
                    recentFiles.Add(file);
                }
            }

            Console.WriteLine($"Files modified in the last {timeSpan.TotalHours:F1} hours:");

            foreach (FileInfo file in recentFiles.OrderByDescending(f => f.LastWriteTime))
            {
                Console.WriteLine($"{file.LastWriteTime:yyyy-MM-dd HH:mm:ss} - {file.FullName}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error finding recently modified files: {ex.Message}");
        }
    }

    // 8. Find duplicate files by size
    public static Dictionary<long, List<FileInfo>> FindDuplicateFiles(string path)
    {
        Dictionary<long, List<FileInfo>> sizeGroups = new Dictionary<long, List<FileInfo>>();

        try
        {
            string[] filePaths = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories);

            // Group files by size
            foreach (string filePath in filePaths)
            {
                FileInfo file = new FileInfo(filePath);
                long size = file.Length;

                if (!sizeGroups.ContainsKey(size))
                {
                    sizeGroups[size] = new List<FileInfo>();
                }
                sizeGroups[size].Add(file);
            }

            // Filter groups with more than one file (potential duplicates)
            var duplicates = sizeGroups.Where(kvp => kvp.Value.Count > 1)
                                     .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

            Console.WriteLine("Potential duplicate files (same size):");

            foreach (var group in duplicates)
            {
                if (group.Value.Count > 1)
                {
                    Console.WriteLine($"\nSize: {FormatFileSize(group.Key)} ({group.Value.Count} files)");
                    foreach (FileInfo file in group.Value)
                    {
                        Console.WriteLine($"  {file.FullName}");
                    }
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error finding duplicate files: {ex.Message}");
        }

        return sizeGroups;
    }

    // 9. Create directory tree structure
    public static void CreateDirectoryTree(string path, int maxDepth = 3, int currentDepth = 0)
    {
        if (currentDepth >= maxDepth) return;

        try
        {
            string indent = new string(' ', currentDepth * 2);

            // Show current directory
            DirectoryInfo dirInfo = new DirectoryInfo(path);
            Console.WriteLine($"{indent}📁 {dirInfo.Name}/");

            // Show files in current directory
            string[] files = Directory.GetFiles(path);
            foreach (string file in files)
            {
                FileInfo fileInfo = new FileInfo(file);
                Console.WriteLine($"{indent}  📄 {fileInfo.Name}");
            }

            // Recursively show subdirectories
            string[] directories = Directory.GetDirectories(path);
            foreach (string subdir in directories)
            {
                CreateDirectoryTree(subdir, maxDepth, currentDepth + 1);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error accessing {path}: {ex.Message}");
        }
    }

    // 10. File search by content
    public static List<FileInfo> SearchFilesByContent(string path, string searchTerm, string filePattern = "*.txt")
    {
        List<FileInfo> matchingFiles = new List<FileInfo>();

        try
        {
            string[] files = Directory.GetFiles(path, filePattern, SearchOption.AllDirectories);

            Console.WriteLine($"Searching for '{searchTerm}' in {files.Length} files...");

            foreach (string filePath in files)
            {
                try
                {
                    string[] lines = File.ReadAllLines(filePath);

                    for (int i = 0; i < lines.Length; i++)
                    {
                        if (lines[i].Contains(searchTerm, StringComparison.OrdinalIgnoreCase))
                        {
                            matchingFiles.Add(new FileInfo(filePath));
                            Console.WriteLine($"Found in {filePath} at line {i + 1}");
                            break; // Only report each file once
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error reading {filePath}: {ex.Message}");
                }
            }

            Console.WriteLine($"Found {matchingFiles.Count} files containing '{searchTerm}'");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error searching files: {ex.Message}");
        }

        return matchingFiles;
    }

    // Helper method to format file size
    public static string FormatFileSize(long bytes)
    {
        string[] sizes = { "B", "KB", "MB", "GB", "TB" };
        int order = 0;
        double size = bytes;

        while (size >= 1024 && order < sizes.Length - 1)
        {
            order++;
            size /= 1024;
        }

        return $"{size:F2} {sizes[order]}";
    }

    static void Main(string[] args)
    {
        Console.WriteLine("=== C# Directory Traversal Demo ===\n");

        try
        {
            string currentDir = Directory.GetCurrentDirectory();

            Console.WriteLine("=== Current Directory Info ===");
            GetCurrentDirectoryFiles();
            Console.WriteLine();
            GetCurrentDirectorySubdirs();

            Console.WriteLine("\n=== Pattern Search ===");
            GetFilesByPattern("*.cs");
            GetFilesByPattern("*.exe");

            Console.WriteLine("\n=== Directory Tree (limited depth) ===");
            CreateDirectoryTree(currentDir, 2);

            Console.WriteLine("\n=== Directory Statistics ===");
            long totalSize = GetDirectorySize(currentDir);
            Console.WriteLine($"Total directory size: {FormatFileSize(totalSize)}");

            Console.WriteLine("\n=== Files by Size (top 10) ===");
            ListFilesBySize(currentDir);

            Console.WriteLine("\n=== Recently Modified Files (last 24 hours) ===");
            FindRecentlyModifiedFiles(currentDir, TimeSpan.FromHours(24));

            Console.WriteLine("\n=== Potential Duplicate Files ===");
            FindDuplicateFiles(currentDir);

            Console.WriteLine("\n=== Content Search Demo ===");
            // Create some test files for content search
            File.WriteAllText("test1.txt", "This file contains the word demo");
            File.WriteAllText("test2.txt", "Another file with demo content");
            File.WriteAllText("test3.txt", "File without the target word");

            SearchFilesByContent(currentDir, "demo", "*.txt");

            // Cleanup test files
            File.Delete("test1.txt");
            File.Delete("test2.txt");
            File.Delete("test3.txt");

            Console.WriteLine("\nDirectory traversal operations completed!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}
Code sourcecsharpSimple

Validation et Informations de Fichiers

Vérifier existence de fichiers, obtenir propriétés, valider formats et surveiller modifications

Difficulté

4/10

Temps estimé

20 min

Étiquettes

csharp, file, validation, security, monitoring

Prérequis

C# file operations, Hash algorithms, File attributes

csharp
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

class FileValidation
{
    // 1. Check if file exists
    public static bool CheckFileExists(string filePath)
    {
        bool exists = File.Exists(filePath);
        Console.WriteLine($"File '{filePath}' exists: {exists}");
        return exists;
    }

    // 2. Get basic file information
    public static void GetFileInfo(string filePath)
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"File '{filePath}' does not exist");
            return;
        }

        FileInfo fileInfo = new FileInfo(filePath);

        Console.WriteLine($"=== File Information for: {fileInfo.Name} ===");
        Console.WriteLine($"Full Path: {fileInfo.FullName}");
        Console.WriteLine($"Size: {FormatFileSize(fileInfo.Length)} bytes");
        Console.WriteLine($"Created: {fileInfo.CreationTime:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Modified: {fileInfo.LastWriteTime:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Accessed: {fileInfo.LastAccessTime:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Attributes: {fileInfo.Attributes}");
        Console.WriteLine($"Extension: {fileInfo.Extension}");
        Console.WriteLine($"Directory: {fileInfo.DirectoryName}");
    }

    // 3. Check file permissions
    public static void CheckFilePermissions(string filePath)
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"File '{filePath}' does not exist");
            return;
        }

        try
        {
            // Test read permission
            using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                Console.WriteLine("✓ Read permission: Allowed");
            }

            // Test write permission
            using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Write))
            {
                Console.WriteLine("✓ Write permission: Allowed");
            }
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine("✗ Access denied - insufficient permissions");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"✗ Error checking permissions: {ex.Message}");
        }
    }

    // 4. Validate file extension
    public static bool IsValidFileExtension(string filePath, string[] allowedExtensions)
    {
        string extension = Path.GetExtension(filePath).ToLowerInvariant();

        bool isValid = allowedExtensions.Contains(extension);
        Console.WriteLine($"File '{filePath}' extension '{extension}' is valid: {isValid}");

        if (!isValid)
        {
            Console.WriteLine($"Allowed extensions: {string.Join(", ", allowedExtensions)}");
        }

        return isValid;
    }

    // 5. Check file size limits
    public static bool ValidateFileSize(string filePath, long maxSizeBytes, long minSizeBytes = 0)
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"File '{filePath}' does not exist");
            return false;
        }

        FileInfo fileInfo = new FileInfo(filePath);
        long fileSize = fileInfo.Length;

        bool isWithinLimits = fileSize >= minSizeBytes && fileSize <= maxSizeBytes;

        Console.WriteLine($"File size: {FormatFileSize(fileSize)}");
        Console.WriteLine($"Size limits: {FormatFileSize(minSizeBytes)} - {FormatFileSize(maxSizeBytes)}");
        Console.WriteLine($"File size is within limits: {isWithinLimits}");

        return isWithinLimits;
    }

    // 6. Calculate file hash for integrity check
    public static string CalculateFileHash(string filePath, string algorithm = "MD5")
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"File '{filePath}' does not exist");
            return null;
        }

        try
        {
            using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                HashAlgorithm hashAlgorithm;

                switch (algorithm.ToUpper())
                {
                    case "SHA1":
                        hashAlgorithm = SHA1.Create();
                        break;
                    case "SHA256":
                        hashAlgorithm = SHA256.Create();
                        break;
                    case "SHA384":
                        hashAlgorithm = SHA384.Create();
                        break;
                    case "SHA512":
                        hashAlgorithm = SHA512.Create();
                        break;
                    default:
                        hashAlgorithm = MD5.Create();
                        break;
                }

                byte[] hashBytes = hashAlgorithm.ComputeHash(stream);
                string hashString = BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();

                Console.WriteLine($"File '{Path.GetFileName(filePath)}' {algorithm} hash: {hashString}");
                return hashString;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error calculating file hash: {ex.Message}");
            return null;
        }
    }

    // 7. Verify file integrity
    public static bool VerifyFileIntegrity(string filePath, string expectedHash, string algorithm = "MD5")
    {
        string actualHash = CalculateFileHash(filePath, algorithm);

        if (actualHash == null)
        {
            return false;
        }

        bool isValid = actualHash.Equals(expectedHash, StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"File integrity check: {(isValid ? "✓ PASSED" : "✗ FAILED")}");

        if (!isValid)
        {
            Console.WriteLine($"Expected: {expectedHash}");
            Console.WriteLine($"Actual:   {actualHash}");
        }

        return isValid;
    }

    // 8. Check if file is in use
    public static bool IsFileInUse(string filePath)
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"File '{filePath}' does not exist");
            return false;
        }

        try
        {
            using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
            {
                // If we can open the file with no sharing, it's not in use
                stream.Close();
            }
            Console.WriteLine($"File '{Path.GetFileName(filePath)}' is not in use");
            return false;
        }
        catch (IOException)
        {
            Console.WriteLine($"File '{Path.GetFileName(filePath)}' is in use by another process");
            return true;
        }
    }

    // 9. Validate text file encoding
    public static void DetectTextFileEncoding(string filePath)
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"File '{filePath}' does not exist");
            return;
        }

        try
        {
            // Read file bytes
            byte[] buffer = new byte[4];
            using (var file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                file.Read(buffer, 0, 4);
            }

            // Check for BOM (Byte Order Mark)
            if (buffer[0] == 0xEF && buffer[1] == 0xBB && buffer[2] == 0xBF)
            {
                Console.WriteLine("File encoding: UTF-8 (with BOM)");
            }
            else if (buffer[0] == 0xFF && buffer[1] == 0xFE)
            {
                Console.WriteLine("File encoding: UTF-16 LE (with BOM)");
            }
            else if (buffer[0] == 0xFE && buffer[1] == 0xFF)
            {
                Console.WriteLine("File encoding: UTF-16 BE (with BOM)");
            }
            else
            {
                Console.WriteLine("File encoding: Unknown or ASCII (no BOM detected)");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error detecting file encoding: {ex.Message}");
        }
    }

    // 10. Validate image file header
    public static bool ValidateImageFile(string filePath)
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"File '{filePath}' does not exist");
            return false;
        }

        try
        {
            using (var file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                byte[] header = new byte[8];
                file.Read(header, 0, 8);

                // Check common image file signatures
                if (header[0] == 0xFF && header[1] == 0xD8 && header[2] == 0xFF)
                {
                    Console.WriteLine("Valid JPEG image detected");
                    return true;
                }
                else if (header[0] == 0x89 && header[1] == 0x50 && header[2] == 0x4E && header[3] == 0x47)
                {
                    Console.WriteLine("Valid PNG image detected");
                    return true;
                }
                else if (header[0] == 0x47 && header[1] == 0x49 && header[2] == 0x46)
                {
                    Console.WriteLine("Valid GIF image detected");
                    return true;
                }
                else if (header[0] == 0x42 && header[1] == 0x4D)
                {
                    Console.WriteLine("Valid BMP image detected");
                    return true;
                }
                else
                {
                    Console.WriteLine("Not a valid image file format");
                    return false;
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error validating image file: {ex.Message}");
            return false;
        }
    }

    // 11. Monitor file changes
    public static void MonitorFileChanges(string filePath)
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"File '{filePath}' does not exist");
            return;
        }

        string directory = Path.GetDirectoryName(filePath);
        string fileName = Path.GetFileName(filePath);

        using (FileSystemWatcher watcher = new FileSystemWatcher(directory))
        {
            watcher.Filter = fileName;

            watcher.Changed += (sender, e) =>
            {
                Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] File changed: {e.FullPath}");
            };

            watcher.Deleted += (sender, e) =>
            {
                Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] File deleted: {e.FullPath}");
            };

            watcher.Renamed += (sender, e) =>
            {
                Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] File renamed from {e.OldName} to {e.Name}");
            };

            watcher.EnableRaisingEvents = true;
            Console.WriteLine($"Monitoring changes to: {filePath}");
            Console.WriteLine("Press Enter to stop monitoring...");

            Console.ReadLine();
        }
    }

    // Helper method to format file size
    public static string FormatFileSize(long bytes)
    {
        string[] sizes = { "B", "KB", "MB", "GB", "TB" };
        int order = 0;
        double size = bytes;

        while (size >= 1024 && order < sizes.Length - 1)
        {
            order++;
            size /= 1024;
        }

        return $"{size:F2} {sizes[order]}";
    }

    static void Main(string[] args)
    {
        Console.WriteLine("=== C# File Validation Demo ===\n");

        try
        {
            // Create test files for demonstration
            File.WriteAllText("test.txt", "This is a test file for validation");
            File.WriteAllText("large_file.txt", new string('A', 10000)); // 10KB file

            Console.WriteLine("=== File Existence Check ===");
            CheckFileExists("test.txt");
            CheckFileExists("nonexistent.txt");

            Console.WriteLine("\n=== File Information ===");
            GetFileInfo("test.txt");

            Console.WriteLine("\n=== File Permissions ===");
            CheckFilePermissions("test.txt");

            Console.WriteLine("\n=== File Extension Validation ===");
            string[] allowedExtensions = { ".txt", ".csv", ".json", ".xml" };
            IsValidFileExtension("test.txt", allowedExtensions);
            IsValidFileExtension("test.exe", allowedExtensions);

            Console.WriteLine("\n=== File Size Validation ===");
            ValidateFileSize("test.txt", 1000); // Max 1KB
            ValidateFileSize("large_file.txt", 20000, 5000); // 5KB-20KB

            Console.WriteLine("\n=== File Hash Calculation ===");
            string hash1 = CalculateFileHash("test.txt", "MD5");
            string hash2 = CalculateFileHash("test.txt", "SHA256");

            Console.WriteLine("\n=== File Integrity Verification ===");
            VerifyFileIntegrity("test.txt", hash1, "MD5");
            VerifyFileIntegrity("test.txt", "wronghash", "MD5");

            Console.WriteLine("\n=== File Usage Check ===");
            IsFileInUse("test.txt");

            Console.WriteLine("\n=== File Encoding Detection ===");
            DetectTextFileEncoding("test.txt");

            Console.WriteLine("\n=== File Validation Summary ===");
            Console.WriteLine("All file validation operations completed successfully!");

            // Cleanup
            File.Delete("test.txt");
            File.Delete("large_file.txt");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Outils

Outils souvent utilisés avec cet exemple

Associé

Collections d’exemples associées

Associé

Dossiers associés

Dossier

Déduire un JSON Schema depuis des exemples et des tableurs

Produisez un brouillon de JSON Schema relisible à partir d'exemples JSON représentatifs ou de lignes XLSX, puis examinez types, caractère obligatoire, valeurs nulles et anomalies avant toute adoption contractuelle.

Dossier

Outils de Comparaison de Fichiers et de Donnees

Comparez deux artefacts, choisissez la bonne branche de diff selon le format, examinez les changements structurels ou semantiques, puis terminez par une verification d'integrite lorsque l'acceptation exige une certitude au niveau des octets.

Dossier

Workflow de chiffrement et de permissions des documents

Chiffrez des fichiers et des champs ciblés, ouvrez des PDF chiffrés avec des identifiants autorisés, gérez les permissions et vérifiez réversibilité et compatibilité.

Dossier

Paquetage AGEX et remise sécurisée de fichiers

Créez un paquet AGEX, examinez ses métadonnées visibles, choisissez la protection et la signature, puis vérifiez la remise avant le partage.

Accueil
Outils3208
Exemples593
Visualisations469
Visionneuses de fichiers103
Dossiers237
Étiquettes333
Images, audio et vidéo657

Outils de traitement, conversion et optimisation d’images, d’audio et de vidéo

Maths, dates et finance646

Calculateurs, outils numériques, logique de dates, statistiques et finance

Design et couleur298

Outils de couleur, mise en page, graphisme, style visuel et assistance design

Texte et rédaction209

Outils de rédaction, nettoyage, formatage, extraction et analyse de texte

Développement et Web193

Utilitaires développeur, réseau, débogage Web et assistants d’automatisation

Conversion et encodage175

Outils de conversion de formats, fichiers, archives, unités et encodages

Habitudes privées : sauvegarde, restauration et partage vérifié
D’un article aux brouillons X et LinkedIn : revue factuelle et livraison
Revue de cours Markdown interactif et livraison hors ligne
Revue d’aménagement d’une petite pièce et dossier d’emménagement
Examen des sources FLAC/WAV et transmission des preuves

© 2026 Elysia Tools. Tous droits réservés.

DocumentationTarifsÀ proposConditions d'utilisationPolitique de confidentialitéCookiesContact

Media

Convertisseur MOV vers MP4

Convertir les fichiers vidéo MOV au format MP4

Media

Convertisseur MP4 vers MOV

Convertir les fichiers vidéo MP4 au format MOV

Media

Remux intelligent

Ré-encapsule avec copie de flux.

Media

Convertisseur Video par Lot

Convertissez plusieurs fichiers video entre differents formats comme MP4, WebM, MKV, AVI, MOV avec reglages de qualite et traitement par lot

Media

Vidéo en GIF Optimisé

Convertit les vidéos en format GIF optimisé avec des paramètres de compression avancés

Media

Coupure Vidéo

Couper et recadrer des clips vidéo avec précision, supportant plusieurs formats et réglages de qualité

Media

Retournement Horizontal Video

Miroir gauche-droite de la video en conservant le conteneur d'origine et l'audio si possible

Media

Extracteur de Flux Video

Detecte les flux puis extrait audio, video sans audio ou les deux sans transcodage

C++

Opérations Fichiers Windows - Exemples C++

Exemples complets d'opérations fichiers en C++ pour plateforme Windows incluant E/S texte, copie fichiers et parcours répertoires

Java

Exemples d'Opérations sur Fichiers Android Java

Exemples d'opérations sur fichiers Android Java incluant lecture/écriture de fichiers texte, copier/déplacer, parcours de répertoires et validation de fichiers

Kotlin

Exemples d'Opérations sur Fichiers Android Kotlin

Exemples d'opérations sur fichiers Android Kotlin incluant lecture/écriture de fichiers texte, copier/déplacer, parcours de répertoires et validation de fichiers

Objective-C

Exemples d'Opérations sur Fichiers macOS Objective-C

Exemples d'opérations sur fichiers macOS Objective-C incluant lecture/écriture de fichiers texte, copier/déplacer, parcours de répertoires et validation de fichiers

Swift

Exemples d'Opérations sur Fichiers macOS Swift

Exemples d'opérations sur fichiers macOS Swift incluant lecture/écriture de fichiers texte, copier/déplacer, parcours de répertoires et validation de fichiers

Traitement de texte

Exemples de Remplacement Regex

Collection de modèles de remplacement regex courants et utiles pour la transformation de texte et le nettoyage de données