[Syntax Deficiency] C# syntax does not accept Span<char> or ReadOnlySpan<char> as valid values with ToString() methods

[4creators]

This becomes a bit problematic when writing code with for instance interpolated strings and passing to them Span<char> or ReadOnlySpan<char>. The C# syntax expects value which could be converted to object and as a result rejects spans. Obviously all other types are OK. Example:

Console.WriteLine($"My message with span {new Span(new char['m', 'e', 's', 's', 'a', 'g', 'e' ])} is failing to compile");
// Error CS0029 Cannot implicitly convert type 'System.ReadOnlySpan<char>' to 'object'

IMHO we should support calling .ToString() on instances of every type which supports it. Perhaps on spans of other primitive types as well.

[ufcpp]

using System;

class Program
{
    static void Main()
    {
        Span<char> s = stackalloc[] { 'm', 'e', 's', 's', 'a', 'g', 'e' };

        // OK. Invoking ToString.
        Console.WriteLine($"{s.ToString()}"); // message

        // NG. Boxing to object.
        Console.WriteLine($"{s}");
    }
}

[4creators]

@ufcpp I know you can invoke .ToStrin() but perhaps I have not clearly stated that IMO C# should support Span in such situation even without boxing. Boxing essentially from API perspective casts instance of type to object to access its API and in this case it is only the .ToString() method which is implemented on Span<T>.

[svick]

How would this work with FormattableString? For example, the following code prints True:

FormattableString fs = $"{42}";
Console.WriteLine(fs.GetArgument(0) is int);

But that only works because int can be boxed to object.

[HaloFour]

@4creators

String interpolation doesn't call ToString, it passes the argument to an API that expects object. What that API happens to do with the argument is completely opaque and subject to formatters and the like. To have C# explicitly call ToString for Span<T> or other ref structs would change the expectation of what that feature does. You can work around this today by calling ToString yourself.

[4creators]

You can work around this today by calling ToString yourself.

@HaloFour Thanks for explanation but unfortunately it is not an option due to additional allocations.

My expectation would be that C# would support it and if necessary runtime would provide support as well. Otherwise we have a lot work done for implementing Span<T> as performance feature and we left a few rough corners around where performance is lost.

[HaloFour]

@4creators

Thanks for explanation but unfortunately it is not an option due to additional allocations.

String interpolation does a lot of additional allocations which you cannot avoid. That's true if you pass any value, including bog-standard structs, which have to be boxed first.

My expectation would be that C# would support it and if necessary runtime would provide support as well. Otherwise we have a lot work done for implementing Span<T> as performance feature and we left a few rough corners around where performance is lost.

The "rough edges" are intentional limitations to keep your use of those types on very tight "safe" rails. There's a great deal you're not allowed to do with a Span<T> because it would be inherently unsafe.

[HaloFour]

I will note that it's been considered that the C# compiler emit different code when interpolating string literals/constants as to not incur the cost of composite formatting, which includes boxing. Maybe the same could be done with Span<char> or ReadOnlySpan<char>. But I think that this would involve the compiler doing a bit of gymnastics up front to concat the spans in with the format string.

[4creators]

But I think that this would involve the compiler doing a bit of gymnastics up front to concat the spans in with the format string.

@HaloFour

Yeah, you are most probably right, however, it would be significant perf improvement if we would use internally spans to interpolate strings. Anyway format string can be represented as span and sliced to include spans. This would require only one allocation of the new return string in the form of writable Span<char> with length equal to the sum of all concatenated strings. Should be doable ...