C# Raw String Literal Proposal

89 点作者 nikbackm超过 3 年前

27 条评论

chubot超过 3 年前

To make the text easy to read and allow for indentation that developers like in code, these string literals will naturally remove the indentation specified on the last line when producing the final literal value.This is the same rule that Oil has; I think it came from the Julia language (or at least that's where I got it from)Oil Has Multi-line Commands and String Literals <a href="http://www.oilshell.org/blog/2021/09/multiline.html" rel="nofollow">http://www.oilshell.org/blog/2021/09/multiline.html</a>

__ryan__超过 3 年前

I've given some thought to this kind of string literal in the past (for my imaginary programming language). I want a syntax something like this:<pre><code> var xml = """<element attr="content"> """ <body> """ </body> """</element> """; </code></pre> This would give you the string:<pre><code> <element attr="content"> <body> </body> </element>(no newline) </code></pre> If you wanted a newline at the end, you'd do this:<pre><code> var xml = """<element attr="content"> """ <body> """ </body> """</element> """ """; </code></pre> Basically the end delimiter of the string would be the last """. You could concatenate two strings like so:<pre><code> var xml = """<element attr="content"> """ <body> """ </body> """</element> """ """ // this string ended on this line + """<element attr="content"> """ <body> """ </body> """</element> """ """; // this string ended on this line </code></pre> This could use the same logic for using at least three quotes as the indicator that it's a multiline string.Please, tear this apart and offer improvements.Edit: this is conceptually similar to Zig's multiline literal: <a href="https://ziglang.org/documentation/master/#Multiline-String-Literals" rel="nofollow">https://ziglang.org/documentation/master/#Multiline-String-L...</a>

评论 #30373498 未加载

评论 #30381658 未加载

评论 #30373799 未加载

评论 #30385406 未加载

hankchinaski超过 3 年前

I have been temporarily working with c# for the past month after years of Go. It’s a different philosophy to Go, there is a lot of syntactic sugar and magic spells that make your life easy… but I don’t know if I prefer that to the Go way of doing things. I was pleasantly surprised tho. Much better experience than working with Java

评论 #30373396 未加载

评论 #30381433 未加载

评论 #30373389 未加载

crispyambulance超过 3 年前

I got confused at the first example.<pre><code> var xml = """ <element attr="content"> <body> </body> </element> """; </code></pre> And then they say that xml gets this...<pre><code> <element attr="content"> <body> </body> </element> </code></pre> But they don't explicitly say if the new lines after and before the """ 's are considered part of the literal string or not.Are they?

评论 #30376804 未加载

评论 #30373405 未加载

评论 #30373366 未加载

评论 #30373387 未加载

wvenable超过 3 年前

I've used this in other languages and I don't like it. It's the wrong approach to solving the problem. As soon as I want to embed some multi-line string in my code then I'd be better of just having it in it's own file..NET does allow you embed files directly into your project and read in those files but it's a lot of confusing boilerplate.If .NET provided a really easy way to take a file from the project and create a compile-time string from it then I think that would be significantly more useful than this proposal.

评论 #30386119 未加载

评论 #30387074 未加载

ape4超过 3 年前

Perl's heredoc is better. You get to pick the delimiter. <a href="https://perlmaven.com/here-documents" rel="nofollow">https://perlmaven.com/here-documents</a>

gwbas1c超过 3 年前

... Why?There are so many different ways to do strings in C#. Adding features like this just makes the language harder to learn, and the compiler harder to implement.At this point, it's probably better to adjust the compiler to make it easier to turn a text file into a hardcoded string. The embedded resource approach works, but it could be significantly smoother.Or, maybe the compiler needs some form of a plugin architecture so people who want obscure features can figure out how to add them?

评论 #30376963 未加载

评论 #30373501 未加载

评论 #30373438 未加载

LandR超过 3 年前

<pre><code> var v = """""" contents""""" """""" </code></pre> lol.I like the proposal to have these sort of raw strings, where indentations are removed, but can't they use a symbol before the string like they do with interpolation `$` or literals `@`?I know it says design decision to go with 1 more " than the longest sequence of " in the string, but why ?

评论 #30373486 未加载

评论 #30376881 未加载

评论 #30374149 未加载

评论 #30373166 未加载

评论 #30372995 未加载

评论 #30373820 未加载

captainmuon超过 3 年前

Nice, I'm surprized this is not already in the language. The only thing I find a bit strange is that the delimiters must be on separate lines (unless it is the special one-line-form). So this is apparantly not legal:<pre><code> var s = """This is a multiline string"""; </code></pre> Requiring the start and especially end quotes to be on a separate line makes it take a lot of vertical space. But OTOH, that is consistent with the default coding style in C# which is vertically verbose (with {} on lines by themselves).

评论 #30373415 未加载

评论 #30376818 未加载

billpg超过 3 年前

A little while ago, I discovered that...<pre><code> $"A{new List<string>{$"B{"{C}"}D"}.First()}E" </code></pre> ... was valid C#.This means that a C# compiler can't start with a simple tokenizing loop. That compiler phase would have to keep track of state in a stack, recording what each } character means while its still looping through code character-by-character.Now we're adding {{ and }} into the equation. Yay.

评论 #30374544 未加载

评论 #30376929 未加载

评论 #30385954 未加载

exyi超过 3 年前

I hope it will also normalize newlines to `\n`. The current version of raw literals (@"...") just puts there whatever is in the file, so it in practice depends on if your program was compiled on Windows or Linux. Surely that should be irrelevant for the compilation to intermediate language

评论 #30377055 未加载

评论 #30373325 未加载

iliketrains超过 3 年前

This is fantastic! After this is in, can anyone propose a better documentation syntax please? I am really tired of typing verbose XML as comments, and not even being able to write "a < b" or "T<int>" in my comments...

DalekBaldwin超过 3 年前

Interpolation is its own can of worms, but if you just want to be able to encode absolutely anything without escape characters, you just need two delimiters:<pre><code> "*n [stringA] "*n "*n [stringB] '*n '*n [stringC] "*n '*n [stringD] '*n </code></pre> Each string may contain runs of contiguous single or double quotes of length less than n, and furthermore:stringA may start and/or end with a single quotestringB may start with a single quote and/or end with a double quotestringC may start with a double quote and/or end with a single quotestringD may start and/or end with a double quote

jsd1982超过 3 年前

For the single-line case, what happens for:<pre><code> """"""" """""""" </code></pre> Are those strings containing `"` and `""` or are they empty strings? Is the first case an error because the starting and ending quote counts do not match? If the number of quote chars is even, do the contents alternate between `"` and empty as the number of surrounding quotes increases?

评论 #30373620 未加载

chhickman超过 3 年前

I would much rather see something like this:<pre><code> string longString = `This ` allows ` differentiation ` of `formatting ` indention ` from ` leading ` string ` spaces ` using ` back-ticks (\`)</code></pre>

评论 #30377076 未加载

a9h74j超过 3 年前

In place of all of the special rules for handling indentation, I wonder if they could simply define some extra starting chars (besides $$""" for controlling interpolation) to indicate suppress-leading-newline or suppress-ending-newline etc. Offhand this would seem more explicit than implicit, and be searchable (unlike a pattern).Other than that, ++ for any mechanism to quote to arbitrary depth. I have imagined[abcfoo[ ...anything but ]abcfoo]... ]abcfoo]as another approach.

