C# File I/O — Missing `using` Locked Production API

using System;
using System.IO;

class FileLayersDemo
{
    static void Main()
    {
        string filePath = "sample_log.txt";

        // --- LAYER 3: File class (convenience, small files) ---
        // Writes all content in one shot. File is opened and closed automatically.
        File.WriteAllText(filePath, "Line one\nLine two\nLine three\n");

        // Reads entire file into a single string — fine for small config files
        string entireContent = File.ReadAllText(filePath);
        Console.WriteLine("[File.ReadAllText output]");
        Console.WriteLine(entireContent);

        // --- LAYER 2: StreamReader (line-by-line, memory-efficient) ---
        // 'using' ensures the stream is closed even if an exception is thrown
        Console.WriteLine("[StreamReader line-by-line output]");
        using (StreamReader reader = new StreamReader(filePath))
        {
            string? currentLine;
            int lineNumber = 1;

            // ReadLine returns null when there are no more lines
            while ((currentLine = reader.ReadLine()) != null)
            {
                Console.WriteLine($"  Line {lineNumber++}: {currentLine}");
            }
        } // stream is guaranteed closed here

        // --- LAYER 1: FileStream (raw bytes, binary data) ---
        Console.WriteLine("\n[FileStream byte count]");
        using (FileStream rawStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        {
            // Length gives total byte count — useful for binary files
            Console.WriteLine($"  File size in bytes: {rawStream.Length}");
        }
    }
}

using System;
using System.IO;
using System.Threading.Tasks;

class AsyncFileOperations
{
    // Simulates writing an application log entry asynchronously
    static async Task WriteLogEntryAsync(string logFilePath, string message)
    {
        // File.AppendAllTextAsync opens, appends, and closes — no stream management needed
        // The thread is released back to the pool while the OS handles the disk write
        string timestampedEntry = $"[{DateTime.UtcNow:yyyy-MM-dd HH:mm:ss}] {message}{Environment.NewLine}";
        await File.AppendAllTextAsync(logFilePath, timestampedEntry);
    }

    // Reads a potentially large report file line by line without blocking
    static async Task<int> CountMatchingLinesAsync(string reportFilePath, string searchTerm)
    {
        int matchCount = 0;

        // StreamReader with 'await using' disposes asynchronously — important for async code
        await using (StreamReader reader = new StreamReader(reportFilePath))
        {
            string? line;
            while ((line = await reader.ReadLineAsync()) != null)
            {
                // Case-insensitive search — realistic for log analysis
                if (line.Contains(searchTerm, StringComparison.OrdinalIgnoreCase))
                {
                    matchCount++;
                }
            }
        }

        return matchCount;
    }

    static async Task Main()
    {
        string logPath = "application.log";

        // Simulate writing several log entries
        await WriteLogEntryAsync(logPath, "Application started");
        await WriteLogEntryAsync(logPath, "User login: alice@example.com");
        await WriteLogEntryAsync(logPath, "ERROR: Database connection timeout");
        await WriteLogEntryAsync(logPath, "User login: bob@example.com");
        await WriteLogEntryAsync(logPath, "ERROR: Null reference in PaymentService");

        Console.WriteLine($"Log file written to: {logPath}");

        // Count how many ERROR lines are in the log
        int errorCount = await CountMatchingLinesAsync(logPath, "ERROR");
        Console.WriteLine($"Total ERROR entries found: {errorCount}");

        // Read and display the full log to confirm
        string fullLog = await File.ReadAllTextAsync(logPath);
        Console.WriteLine("\n--- Full Log Contents ---");
        Console.WriteLine(fullLog);
    }
}

using System;
using System.IO;
using System.Threading;

class DefensiveFileIO
{
    // Uses Path.Combine — works on Windows (\) and Linux (/) without changes
    static string BuildReportPath(string baseDirectory, string reportName)
    {
        return Path.Combine(baseDirectory, "reports", $"{reportName}.txt");
    }

    // Ensures the directory exists before writing — safe to call multiple times
    static void EnsureDirectoryExists(string filePath)
    {
        string? directory = Path.GetDirectoryName(filePath);
        if (!string.IsNullOrEmpty(directory))
        {
            // CreateDirectory does nothing if directory already exists — no need to check first
            Directory.CreateDirectory(directory);
        }
    }

    // Retries on IOException (file lock) with exponential back-off
    static string ReadWithRetry(string filePath, int maxAttempts = 3)
    {
        for (int attempt = 1; attempt <= maxAttempts; attempt++)
        {
            try
            {
                return File.ReadAllText(filePath);
            }
            catch (FileNotFoundException)
            {
                // No point retrying — file genuinely doesn't exist
                throw;
            }
            catch (IOException ex) when (attempt < maxAttempts)
            {
                // File is locked by another process — wait and retry
                int delayMs = 100 * (int)Math.Pow(2, attempt); // 200ms, 400ms
                Console.WriteLine($"  File locked (attempt {attempt}), retrying in {delayMs}ms: {ex.Message}");
                Thread.Sleep(delayMs);
            }
        }
        throw new IOException($"Could not read '{filePath}' after {maxAttempts} attempts.");
    }

