proposal: generate and handle FormatStringTuples from extened interpolated strings

[Zetanova]

Intro
The new interpolated strings feature works great to concatenate and format strings
but there is currently no support to work with FormatString-Template engines
like in Serilog or Elasticsearch (and many others).

Proposal
Instead of overloading multiple methods all over the place to push the parameters of string template, object args[] around
c# could extend the interpolated strings syntax to generate a tuple (string Template, object[] Args) instead.

The combination of tuple with interpolated strings could be used for new syntax extension
like $("", arg1, arg2, ...).

Benifite
The standardization and compile time validation of a formatted-string.

Pseudo code

var info = new { Name: "World", Number: 2 };

var formatedString = $("Hello {name} {number:D2}!", info.Name, info.Number);
//formatedString is: (Template: "Hello {name} {number:D2}!", Args: ["World", 2])

Logger.LogDebug(formatedString.Template, formatedString.Args);

//or after adoption with an overload or magic-deconstructor:
//Logger.LogDebug(formatedString);

var output = formatedString.toString();
//output is: "Hello World 02!"

final statement
It looks first not necessary, the tuple could be used directly or the tuple could be created over a helper function.
But both methods would still lack an compile time check of the template-string and a standardization for 3th party libs.

[TheUnlocked]

I'm not sure what problem this is trying to solve. If I'm understanding this right, you could just create a function like

(string template, object[] args) CreateFormattedString(string template, params object[] args) {
    return (template, args);
}

Instead of needing to add a whole new language feature.

[svick]

But both methods would still lack an compile time check of the template-string

This sounds like something that could be solved by writing a Roslyn analyzer.

a standardization for 3th party libs

Why would standardization be useful here? Aren't these values usually passed directly to the logging method?

[PathogenDavid]

You can't name the template elements (without custom format strings or something similar), but C# already essentially supports this with FormattableString.

It looks like there have been requests to add support for FormattableString to Serilog, which have been rejected:

• String.Interpolation serilog/serilog#1225
• Support interpolated strings serilog/serilog#810
• Add Support for Interpolated String serilog/serilog#639

A few noteworthy things from the comments on that first issue:

• Extension methods to add FormattableString support to Serilog
• SerilogAnalyzer

See also: dotnet/roslyn#142 -- An ancient language request to enhance FormattableString to help meet Serilog's needs which was explicitly rejected.

[Zetanova]

Yes, the issue is ancient and i search/tried many things, but now had the idea with the new Tuples and interpolated strings.

FormattableString looks good but lacks the naming of the arguments and cant be used for Structured logging.

A variant of my idea would be instead of generating an args array like in FormattableString to generate a named tuple

var info = new { Name: "World", Number: 2 };

var formattedString = $("Hello {theName} {theNumber:D2}!", info.Name, info.Number);
//formattedString is: (Format: "Hello {0} {1:D2}!", theName: "World", theNumber: 2)

but this has the issue that it cant be used in method parameters easily.

[Zetanova]

dotnet 3.1 addresses this issue with the name support in message template in ILogger
https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-3.1#log-message-template

I still believed that without NLog or Serilog the standard ILogger would throw errors.