Opérations de Fichiers Windows - Exemples C#

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}");
                }
            }
        }
    }
}

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}");
                }
            }
        }
    }
}

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}");
        }
    }
}

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}");
        }
    }
}