Какой смысл использовать класс ArraySegment <T>?

Question

Я только что натолкнулся на тип ArraySegment<byte> при создании подкласса класса MessageEncoder.

Теперь я понимаю, что это сегмент заданного массива, он принимает смещение, не перечисляется и не имеет индексатора, но я все еще не понимаю его использования. Может кто-нибудь объяснить, пожалуйста, с примером?

Answer 1

ArraySegment<T> стал намного полезнее в .NET 4.5 , поскольку теперь он реализует:

• IList<T>
• ICollection<T>
• IEnumerable<T>
• IEnumerable
• IReadOnlyList<T>
• IReadOnlyCollection<T>

в отличие от Версия .NET 4 , в которой не реализовано никаких интерфейсов.

Теперь класс может принимать участие в чудесном мире LINQ, поэтому мы можем выполнять обычные вещи LINQ, такие как запрос содержимого, обратное содержимое безвоздействуя на исходный массив, получить первый элемент и так далее:

var array = new byte[] { 5, 8, 9, 20, 70, 44, 2, 4 };
array.Dump();
var segment = new ArraySegment<byte>(array, 2, 3);
segment.Dump(); // output: 9, 20, 70
segment.Reverse().Dump(); // output 70, 20, 9
segment.Any(s => s == 99).Dump(); // output false
segment.First().Dump(); // output 9
array.Dump(); // no change

Answer 2

1. Распределение буфера для классов ввода-вывода - Используйте один и тот же буфер для одновременных операций чтения и записи и используйте единую структуру, которую вы можете передать, описывая всю вашу операцию.
2. Функции набора - говоря математически, вы можете представить любые смежные подмножества, используя эту новую структуру.Это в основном означает, что вы можете создавать разделы массива, но вы не можете представить, скажем, все шансы и все четные.Обратите внимание, что телефонный тизер, предложенный The1, мог быть элегантно решен с использованием разбиения ArraySegment и древовидной структуры.Окончательные числа можно было записать, пройдя сначала глубину дерева.Я думаю, это был бы идеальный сценарий с точки зрения памяти и скорости.
3. Многопоточность - теперь вы можете порождать несколько потоков для работы с одним и тем же источником данных, используя сегментированные массивы в качестве шлюза управления.Циклы, в которых используются дискретные вычисления, теперь могут быть обработаны довольно легко, что начинают делать последние компиляторы C ++ в качестве шага оптимизации кода.
4. Сегментация пользовательского интерфейса. Ограничьте отображение пользовательского интерфейса с помощью сегментированных структур.Теперь вы можете хранить структуры, представляющие страницы данных, которые можно быстро применить к функциям отображения.Одиночные непрерывные массивы могут использоваться для отображения отдельных представлений или даже иерархических структур, таких как узлы в TreeView, путем сегментирования линейного хранилища данных на сегменты сбора узлов.

В этом примеремы рассмотрим, как вы можете использовать исходный массив, свойства Offset и Count, а также как вы можете циклически проходить по элементам, указанным в ArraySegment.

using System;

class Program
{
    static void Main()
    {
        // Create an ArraySegment from this array.
        int[] array = { 10, 20, 30 };
        ArraySegment<int> segment = new ArraySegment<int>(array, 1, 2);

        // Write the array.
        Console.WriteLine("-- Array --");
        int[] original = segment.Array;
        foreach (int value in original)
        {
            Console.WriteLine(value);
        }

        // Write the offset.
        Console.WriteLine("-- Offset --");
        Console.WriteLine(segment.Offset);

        // Write the count.
        Console.WriteLine("-- Count --");
        Console.WriteLine(segment.Count);

        // Write the elements in the range specified in the ArraySegment.
        Console.WriteLine("-- Range --");
        for (int i = segment.Offset; i < segment.Count+segment.Offset; i++)
        {
            Console.WriteLine(segment.Array[i]);
        }
    }
}

Структура ArraySegment - какими они былимышления?

Answer 3

Это маленькая структура солдат, которая делает только ссылку на массив и сохраняет диапазон индекса. Немного опасно, остерегайтесь того, что он не делает копию данных массива и никоим образом не делает массив неизменным или не выражает необходимость неизменности. Более типичный шаблон программирования - просто сохранить или передать массив и переменную или параметр длины, как это делается в методах .NET BeginRead (), String.SubString (), Encoding.GetString () и т. Д. И т. Д.

