add Span overloads for Socket datagram functions

[wfurt]

Spanification, ValueTask, and cancellation

This proposal spanifies connectionless methods on Socket, uses a ValueTask return, and adds cancellation support. There are already such overloads in Send() and Receive() functions for connection oriented sockets (TCP) and this is complement for UDP.

Proposed APIs

namespace System.Net.Sockets
{
    // Open question: consider defaulting SocketFlags to SocketFlags.None to reduce API space? Might challenge IntelliSense.

    public partial class Socket : IDisposable
    {
        // existing: public int SendTo(byte[] buffer, EndPoint remoteEP);
        public int SendTo(ReadOnlySpan<byte> buffer, EndPoint remoteEP);

        // existing: public int SendTo(byte[] buffer, SocketFlags socketFlags, EndPoint remoteEP);
        public int SendTo(ReadOnlySpan<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP);

        // existing: public int ReceiveFrom(byte[] buffer, ref EndPoint remoteEP);
        public int ReceiveFrom(Span<byte> buffer, ref EndPoint remoteEP);

        // existing: public int ReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP);
        public int ReceiveFrom(Span<byte> buffer, SocketFlags socketFlags, ref EndPoint remoteEP);
    }

    public static class SocketTaskExtensions
    {
        // existing: public static Task<int> SendToAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP);
        public static ValueTask<int> SendToAsync(this Socket socket, ReadOnlyMemory<byte> buffer, EndPoint remoteEP, CancellationToken cancellationToken = null);
        public static ValueTask<int> SendToAsync(this Socket socket, ReadOnlyMemory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);

        // existing: public static Task<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
        public static ValueTask<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, Memory<byte> buffer, EndPoint remoteEP, CancellationToken cancellationToken = null);
        public static ValueTask<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, Memory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);

        // existing: public static Task<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
        public static ValueTask<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, Memory<byte> buffer, EndPoint remoteEP, CancellationToken cancellationToken = null);
        public static ValueTask<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, Memory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);
    }
}

Most of the underlying code is already ready, this is about exposing it as public API.

cc: @stephentoub

[stephentoub]

Thanks, @wfurt. What about the asynchronous equivalents? Do we want to have ValueTask<int>-based versions of these APIs that accept {ReadOnly}Memory<byte> as we do for ReceiveAsync and SendAsync?

[wfurt]

I'm not sure. I look at SendAsync and ReceiveFromAsync as example and I only saw overload with SocketAsyncEventArgs. My general thinking was to mimic existing stream options.

[stephentoub]

I look at SendAsync and ReceiveFromAsync as example and I only saw overload with SocketAsyncEventArgs

For historical reasons, the Task/ValueTask-based overloads are extension methods here:
https://github.com/dotnet/corefx/blob/848811c496a7cb9d48ddee2775e982b4b732e8ac/src/System.Net.Sockets/src/System/Net/Sockets/SocketTaskExtensions.cs#L29-L30
https://github.com/dotnet/corefx/blob/848811c496a7cb9d48ddee2775e982b4b732e8ac/src/System.Net.Sockets/src/System/Net/Sockets/SocketTaskExtensions.cs#L40-L41

[wfurt]

updated. I missed that part when looking at Socket documentation. I was not sure if we also need overload for ReceiveMessageFrom(Async). With ipPacketInformation it probably won't be good fit for anybody looking for performance.

[hjc4869]

Is there any plan to avoid allocating EndPoint objects in these APIs? Since SendTo/ReceiveFrom APIs are called per datagram send/receive operation and they're probably on the hot path of a UDP server, even a small allocation could cause some kind of performance impact.

[karelz]

Not critical for 3.0, pushing to Future milestone.

[scalablecory]

Can we drop the two methods without SocketFlags? Users can specify SocketFlags.None. We have dropped these from our async APIs already:

    public partial class Socket : IDisposable
    {
        public int SendTo(ReadOnlySpan<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP);
        public int ReceiveFrom(Span<byte> buffer, SocketFlags socketFlags, ref EndPoint remoteEP);
    }

