I suggest to add ReadOnlySequence constructor for ArraySegment

[AlexRadch]

I suggest to add ReadOnlySequence constructor for ArraySegment.

Proposed API

    public readonly partial struct ReadOnlySequence<T>
    {
        /// <summary>
        /// Creates an instance of <see cref="ReadOnlySequence{T}"/> from the <see cref="ArraySegment{T}"/>.
        /// </summary>
        public ReadOnlySequence(ArraySegment<T> arraySegment);
    }

Details

Now we have three types for buffers: Array, ArraySegment, Memory. ReadOnlySequence have constructor for two of them, so it seems convenient to have constructor for ArraySegment too.

It is just sugar for public ReadOnlySequence(T[] array, int start, int length); constructor for ArraySegment.

[ahsonkhan]

Can you please provide a scenario or code snippet where such a ctor would be useful? What motivates the need to add this API?

See example of "Rationale and Usage": https://github.com/dotnet/corefx/blob/master/Documentation/project-docs/api-review-process.md

The goal isn't to get a complete API list, but a good handle on how the new APIs would roughly look like and in what scenarios they are being used. Here is a good example.

[ahsonkhan]

It would be good to see a rationale for why we need such an API. What can't you do today that you can do if such an API was added?

[AlexRadch]

It would be good to see a rationale for why we need such an API. What can't you do today that you can do if such an API was added?

It is just sugar for public ReadOnlySequence(T[] array, int start, int length); constructor for ArraySegment.

Now we have three types for buffers: Array, ArraySegment, Memory. ReadOnlySequence have constructor for two of them, so it seems convenient to have constructor for ArraySegment too.

[kamronbatman]

I have a use case for this where I would like to get an ArraySegment<byte>[] from a socket, turn it into a ReadOnlySequence<byte> and use a SequenceReader<byte> to parse it.

[svick]

@AlexRadch I don't understand why this proposal would be useful. ArraySegment<T> is implicitly convertible to ReadOnlyMemory<T>, so code like the following already works:

var segment = new ArraySegment<byte>(…);
var sequence = new ReadOnlySequence<byte>(segment);

@kamronbatman I think that's a separate request, since this one is about creating ReadOnlySequence<T> out of a single ArraySegment<T>. You might want to create a separate issue for that.

In case you didn't know, you can do what you want today, though it requires some extra code:

public static ReadOnlySequence<T> CreateSequence<T>(ArraySegment<T>[] segments)
{
    if (segments.Length == 0)
        return ReadOnlySequence<T>.Empty;
    
    var first = new BufferSegment<T>(segments[0]);
    var last = first;
    
    for (int i = 1; i < segments.Length; i++)
    {
        last = last.Append(segments[i]);
    }
    
    return new ReadOnlySequence<T>(first, 0, last, last.Memory.Length);
}

// Based on https://github.com/dotnet/aspnetcore/blob/ed5034e/src/Shared/Buffers.Testing/BufferSegment.cs
internal class BufferSegment<T> : ReadOnlySequenceSegment<T>
{
    public BufferSegment(Memory<T> memory) => Memory = memory;

    public BufferSegment<T> Append(Memory<T> memory)
    {
        var segment = new BufferSegment<T>(memory)
        {
            RunningIndex = RunningIndex + Memory.Length
        };
        Next = segment;
        return segment;
    }
}

I definitely wouldn't be against a convenience API for something like this.

[ahsonkhan]

I agree with @svick. The implicit cast for this should be sufficient. We don't need an arraysegment based ctor and I recommend closing this issue.

[dotnet-policy-service]

Due to lack of recent activity, this issue has been marked as a candidate for backlog cleanup. It will be closed if no further activity occurs within 14 more days. Any new comment (by anyone, not necessarily the author) will undo this process.

This process is part of our issue cleanup automation.

[dotnet-policy-service]

This issue will now be closed since it had been marked no-recent-activity but received no further activity in the past 14 days. It is still possible to reopen or comment on the issue, but please note that the issue will be locked if it remains inactive for another 30 days.