Он мало используется в .NET Framework, за исключением того, что похоже на одного конкретного программиста Microsoft, который работал над веб-сокетами и любил его в WCF. Это, вероятно, правильное руководство, если вам это нравится, то используйте его. В .NET 4.6 это было сделано в прятки, его использует добавленный метод MemoryStream.TryGetBuffer (). Я предпочитаю иметь два out аргумента.

В целом, более универсальное понятие ломтиков занимает первое место в списке пожеланий ведущих инженеров .NET, таких как Мадс Торгерсен и Стивен Тауб. Последний недавно выдвинул предложение о синтаксисе array[:], вы можете увидеть, о чем они думают, на этой странице Roslyn . Я предполагаю, что получение поддержки CLR - это то, от чего в конечном итоге зависит. Об этом активно думают в C # версии 7, следите за System.Slices .

Обновление: недействительная ссылка, поставляется в версии 7.2 как Span .

Update2: больше поддержки в C # версии 8.0 с типами Range и Index и методом Slice ().

Answer 4

А как насчет класса-обёртки?Просто чтобы избежать копирования данных во временные буферы.

public class SubArray<T> {
        private ArraySegment<T> segment;

        public SubArray(T[] array, int offset, int count) {
            segment = new ArraySegment<T>(array, offset, count);
        }
        public int Count {
            get { return segment.Count; }
        }

        public T this[int index] {
            get {
               return segment.Array[segment.Offset + index];
            }
        }

        public T[] ToArray() {
            T[] temp = new T[segment.Count];
            Array.Copy(segment.Array, segment.Offset, temp, 0, segment.Count);
            return temp;
        }

        public IEnumerator<T> GetEnumerator() {
            for (int i = segment.Offset; i < segment.Offset + segment.Count; i++) {
                yield return segment.Array[i];
            }
        }
    } //end of the class

Пример:

byte[] pp = new byte[] { 1, 2, 3, 4 };
SubArray<byte> sa = new SubArray<byte>(pp, 2, 2);

Console.WriteLine(sa[0]);
Console.WriteLine(sa[1]);
//Console.WriteLine(b[2]); exception

Console.WriteLine();
foreach (byte b in sa) {
    Console.WriteLine(b);
}

Выход:

3
4

3
4

Answer 5

ArraySegment НАМНОГО полезнее, чем вы думаете.Попробуйте запустить следующий модульный тест и приготовьтесь к изумлению!

    [TestMethod]
    public void ArraySegmentMagic()
    {
        var arr = new[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

        var arrSegs = new ArraySegment<int>[3];
        arrSegs[0] = new ArraySegment<int>(arr, 0, 3);
        arrSegs[1] = new ArraySegment<int>(arr, 3, 3);
        arrSegs[2] = new ArraySegment<int>(arr, 6, 3);
        for (var i = 0; i < 3; i++)
        {
            var seg = arrSegs[i] as IList<int>;
            Console.Write(seg.GetType().Name.Substring(0, 12) + i);
            Console.Write(" {");
            for (var j = 0; j < seg.Count; j++)
            {
                Console.Write("{0},", seg[j]);
            }
            Console.WriteLine("}");
        }
    }

Видите ли, все, что вам нужно сделать, это навести ArraySegment на IList, и он сделает все то, что вы, вероятно, ожидали, что он сделает впервое место.Обратите внимание, что типом по-прежнему является ArraySegment, даже если он ведет себя как обычный список.

OUTPUT:

ArraySegment0 {0,1,2,}
ArraySegment1 {3,4,5,}
ArraySegment2 {6,7,8,}

Answer 6

Простыми словами: он хранит ссылку на массив, позволяя вам иметь несколько ссылок на одну переменную массива, каждая из которых имеет свой диапазон.

Фактически это помогает вам использовать и передавать разделы массива более структурированным способом, вместо того, чтобы иметь несколько переменных, для хранения начального индекса и длины. Кроме того, он предоставляет интерфейсы для работы с разделами массива.

Например, следующие два примера кода делают то же самое, один с ArraySegment, а другой без:

        byte[] arr1 = new byte[] { 1, 2, 3, 4, 5, 6 };
        ArraySegment<byte> seg1 = new ArraySegment<byte>(arr1, 2, 2);
        MessageBox.Show((seg1 as IList<byte>)[0].ToString());

и

        byte[] arr1 = new byte[] { 1, 2, 3, 4, 5, 6 };
        int offset = 2;
        int length = 2;
        byte[] arr2 = arr1;
        MessageBox.Show(arr2[offset + 0].ToString());

Очевидно, что первый фрагмент кода более предпочтителен, особенно когда вы хотите передать сегменты массива в функцию.