StevePerkins超过 3 年前

I like the three-quote literal syntax in general, and am a bit surprised that C# doesn't have this already. Even Java has had this for awhile now!But I don't like the indented form, where nested triple-quotes are ignored. Whitespace formatting is fine when I'm working with Python, but I really don't want to mix that paradigm when I'm working with curly-brace languages.

评论 #30373503 未加载

ducharmdev超过 3 年前

> This allows code to look natural, while still producing literals that are desired, and avoiding runtime costs if this required the use of specialized string manipulation routines.Maybe a source generator would be applicable here? Not as nice has having it built into the language of course, but it would at least eliminate these runtime costs.

KingOfCoders超过 3 年前

With all the hacks and exploits going on, and (Log4J) more security awareness coming,I've been considering a safe String class that prevents some characters like CR,LF,\ that are seldom needed in business strings but used in system level things. Drawing a line between these two would increase security.

评论 #30375375 未加载

评论 #30373522 未加载

assbuttbuttass超过 3 年前

I always found these complex indentation-stripping rules to be confusing in a language such as Python. I was under the impression that C# doesn't treat whitespace significantly, so why do they need all these complex rules? Just interpret what's between the quotes literally.

评论 #30373087 未加载

评论 #30373085 未加载

torginus超过 3 年前

It seems like .NET is trying to outcompete Rust in the number of string types available in the language.

评论 #30373291 未加载

评论 #30373334 未加载

评论 #30373298 未加载

monadmoproblems超过 3 年前

I've long wanted a more succinct way of writing implicitly typed arrays. Whenever you work with data directly in the code, for example when hacking on leetcode, you end you with lots of horrible nested arrays:new [] {new [] {1, 2}, new [] {3, 4}};Something like:@[ @[1, 2], @[3, 4] ]

评论 #30377094 未加载

radicalbyte超过 3 年前

The issue is being discussed here: <a href="https://github.com/dotnet/csharplang/issues/4304" rel="nofollow">https://github.com/dotnet/csharplang/issues/4304</a>

jmull超过 3 年前

I guess a good thing about proposals like this is as an early warning system.When a language gets its fourth or fifth string literal syntax, its process is probably broken.

jimworm超过 3 年前

Heredoc by another name...?

评论 #30373265 未加载

intrasight超过 3 年前

I did not understand the xml indentation examples

评论 #30377108 未加载

jwsteigerwalt超过 3 年前

Yes!!!!