Requesting a new escape sequence that is equal to Environment.NewLine

[mauler2025]

For cross-platform code, writing $"I love C#.{Environment.NewLine}How about you?" reduces the readability. It will be better if we define a new escape sequence, for example \z, that is equal to Environment.NewLine. So the above literal string becomes more readable, "I love C#.\zHow about you?".

I hope my request does make sense. Thank you in advance.

[YairHalberstadt]

An interesting idea.

One difficulty with this is that currently plain string literals are embedded in IL which means that they take up no extra memory at runtime. Instead you just get a pointer to the string in metadata.
This is obviously impossible if the string uses /z since you have to wait till JIT time to know what the actual string will be. Instead it will have to be stored as an interpolated string.
This may require a bit of design work around whether such a string can be used as a const. For example could you use it as an argument to an attribute?

[FaustVX]

@YairHalberstadt
Maybe allow /z only in interpolated strings, $"Hello/zWorld!" would compile like $"Hello{Environment.NewLine}World!".

[theraot]

Given a string, in a given scope, and an escape sequence... the compiler would need to discover what should be interpolated there.

I'll also guess that a conflict should be a compiler error.

---

My first idea was that you could add an attribute, so that the developer could define the escape sequence with an attribute parameter, and it would be resolved with interpolating the member on which the attribute was applied, considering scope rules... However the meaning of literal strings being changed by another file this way bother me.

Perhaps it should be scoped by files instead. A new using directive... how about:

using string escape "z" = System.Environment.NewLine;

I did consider:

using string "z" = System.Environment.NewLine;

However, there it is not clear that "z" is an escape sequence. I also did consider:

using string "\z" = System.Environment.NewLine;

However, that could give the impression that you could put there any string, not only those that begin with \.

In my suggestion escape would be a keyword only in context. I looked through C# keywords... does the following have any fans?

using string break "z" = System.Environment.NewLine;

---

I did also consider something like #escape "z" System.Environment.NewLine - However, I do not think it is a good use of that kind of directives, nor that the compiler knows what is in scope when dealing with those.

---

I'm just tossing ideas, don't mind me.

[HaloFour]

Escape sequences are expanded at compile time and the characters inserted into the literal string. That would be impossible here because the value of Environment.NewLine can be different based on the platform. There really isn't a way to do this without it expanding at runtime which makes such a string unsuitable for constants and attributes.

I'd suggest that it's probably easier to map System.Environment.NewLine to a much shorter variable name for use in interpolation and formatting.

[canton7]

Another possibility is a new property on TextWriter which, when enabled, transparently converts \n or \r\n into the current platform's line endings, perhaps?

Although I'm sure there are implementation pains there as well.

[Unknown6656]

In the past I always used the following:

common.cs:

internal static class CommonUtils
{
    public static readonly string NL = System.Environment.NewLine;
}

And in any other file:

using System;
using static CommonUtils;

namespace App
{
    public class Program
    {
        public static void Main(string[] argv)
        {
            Console.WriteLine($"This is a{NL}multi-lined{NL}string!");
        }
    }
}

I think that this proposal has some potential, however, I currently see the same problem as @YairHalberstadt does.