Elysia Tools

Explora herramientas, ejemplos, explicaciones visuales y guías temáticas en un solo espacio claro.

Categorías populares

Temas

Idioma
ZHESPTRUFRDEEN

Elysia Tools

Navegación

C#

Archivos C#: saltos, entradas vacías y límites de lectura | Elysia Tools

Operaciones de Lectura y Escritura de Archivos de Texto. Resuelva tres ejemplos Windows C# acotados con entradas explícitas y resultados comprobables.

Ejemplos

Entradas de esta colección

CódigocsharpSimple

Operaciones de Lectura y Escritura de Archivos de Texto

Operaciones básicas de lectura y escritura de archivos de texto usando la clase File de C#

Dificultad

2/10

Tiempo estimado

15 min

Etiquetas

csharp, file, io, windows, system

Requisitos previos

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

Operaciones de Copia y Movimiento de Archivos

Operaciones de copia, movimiento y renombrado de archivos con manejo de errores

Dificultad

3/10

Tiempo estimado

20 min

Etiquetas

csharp, file, copy, move, windows

Requisitos previos

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

Recorrido de Directorios y Listado de Archivos

Técnicas de recorrido de directorios para obtener listas de archivos, estructuras de carpetas y operaciones recursivas

Dificultad

5/10

Tiempo estimado

25 min

Etiquetas

csharp, directory, filesystem, search, recursive

Requisitos previos

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

Validación e Información de Archivos

Verificar existencia de archivos, obtener propiedades, validar formatos y monitorizar cambios

Dificultad

4/10

Tiempo estimado

20 min

Etiquetas

csharp, file, validation, security, monitoring

Requisitos previos

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

Herramientas

Herramientas que suelen usarse con este ejemplo

Relacionado

Colecciones de ejemplos relacionadas

Relacionado

Temas relacionados

Guía de uso de la herramienta

Contexto para entender esta colección de ejemplos

Resumen

Use «Operaciones de Lectura y Escritura de Archivos de Texto» para los ejercicios. Siga solo el bloque indicado; otras tarjetas tratan funciones y dependencias diferentes.

Elegir el ejemplo mínimo

Solo cadenas y registros ficticios. Main crea/borra archivos: no lo invoque. Líneas lógicas no prueban bytes ni éxito I/O.

Cómo funciona

  1. 1Lea la tarjeta y siga los valores declarados. La página muestra código; no ejecuta este lenguaje.

Casos límite y errores frecuentes

  • Alcance del resultado

    Son expectativas derivadas del código, no salidas registradas de compilación o ejecución. Entrada interactiva, reloj, archivos, hilos, servicios y frameworks quedan fuera.

Ejemplos

1. Seguir AppendToFile: string literals

Cómo usarlo

En «Operaciones de Lectura y Escritura de Archivos de Texto», localice AppendToFile: string literals. Use "First line\n"+"Second line\n"+"Third line\n" y siga únicamente las operaciones indicadas en el mismo orden.

Resultado

Esperado: "First line\nSecond line\nThird line\n". Concatene cadenas en papel; se conserva salto final.

2. Seguir WriteMultipleLines: lines

Cómo usarlo

En «Operaciones de Lectura y Escritura de Archivos de Texto», localice WriteMultipleLines: lines. Use six literal array entries y siga únicamente las operaciones indicadas en el mismo orden.

Resultado

Esperado: Length=6;lines[4]="". La cadena vacía cuenta; seis elementos incluyen línea vacía.

3. Seguir ReadWithStreamReader: lineNumber / break

Cómo usarlo

En «Operaciones de Lectura y Escritura de Archivos de Texto», localice ReadWithStreamReader: lineNumber / break. Use 10 or more synthetic records;initial lineNumber=1 y siga únicamente las operaciones indicadas en el mismo orden.

Resultado

Esperado: labels1..10;lineNumber=11;break. Con diez registros ficticios: etiquetas1–10, contador11 y salida.

Tema

Verificación de firmas separadas e integridad de archivos

Calcula o reproduce el hash de un archivo conocido, compáralo con un checksum publicado y verifica una firma Ed25519 separada con una clave pública cuya confianza se confirmó por otra vía.

Tema

