Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

C#

Windows File Operations - C# Samples

Comprehensive C# file operations examples for Windows platform including text file I/O, file copying, directory traversal, and file system operations

Samples

Entries inside this sample collection

CodecsharpSimple

Text File Read and Write Operations

Basic text file reading and writing operations using C# File class

Difficulty

2/10

Estimated time

15 min

Tags

csharp, file, io, windows, system

Prerequisites

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

File Copy and Move Operations

File copying, moving, and renaming operations with error handling

Difficulty

3/10

Estimated time

20 min

Tags

csharp, file, copy, move, windows

Prerequisites

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

Directory Traversal and File Listing

Directory traversal techniques to get file lists, folder structures, and recursive file operations

Difficulty

5/10

Estimated time

25 min

Tags

csharp, directory, filesystem, search, recursive

Prerequisites

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

File Validation and Information

Check file existence, get file properties, validate file formats, and monitor file changes

Difficulty

4/10

Estimated time

20 min

Tags

csharp, file, validation, security, monitoring

Prerequisites

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

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Detached Signature and File Integrity Verification

Generate or reproduce a file hash, compare it with a published checksum, and verify a detached Ed25519 signature with a separately trusted public key.

Hub

Review Dockerfile and Environment Configuration Before Release

Review Dockerfile findings, validate image references, expose duplicate environment keys and explain staging-to-production drift in one container release record.

Hub

Infer JSON Schema from Samples and Spreadsheets

Derive a reviewable JSON Schema draft from representative JSON samples or XLSX rows, then inspect types, requiredness, nulls, and outliers before treating it as a contract.

Hub

Binary Encoding, File Forensics, and Integrity Tools

Inspect bytes and signatures, identify file types, measure entropy, and verify hashes or checksums in one safe forensic workflow.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact

Media

MOV to MP4 Converter

Convert MOV video files to MP4 format

Media

MP4 to MOV Converter

Convert MP4 video files to MOV format

Media

Stream Smart Remux

Rewrap media containers with stream copy.

Media

Batch Video Converter

Convert multiple video files between different formats like MP4, WebM, MKV, AVI, MOV with quality settings and batch processing

Media

Video to GIF Optimized

Convert videos to optimized GIF format with advanced compression settings

Media

Video Cutter

Cut and trim video clips with precision, supporting multiple formats and quality settings

Media

Video Horizontal Flip

Flip video horizontally (mirror left-right) while keeping original container format and copying audio stream when possible

Media

Video Stream Extractor

Extract audio and/or video streams from a video file using stream copy (no transcoding) after probing stream availability

C++

Windows File Operations - C++ Samples

Comprehensive C++ file operations examples for Windows platform including text file I/O, file copying, and directory traversal

Java

Android File Operations Java Samples

Android Java file operations examples including text file read/write, file copy/move, directory traversal, and file validation

Kotlin

Android File Operations Kotlin Samples

Android Kotlin file operations examples including text file read/write, file copy/move, directory traversal, and file validation

Objective-C

macOS File Operations Objective-C Samples

macOS Objective-C file operations examples including text file read/write, file copy/move, directory traversal, and file validation

Swift

macOS File Operations Swift Samples

macOS Swift file operations examples including text file read/write, file copy/move, directory traversal, and file validation

Text Processing

Regex Replace Samples

Collection of common and useful regex replacement patterns for text transformation and data cleaning