How to detect a line ending of the file

[lsoft]

Hello.

I need to detect line endings of the file for correct injecting piece of code inside.

Of course, I can detect it manully (read and analyze), but I'm not sure it's the best solution.

VS already detected line endings:

and I want to obtain this data. Any ideas except using a hardcode WPF magic? :)

If it possible, may be we want to see this logic in Vsix Toolkin?

Thanks!

[reduckted]

Do you want the line ending that should be used, or the line ending that is actually used? For example, the document could be using LF, but the editor settings or EditorConfig file says that the line endings should be CRLF.

There's a few options (code samples of each are at the bottom).

IEditorOptions

If you want the line ending that should be used, then you could look at the document's options. Get your hands on an ITextBuffer, then get the IEditorOptions from its properties. There's a GetNewLineCharacter() extension method that provides the line ending that should be used in the document.

Important

Having used this, I think this option is only what Visual Studio is configured to use, because it does not match what the EditorConfig file says to use.

EditorConfig

I don't know of any way to get this purely through Visual Studio, but you can use the editorconfig NuGet package to find and read EditorConfig files. This will get you the line ending that should be used.

IWhitespaceManager

This isn't a public API, but I'm pretty sure it's what Visual Studio uses to show the line ending in the status bar in your screenshot. This will get the line ending that is actually used (be careful of mixed line endings!). Because it's not public, it requires some reflection. From an ITextBuffer, get the property of type Microsoft.VisualStudio.Text.Document.IWhitespaceManager, then get its NewlineState.InferredLineEnding property. You can see the implementation here: https://github.com/microsoft/vs-editor-api/blob/0209a13c58194d4f2a7d03a2615ef03e857547e7/src/Editor/Text/Def/TextData/Document/NewlineState.cs

ITextSnapshot

You can detect the actual line ending used manually by using the ITextSnapshot. From the ITextBuffer, get the ITextSnapshot, get its first ITextSnapshotLine, then call GetLineBreakText(). Just be careful, because it returns an empty string for the last line in the buffer.

Sample Code

Here's some sample code that demonstrates each technique:

private string GetLineEnding(DocumentView document)
{
    string fromOptions = GetLineEndingFromOptions(document);
    string fromWhitespaceManager = GetLineEndingFromWhitespaceManager(document);
    string fromEditorConfig = GetLineEndingFromEditorConfig(document);
    string fromDocument = GetLineEndingFromDocument(document);


    Debug.WriteLine("Document Options:   " + FormatLineEnding(fromOptions));
    Debug.WriteLine("Whitespace Manager: " + FormatLineEnding(fromWhitespaceManager));
    Debug.WriteLine("EditorConfig:       " + FormatLineEnding(fromEditorConfig));
    Debug.WriteLine("Document:           " + FormatLineEnding(fromDocument));

    return fromEditorConfig ?? fromDocument ?? fromWhitespaceManager ?? fromDocument ?? Environment.NewLine;

    static string FormatLineEnding(string s)
    {
        return s?.Replace("\r", "CR")?.Replace("\n", "LF");
    }
}

private string GetLineEndingFromOptions(DocumentView document)
{
    if (document.TextBuffer.Properties.TryGetProperty(typeof(IEditorOptions), out IEditorOptions options))
    {
        // Take note of the remarks for `DefaultOptions.NewLineCharacterOptionId`:
        //   > This setting applies when `ReplicateNewLineCharacter` is false, 
        //   > or when `ReplicateNewLineCharacter` is true and the text buffer is empty.
        // https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualstudio.text.editor.defaultoptions.newlinecharacteroptionid?view=visualstudiosdk-2022#remarks
        if (options.GetReplicateNewLineCharacter())
        {
            if (document.TextBuffer.CurrentSnapshot.Length == 0)
            {
                return options.GetNewLineCharacter();
            }
        }
        else
        {
            return options.GetNewLineCharacter();
        }
    }

    return null;
}

private string GetLineEndingFromWhitespaceManager(DocumentView document)
{
    Type whitespaceManagerType = Type.GetType("Microsoft.VisualStudio.Text.Document.IWhitespaceManager, Microsoft.VisualStudio.Text.Data, Version=17.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");

    if (document.TextBuffer.Properties.TryGetProperty(whitespaceManagerType, out object whitespaceManager))
    {
        object newlineState = whitespaceManager.GetType().GetProperty("NewlineState").GetValue(whitespaceManager);
        object inferredLineEnding = newlineState.GetType().GetProperty("InferredLineEnding").GetValue(newlineState);

        if (inferredLineEnding is not null)
        {
            // This is an enum: https://github.com/microsoft/vs-editor-api/blob/0209a13c58194d4f2a7d03a2615ef03e857547e7/src/Editor/Text/Def/TextData/Document/NewlineState.cs#L21-L29
            return (int)inferredLineEnding switch
            {
                0 => "\r\n",
                1 => "\r",
                2 => "\n",
                _ => null
            }
            ;
        }
    }

    return null;
}

private string GetLineEndingFromEditorConfig(DocumentView document)
{
    // Using https://www.nuget.org/packages/editorconfig/0.15.0
    EditorConfig.Core.EditorConfigParser parser = new();
    EditorConfig.Core.FileConfiguration file = parser.Parse(document.FilePath);

    if (file.EndOfLine.HasValue)
    {
        return file.EndOfLine switch
        {
            EditorConfig.Core.EndOfLine.CRLF => "\r\n",
            EditorConfig.Core.EndOfLine.LF => "\n",
            EditorConfig.Core.EndOfLine.CR => "\r",
            _ => null
        };
    }

    return null;
}

private string GetLineEndingFromDocument(DocumentView document)
{
    string endOfLine = document.TextBuffer.CurrentSnapshot.Lines.FirstOrDefault()?.GetLineBreakText();
    // GetLineBreakText returns an empty string for the last line in the buffer.
    if (!string.IsNullOrEmpty(endOfLine))
    {
        return endOfLine;
    }
    else
    {
        return null;
    }
}

[lsoft]

@reduckted wow! Thanks A LOT for such detailed answer!

I found one more way to obtain an actual line ending of the document, could you describe its pro and cons?

        private static string GetDocumentLineEnding(
            EnvDTE.Document activeDoc
            )
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            if (activeDoc.Object("TextDocument") is EnvDTE.TextDocument textDoc)
            {
                var ep = textDoc.CreateEditPoint();
                ep.EndOfLine();

                var lineEnding = ep.GetText(null);
                return lineEnding;
            }

            return Environment.NewLine;
        }