Share via

Validate eol of each line of the text file

Peter_1985 2,806 Reputation points
2025-10-08T09:45:21.36+00:00

Hi,

I used the way below to validate the eol of each line. How to ensure that I have the validation (by it) against each line of the text file?

User's image

Developer technologies | C#
Developer technologies | C#
An object-oriented and type-safe programming language that has its roots in the C family of languages and includes support for component-oriented programming.

5 answers

Sort by: Most helpful
Most helpful Newest Oldest
  1. Gade Harika (INFOSYS LIMITED) 1,185 Reputation points Microsoft External Staff
    2025-10-08T11:18:51.08+00:00

    Thanks for reaching out.
    You're on the right track using regular expressions to validate the end-of-line (EOL) characters in a text file.

    To ensure you're validating each line, make sure your approach:

    Processes the entire file content as a single string.

    Uses a pattern that can detect different EOL formats (e.g., Windows \r\n, Unix \n, or legacy Mac \r).

    Iterates through all matches and checks the EOL group for each line.

    This method allows you to identify and handle inconsistent EOL characters across lines. If you're looking to normalize or report mismatches, you can extend your logic to count or log each EOL type

    Let me know if the issue persists after following these steps. I’ll be happy to assist further if needed. If the issue has been resolved, please click "Accept Answer".

  2. Viorel 124.9K Reputation points
    2025-10-09T08:25:17.3433333+00:00

    With these details:

    Normal case is that one line is with both these - \rn. Otherwise it is invalid.

    it is possible to validate the text in advance using this code:

    if( Regex.IsMatch( text, @"\r(?!\n)|(?<!\r)\n" ) )
{
   // the text contains unexpected eol
   . . .
}
else
{
   // the text is good
   . . .
}

    If it is also necessary to process the lines of the text after validation: 

    using( StringReader sr = new StringReader( text ) )
{
    string line;
    while( ( line = sr.ReadLine( ) ) != null )
    {
        // process the line
        . . .
    }
}

    Validation in advance is suitable if it is not desired to process a part of the text and then find that it contains an unexpected end-of-line.

    By the way, various combinations of \r and \n are considered valid. The StringReader accepts different formats.

    Maybe validation is not even necessary.

  3. Gade Harika (INFOSYS LIMITED) 1,185 Reputation points Microsoft External Staff
    2025-10-13T11:24:21.5766667+00:00

    Thanks for reaching out.

    The issue occurs because the two files use different EOL formats. To fix this, normalize both files to CRLF before comparing. Here’s a complete solution that:

    • Normalizes EOLs in both files.
    • Compares line by line.
    • Saves mismatches and a summary to ComparisonReport.txt.

    After running this, you’ll know if differences are only EOL-related or actual content mismatches. You can copy the full code from this link:
    https://gist.github.com

    The reason the last line is not detected is that it often has no EOL marker because the file ends there. Your regex captures an empty eol group in that case, but your switch statement doesn’t handle it.

    You can fix this by adding a case for an empty EOL and reporting it as “No EOL (possibly last line)”.
    For example:
    if (Regex.IsMatch(text, @"\r(?!\n)|(?<!\r)\n"))

    {

    Console.WriteLine("Invalid EOL detected");
```}  
**Regex** splits the file into `line` and `eol` groups.

Checks each `eol`:

   `\r\n` → OK
   
      `\n` → Missing CR
      
         `\r` → Missing LF
         
            `""` → No EOL (last line)
            
            Writes a **detailed report** to `EOL_Report.txt`.
            
            Creates a **normalized copy** with proper CRLF endings.
            
Let me know if the issue persists after following these steps. I’ll be happy to assist further if needed. If the issue has been resolved, please click "Accept Answer".
  4. AgaveJoe 30,396 Reputation points
    2025-10-18T12:49:22.1533333+00:00

    Hi @Peter_1985,

    Have you considered letting the built-in C# methods handle this? File.ReadAllLines() correctly reads files even if the last line doesn't end with a CR LF.

    For missing EOL characters between records, your parsing logic will almost certainly throw an exception when the field count is wrong. This is usually a sufficient and simpler way to validate the file's integrity. It seems like you might be adding an extra layer of validation that the framework already provides.

    The following is sample code to check if a file ends with CR LF. The sample code adds a CR LF but you can replace this code with your custom validation logic. 

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

/// <summary>
/// Provides utility methods for handling End-Of-Line (EOL) characters in files.
/// </summary>
public static class EOLManager
{
    /// <summary>
    /// Checks a text file and adds a standard EOL character sequence (like CRLF) 
    /// to the end if the last line is missing one.
    /// This version specifically checks for CR LF, but also handles standalone LF.
    /// </summary>
    /// <param name="filePath">The full path to the text file.</param>
    public static void EnsureFinalEOL(string filePath)
    {
        if (!File.Exists(filePath))
        {
            Console.WriteLine($"Error: File not found at '{filePath}'");
            return;
        }

        try
        {
            bool needsEOL = true;

            // Open the file with read access to check the last byte(s).
            using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                // If the file is empty, there's nothing to do.
                if (stream.Length == 0)
                {
                    Console.WriteLine("File is empty. No action taken.");
                    needsEOL = false;
                }
                // If file is long enough, check for the two-character EOL (CRLF).
                else if (stream.Length >= 2)
                {
                    // Seek to the last two bytes of the file.
                    stream.Seek(-2, SeekOrigin.End);

                    // Create a buffer to hold the last two bytes.
                    byte[] lastTwoBytes = new byte[2];
                    stream.Read(lastTwoBytes, 0, 2);

                    // Check if the last two characters are CR ('\r') followed by LF ('\n').
                    if (lastTwoBytes[0] == '\r' && lastTwoBytes[1] == '\n')
                    {
                        Console.WriteLine("File already ends with EOL characters (CRLF).");
                        needsEOL = false;
                    }
                }

                // If a CRLF was not found, we should still check for a standalone LF
                // to avoid adding a CRLF after an existing LF (resulting in LFCRLF).
                if (needsEOL && stream.Length >= 1)
                {
                    // Seek to the very last byte of the file.
                    stream.Seek(-1, SeekOrigin.End);

                    // Read the last byte.
                    int lastByte = stream.ReadByte();

                    // Check if the last character is a line feed ('\n').
                    if (lastByte == '\n')
                    {
                        Console.WriteLine("File already ends with an EOL character (LF).");
                        needsEOL = false;
                    }
                }
            }

            // If after all checks, an EOL is needed, append it.
            if (needsEOL)
            {
                Console.WriteLine("Adding EOL character to the end of the file.");
                File.AppendAllText(filePath, Environment.NewLine);
                Console.WriteLine("Successfully updated file.");
            }
        }
        catch (IOException ex)
        {
            Console.WriteLine($"An I/O error occurred: {ex.Message}");
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine($"Access denied. Please check permissions for '{filePath}'. Details: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An unexpected error occurred: {ex.Message}");
        }
    }

    public static void ReadFileLines(string filePath)
    {
        try
        {
            var lines = File.ReadAllLines(filePath);
            Console.WriteLine($"Contents of '{filePath}':");
            foreach (var line in lines)
            {
                Console.WriteLine(line);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error reading file '{filePath}': {ex.Message}");
        }
    }

    /// <summary>
    /// Main method to demonstrate the functionality.
    /// </summary>
    public static void Main(string[] args)
    {
        // --- Create dummy files for demonstration ---
        string fileWithEOL = "file_with_eol.txt";
        string fileWithoutEOL = "file_without_eol.txt";
        string emptyFile = "empty_file.txt";

        // File that already has a proper EOL
        File.WriteAllText(fileWithEOL, "Hello World!\r\nThis is a test.\r\n");

        // File that is missing the final EOL
        // We use a StringBuilder to avoid any automatic EOL from helper methods.
        var sb = new StringBuilder();
        sb.Append("First line\r\n");
        sb.Append("Second line has no EOL");
        File.WriteAllText(fileWithoutEOL, sb.ToString());

        // An empty file
        File.Create(emptyFile).Close();

        Console.WriteLine($"--- Checking '{fileWithEOL}' ---");
        EnsureFinalEOL(fileWithEOL);
        Console.WriteLine();

        Console.WriteLine($"--- Checking '{fileWithoutEOL}' ---");
        EnsureFinalEOL(fileWithoutEOL);
        Console.WriteLine();

        Console.WriteLine($"--- Checking '{emptyFile}' ---");
        EnsureFinalEOL(emptyFile);
        Console.WriteLine();

        Console.WriteLine($"--- Read '{fileWithoutEOL}' with standard tooling ---");
        ReadFileLines(fileWithoutEOL);
        Console.WriteLine();

        // --- Clean up the dummy files ---
        File.Delete(fileWithEOL);
        File.Delete(fileWithoutEOL);
        File.Delete(emptyFile);
    }
}
  5. Peter_1985 2,806 Reputation points
    2025-10-21T04:19:11.8333333+00:00

    Many thanks

Your answer

Answers can be marked as 'Accepted' by the question author and 'Recommended' by moderators, which helps users know the answer solved the author's problem.