Tracking: Revisit APIs to use Span<T>

[karelz]

We just need to wait for Span<T> to mature a bit.

• Parse integers in a string based on an index #16933 - Int32.Parse, Int32.TryParse
  • https://github.com/dotnet/corefx/issues/13892#issuecomment-262382196 - Parse on all primitive types (sbyte.Parse byte.Parse short.Parse ... ulong.Parse, DateTime.Parse, Guid.Parse, etc)
• Add methods to StringBuilder to append ReadOnlySpan<char> #19437 - StringBuilder.Append
• https://github.com/dotnet/corefx/issues/13892#issuecomment-262576835 - ImmutableArray<T>.implicit operator ReadOnlySpan<T>()
• https://github.com/dotnet/corefx/issues/7656#issuecomment-231217120 - string.Split
• https://github.com/dotnet/corefx/issues/12672#issue-183177295 - Guid.GetBytes(out byte[]), Decimal.GetBits(decimal, out byte[])
  • https://github.com/dotnet/corefx/issues/12672#issuecomment-253959625 - Look at all methods which take new array (e.g. out byte[])
• dotnet/corefx#14255 - Encoding.GetBytes
• https://github.com/dotnet/corefx/issues/17281 - SocketAsyncEventArgs.SetBuffer(Memory<T>)
• https://github.com/dotnet/corefx/issues/13892#issuecomment-287667969 - Stream.Read/Write[Async] and Socket.Send/Receive[Async]
• https://github.com/dotnet/corefx/issues/6740#issuecomment-287684217 - IO APIs
• dotnet/corefx#17378 - IPAddress
• dotnet/corefx#18693 - Crypto
• dotnet/corefx#18847 - ImmutableArray.AsReadOnlySpan()

[tarekgh]

@karelz why this not under System.Runtime area?

[karelz]

I expected it to be cross-cutting. It will also grow. I don't have strong preference between Meta vs. Runtime in this case.

[jamesqo]

@karelz If you have int.Parse, then you need to add Parse apis for all the other primitive types too, plus some others. e.g. sbyte.Parse byte.Parse short.Parse ... ulong.Parse, DateTime.Parse, Guid.Parse, etc.

[jamesqo]

@karelz, I think it may also be valuable offering an API for converting an ImmutableArray<T> to a ReadOnlySpan<T> via an implicit conversion, e.g.:

public struct ImmutableArray<T>
{
    public static implicit operator ReadOnlySpan<T>(ImmutableArray<T> array);
}

ImmutableArray<T> as it is it kind of hard to work with, because most of the framework methods accept plain arrays. That leads to scenarios like this, where to write an ImmutableArray to a Stream, instead of calling Write directly, you have to loop through each byte of it & call WriteByte (super slow), or call ToArray and make a copy (allocates). It seems like it would be beneficial to convert an ImmutableArray to a ReadOnlySpan as more & more methods start accepting spans.

cc @AArnott @KrzysztofCwalina

[karelz]

Updated above ...

[AArnott]

I wonder when the right time to make ImmutableArray<T> depend on the new API. Adding such a dependency will limit who can upgrade to the latest System.Collections.Immutables. Which versions of .NET Framework define ReadOnlySpan<T>?

[jamesqo]

cc: @jkotas @terrajobst

[jkotas]

Which versions of .NET Framework define ReadOnlySpan<T>?

System.Memory for .NET Framework will be separate nuget package for foreseeable future.

ImmutableArray<T> as it is it kind of hard to work with, because most of the framework methods accept plain arrays.

Right. The current solution to this problem is this hack: https://github.com/dotnet/corefx/blob/master/src/System.Reflection.Metadata/src/System/Reflection/Internal/Utilities/ImmutableByteArrayInterop.cs#L83 that is getting replicated around. There was a discussion about adding official method to get to the underlying storage to avoid this hack, but the purist view of not having such method in the public surface prevailed. I believe this discussion was before open source, so it is not on GitHub. (disclaimer: I was for adding the method).

ReadOnlySpan<T> is going to have a similar method to get unprotected access to the underlying storage for interop. It is called DangerousGetPinnableReference currently, but this name may not be final. So once there is a public method to convert from ImmutableArray<T> to ReadOnlySpan<T>, there will be a way to get to the unprotected access to the underlying storage via public APIs and the purist argument will have much less merit. Thus, we can as well revisit adding the method to get to the underlying array for ImmutableArray<T>. It will address the current ImmutableArray<T> interop issue, without hacks and Span<T> dependency.

[jamesqo]

@jkotas Thanks for the synopsis. Very interesting to know the background on all of this.

[geoffkizer]

Stream.Read/Write[Async]
Socket.Send/Receive[Async]

[jamesqo]

Did we also forget about the IO APIs? https://github.com/dotnet/corefx/issues/6740#issuecomment-253602220

[karelz]

Top post updated with both @geoffkizer's and @jamesqo's links.

[Drawaes]

What about Crypto API's?
dotnet/corefx#18693

[karelz]

Top post updated, thanks @Drawaes!

[stephentoub]

Replaced by https://github.com/dotnet/corefx/issues/21281