For async, these would be more consistent with existing Task-based APIs:

    public static class SocketTaskExtensions
    {
        public static ValueTask<int> SendToAsync(this Socket socket, ReadOnlyMemory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);
        public static ValueTask<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, Memory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);
        public static ValueTask<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, Memory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);
    }

(note return values to get endpoint / packet info, and defaulted cancellation token as last param)

[FiniteReality]

I also have a use case for these endpoints in some UDP code implementing a subset of RTP transmission, which runs on a 20ms timer. My data frames are less than 1kbytes total, and I believe implementing this as a Span operation would be much more efficient than my current implementation, which rents a buffer from ArrayPool<byte> to send instead.

[scalablecory]

triage: maybe default the socket flags, and then ready for review.

[terrajobst]

Video

• Looks good as proposed.
• However, should we stop adding async methods as extension and just make them proper public instance methods?
• In fact we may want to hide the entire SocketTaskExtensions because it was only used as a bridge pack for .NET Framework.
• Remaining: we should have overloads for the method that take IList<ArraySegment<byte>> because they are more efficient.

namespace System.Net.Sockets
{
    // Open question: consider defaulting SocketFlags to SocketFlags.None to reduce API space? Might challenge IntelliSense.

    public partial class Socket : IDisposable
    {
        // existing: public int SendTo(byte[] buffer, EndPoint remoteEP);
        public int SendTo(ReadOnlySpan<byte> buffer, EndPoint remoteEP);

        // existing: public int SendTo(byte[] buffer, SocketFlags socketFlags, EndPoint remoteEP);
        public int SendTo(ReadOnlySpan<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP);

        // existing: public int ReceiveFrom(byte[] buffer, ref EndPoint remoteEP);
        public int ReceiveFrom(Span<byte> buffer, ref EndPoint remoteEP);

        // existing: public int ReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP);
        public int ReceiveFrom(Span<byte> buffer, SocketFlags socketFlags, ref EndPoint remoteEP);
    }

    public static class SocketTaskExtensions
    {
        // existing: public static Task<int> SendToAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP);
        public static ValueTask<int> SendToAsync(this Socket socket, ReadOnlyMemory<byte> buffer, EndPoint remoteEP, CancellationToken cancellationToken = null);
        public static ValueTask<int> SendToAsync(this Socket socket, ReadOnlyMemory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);

        // existing: public static Task<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
        public static ValueTask<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, Memory<byte> buffer, EndPoint remoteEP, CancellationToken cancellationToken = null);
        public static ValueTask<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, Memory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);

        // existing: public static Task<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
        public static ValueTask<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, Memory<byte> buffer, EndPoint remoteEP, CancellationToken cancellationToken = null);
        public static ValueTask<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, Memory<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP, CancellationToken cancellationToken = null);
    }
}

[ahsonkhan]

Since we are adding span overloads to Socket, did we consider doing a full-pass on the type and adding similar overloads to the rest of the APIs on Socket?

For example, these APIs (+ overloads):

public IAsyncResult BeginReceive(byte[] buffer, int offset, int size, SocketFlags socketFlags, AsyncCallback callback, object state);
public IAsyncResult BeginReceiveMessageFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP, AsyncCallback callback, object state);
public IAsyncResult BeginSend(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode, AsyncCallback callback, object state);
public IAsyncResult BeginSendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint remoteEP, AsyncCallback callback, object state);

[ohsorry]

If we have Memory<T> version overloads in both TCP and UDP socket, I can design a system with such an interface:

    public partial interface IClient //regardless connection-oriented or connectionless.
    {        
        ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default);
        ValueTask<int> WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default);
    }

Pretty cool!

Can not use these two overloads in UDP if I don't have a default remote host:

public static ValueTask<int> ReceiveAsync(this Socket socket, Memory<byte> buffer, SocketFlags socketFlags, CancellationToken cancellationToken = default);

public static ValueTask<int> SendAsync(this Socket socket, ReadOnlyMemory<byte> buffer, SocketFlags socketFlags, CancellationToken cancellationToken = default);

need a Memory<byte> version overload for ReceiveFromAsync() / SendToAsync().

[scalablecory]

Closing for mega-issue #33418.