Consider providing a string.Create method which accepts a ROS<T> or ROS<char> as state

[john-h-k]

Currently, string.Create only accepts a generic TState as the state, which means ReadOnlySpan<T> and Span<T> can't be used as state. In situations where, for example, the state is a stackalloc'd buffer which can't be converted to a ROM. It can be unpleasantly worked around with pinning and passing pointer and length manually, but it is ugly and clunky. It seems simple enough to add

public delegate void SpanReadOnlySpanAction<TSpan, TReadOnlySpan>(Span<TSpan> span, ReadOnlySpan<TReadOnlySpan> readOnlySpan)

( with potentially nicer naming )

and provide a string.Create<TState>(int length, ReadOnlySpan<TState> state, SpanReadOnlySpanAction action that is basically the same as the current impl.

[joperezr]

In order to consider this we would need a formal API proposal with rationale and usage examples.

[AlexeiScherbakov]

I think this issue is not about string.Create. CLR has limit that ref struct cannot be used as type arg.
Even if we add string.Create - it will not help, actually real solution must be allowing for public delegate void SpanAction<T, in TArg>(Span<T> span, TArg arg) have an any ref struct as TArg type argument.

Most simple syntetic example for is hex converting. Let we need to implement two extension methods:

public static unsafe string ToHexStringUpperCase(this ReadOnlySpan<byte> array)
{
	string ret = null;
	fixed (void* fix = array)
	{
		byte* ptr = (byte*) fix;
		ret = string.Create(array.Length * 2, array.Length, (span, len) =>
		{
			CharSpanWriteHexExtension.WriteByteArrayAsHexUpperCase(span, ptr, len);
		});
	}
	return ret;
}

public static unsafe string ToHexStringUpperCase(this ReadOnlySpan<byte> array, char separator)
{
	string ret = null;
	fixed (void* fix = array)
	{
		byte* ptr = (byte*) fix;
		ret = string.Create(array.Length * 3, array.Length, (span, len) =>
		{
			ReadOnlySpan<byte> arr = new ReadOnlySpan<byte>(ptr, len);
			CharSpanWriteHexExtension.WriteByteArrayAsHexUpperCase(span, arr, separator);
		});
	}
	return ret;
}

For second method we need pass ReadOnlySpan with int and char together, for compiler it will be optimal to create something like new ref struct ValueTuple and pass it to this method as state.

So this issue is related to dotnet/csharplang#2584

[Aragas]

As a workaround for people trying to solve the issue without copying the context - pinning the span via fixed and then passing the pointer as IntPtr can also work!
You can also pass the length via a tuple ((IntPtr) pOutput, length) if needed.

int outputLength = 128;
Span<char> output = stackalloc char[outputLength];
// Some operation on output

fixed (void* pOutput = output)
{
    var str = string.Create(outputLength, (IntPtr) pOutput, static (span, ptr) =>
    {
        new Span<char>(ptr.ToPointer(), span.Length).CopyTo(span);
    });
}

And if I understand correctly, it should be possible to do the same thing without pinning now

int outputLength = 128;
Span<char> output = stackalloc char[outputLength];
// Some operation on output

ref var outputRef = ref MemoryMarshal.GetReference(output);
var outputPtr = (IntPtr) Unsafe.AsPointer(ref outputRef);
var str = string.Create(outputLength, outputPtr, static (span, ptr) =>
{
    new Span<char>(ptr.ToPointer(), span.Length).CopyTo(span);
});

[stephentoub]

it should be possible to do the same thing without pinning now

Yes, e.g.

int outputLength = 128;
Span<char> output = stackalloc char[outputLength];
...
var str = string.Create(outputLength, &output, static (span, ptr) =>
{
    Span<char> output = *(ReadOnlySpan<char>*)ptr;
    ...
});

[dakersnar]

In order to consider this we would need a formal API proposal with rationale and usage examples.

Closing this issue for now given this. If anyone is interested in driving it forward themselves, please feel free to open a new issue that follows the API suggestion template. Our API review process and a link to the template/good example is here: https://github.com/dotnet/runtime/blob/main/docs/project/api-review-process.md#steps.