Simulacro de restauración de archivos de respaldo y evidencias

Define un simulacro acotado, inspecciona una copia ZIP, recupera archivos seleccionados y registra hashes de referencia, uso en aplicaciones, tiempos y fallos pendientes.

Tema

Herramientas para Comparar Diferencias de Archivos y Datos

Compara dos artefactos, elige la ruta de diff adecuada según el formato, revisa cambios estructurales o semánticos y termina con validación de integridad cuando la aprobación exige certeza a nivel de bytes.

Tema

Vista previa, extracción selectiva y conversión de archivos

Previsualiza archivos compatibles, extrae un miembro verificado y convierte el resultado.

Inicio
Herramientas3216
Ejemplos593
Visualizaciones473
Visores de archivos103
Temas239
Etiquetas333
Imágenes, audio y video657

Herramientas de procesamiento, conversión y optimización de imágenes, audio y video

Matemáticas, fechas y finanzas647

Calculadoras, herramientas numéricas, lógica de fechas, estadística y finanzas

Diseño y color298

Herramientas de color, maquetación, gráficos, estilo visual y apoyo al diseño

Texto y redacción209

Herramientas de redacción, limpieza, formato, extracción y análisis de texto

Desarrollo y Web194

Utilidades para desarrolladores, red, depuración web y automatización

Conversión y codificación175

Herramientas de conversión de formatos, archivos, unidades, archivos comprimidos y codificación

Lanzamiento de un cuestionario de captación y entrega de contactos
Textos conmemorativos: revisión familiar y entrega para impresión
Hábitos privados: copia, restauración y revisión antes de compartir
De artículo a borradores de X y LinkedIn: revisión factual y entrega
Revisión de una lección Markdown interactiva y entrega sin conexión

© 2026 Elysia Tools. Todos los derechos reservados.

DocumentaciónPreciosAcerca deTérminos de servicioPolítica de privacidadCookiesContacto

Media

Convertidor de MOV a MP4

Convierte archivos de video MOV a formato MP4

Media

Convertidor de MP4 a MOV

Convierte archivos de video MP4 a formato MOV

Media

Remux inteligente

Reenvuelve contenedores con stream copy.

Media

Conversor de Video en Lote

Convierte múltiples archivos de video entre diferentes formatos como MP4, WebM, MKV, AVI, MOV con configuración de calidad y procesamiento por lotes

Media

Video a GIF Optimizado

Convierte videos a formato GIF optimizado con configuración avanzada de compresión

Media

Cortador de Video

Cortar y recortar clips de video con precisión, soportando múltiples formatos y configuraciones de calidad

Media

Volteo Horizontal de Video

Refleja el video de izquierda a derecha, conservando formato contenedor y audio cuando sea posible

Media

Extractor de Streams de Video

Detecta streams primero y extrae audio, video sin audio o ambos sin transcodificar

C++

Operaciones de Archivos Windows - Ejemplos C++

Ejemplos completos de operaciones de archivos en C++ para plataforma Windows incluyendo E/S de texto, copia de archivos y recorrido de directorios

Java

Ejemplos de Operaciones de Archivos Android Java

Ejemplos de operaciones de archivos Android Java incluyendo lectura/escritura de archivos de texto, copiar/mover archivos, recorrido de directorios y validación de archivos

Kotlin

Ejemplos de Operaciones de Archivos Android Kotlin

Ejemplos de operaciones de archivos Android Kotlin incluyendo lectura/escritura de archivos de texto, copiar/mover archivos, recorrido de directorios y validación de archivos

Objective-C

Ejemplos de Operaciones de Archivos macOS Objective-C

Ejemplos de operaciones de archivos macOS Objective-C incluyendo lectura/escritura de archivos de texto, copiar/mover archivos, recorrido de directorios y validación de archivos

Swift

Ejemplos de Operaciones de Archivos macOS Swift

Ejemplos de operaciones de archivos macOS Swift incluyendo lectura/escritura de archivos de texto, copiar/mover archivos, recorrido de directorios y validación de archivos

Procesamiento de texto

Ejemplos de Reemplazo de Regex

Colección de patrones de reemplazo de regex comunes y útiles para transformación de texto y limpieza de datos