    static void Main()
    {
        string reportPath = BuildReportPath(AppDomain.CurrentDomain.BaseDirectory, "monthly_summary");
        Console.WriteLine($"Target path: {reportPath}");

        // Safe write — creates all missing directories automatically
        EnsureDirectoryExists(reportPath);
        File.WriteAllText(reportPath, "Monthly Revenue: $142,500\nNew Users: 3,421\n");
        Console.WriteLine("Report written successfully.");

        // Safe read with retry
        try
        {
            string reportContent = ReadWithRetry(reportPath);
            Console.WriteLine("\n--- Report Contents ---");
            Console.WriteLine(reportContent);
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("ERROR: Report file not found. Generate the report first.");
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine("ERROR: No permission to read report. Check file permissions.");
        }

        // Demonstrate safe check before delete
        if (File.Exists(reportPath))
        {
            File.Delete(reportPath);
            Console.WriteLine("\nReport cleaned up.");
        }
    }
}

using System;
using System.IO;
using System.Text;

class CsvProcessor
{
    record ProductRecord(string Name, string Category, decimal Price, int StockLevel);

    // Streams through a CSV file line by line — memory stays flat regardless of file size
    static System.Collections.Generic.IEnumerable<ProductRecord> ReadProductCsv(string csvFilePath)
    {
        // detectEncodingFromByteOrderMarks handles UTF-8 BOM from Excel exports automatically
        using StreamReader reader = new StreamReader(csvFilePath, detectEncodingFromByteOrderMarks: true);

        // Skip the header row
        string? headerLine = reader.ReadLine();
        if (headerLine == null) yield break;

        string? dataLine;
        int rowNumber = 1;

        while ((dataLine = reader.ReadLine()) != null)
        {
            rowNumber++;
            string[] columns = dataLine.Split(',');

            // Guard against malformed rows — real CSVs have bad data
            if (columns.Length != 4)
            {
                Console.WriteLine($"  Skipping malformed row {rowNumber}: '{dataLine}'");
                continue;
            }

            if (!decimal.TryParse(columns[2], out decimal price) ||
                !int.TryParse(columns[3], out int stock))
            {
                Console.WriteLine($"  Skipping row {rowNumber} — invalid numeric data");
                continue;
            }

            yield return new ProductRecord(columns[0].Trim(), columns[1].Trim(), price, stock);
        }
    }

    // Writes filtered results using temp-file-then-rename for atomicity
    static void WriteLowStockReport(string outputCsvPath, System.Collections.Generic.IEnumerable<ProductRecord> products)
    {
        string tempPath = outputCsvPath + ".tmp";

        // AutoFlush = false — buffers writes for performance, flushed on Dispose
        using (StreamWriter writer = new StreamWriter(tempPath, append: false, encoding: new UTF8Encoding(encoderShouldEmitUTF8Identifier: true)))
        {
            writer.AutoFlush = false;
            writer.WriteLine("ProductName,Category,Price,StockLevel,StockStatus");

            foreach (ProductRecord product in products)
            {
                if (product.StockLevel < 10)
                {
                    string status = product.StockLevel == 0 ? "OUT_OF_STOCK" : "LOW_STOCK";
                    writer.WriteLine($"{product.Name},{product.Category},{product.Price:F2},{product.StockLevel},{status}");
                }
            }
        } // buffer flushed and file closed here

        // Atomic rename — if process dies during write, original file is untouched
        File.Move(tempPath, outputCsvPath, overwrite: true);
    }

    static void Main()
    {
        string inputPath = "inventory.csv";
        string outputPath = "low_stock_report.csv";

        // Create sample inventory CSV for demonstration
        File.WriteAllText(inputPath,
            "Name,Category,Price,Stock\n" +
            "Wireless Keyboard,Peripherals,49.99,23\n" +
            "USB-C Hub,Peripherals,34.95,3\n" +
            "Webcam HD,Video,89.00,0\n" +
            "Monitor Stand,Accessories,29.50,INVALID\n" +  // bad row — intentional
            "Laptop Stand,Accessories,44.99,7\n" +
            "HDMI Cable,Cables,12.99,145\n");

        Console.WriteLine("Processing inventory CSV...");
        var allProducts = ReadProductCsv(inputPath);
        WriteLowStockReport(outputPath, allProducts);

        Console.WriteLine("\n--- Low Stock Report ---");
        Console.WriteLine(File.ReadAllText(outputPath));
    }
}

using System;
using System.IO;
using System.Threading;

namespace io.thecodeforge.FileIO
{
    class ConcurrentFileAccess
    {
        private static readonly object _lock = new object();

        static void WriteToSharedLog(string logFilePath, string message)
        {
            lock (_lock)
            {
                File.AppendAllText(logFilePath, $"{DateTime.UtcNow}: {message}{Environment.NewLine}");
            }
        }

        static void Main()
        {
            string logPath = "shared.log";

            // Simulate concurrent writes from multiple threads
            Thread t1 = new Thread(() => {
                for (int i = 0; i < 5; i++)
                    WriteToSharedLog(logPath, $"Thread A - message {i}");
            });

            Thread t2 = new Thread(() => {
                for (int i = 0; i < 5; i++)
                    WriteToSharedLog(logPath, $"Thread B - message {i}");
            });

            t1.Start();
            t2.Start();
            t1.Join();
            t2.Join();

            Console.WriteLine("Shared log content:");
            Console.WriteLine(File.ReadAllText(logPath));
        }
    }
}