C #의 배열 조각

어떻게합니까? 바이트 배열이 주어지면 :

byte[] foo = new byte[4096];

배열의 첫 x 바이트를 별도의 배열로 얻는 방법은 무엇입니까? (구체적으로 필요합니다 IEnumerable<byte>)

Sockets 로 작업하기위한 것 입니다. 가장 쉬운 방법은 Perls 구문과 비슷한 배열 슬라이싱입니다.

@bar = @foo[0..40];

처음 41 개의 요소를 @bar배열 로 반환합니다 . C #에 방금 놓친 것이 있습니까? 아니면 다른 일이 있습니까?

LINQ는 나에게 도움이되는 옵션입니다 (.NET 3.5).

배열은 열거 가능하므로 foo이미 IEnumerable<byte>자체입니다. LINQ 시퀀스 메소드를 사용하여 Take()원하는 것을 얻으십시오 ( Linq네임 스페이스 를로 포함하는 것을 잊지 마십시오 using System.Linq;).

byte[] foo = new byte[4096];

var bar = foo.Take(41);

어떤 IEnumerable<byte>값 에서든 배열이 정말로 필요하다면 그 ToArray()방법을 사용할 수 있습니다 . 그것은 사실이 아닌 것 같습니다.

사용할 수 있습니다 ArraySegment<T>. 배열을 복사하지 않으므로 매우 가볍습니다.

string[] a = { "one", "two", "three", "four", "five" };
var segment = new ArraySegment<string>( a, 1, 2 );

배열 CopyTo()방법을 사용할 수 있습니다 .

또는 LINQ와 함께 당신이 사용할 수있는 Skip()및 Take()...

byte[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
var subset = arr.Skip(2).Take(2);

static byte[] SliceMe(byte[] source, int length)
{
    byte[] destfoo = new byte[length];
    Array.Copy(source, 0, destfoo, 0, length);
    return destfoo;
}

//

var myslice = SliceMe(sourcearray,41);

C # 8.0 / .Net Core 3.0부터

새로운 유형 Index및 Range추가 되는 배열 슬라이싱이 지원 됩니다.

범위 구조 문서
색인 구조 문서

Index i1 = 3;  // number 3 from beginning
Index i2 = ^4; // number 4 from end
int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Console.WriteLine($"{a[i1]}, {a[i2]}"); // "3, 6"

var slice = a[i1..i2]; // { 3, 4, 5 }

위의 코드 샘플은 C # 8.0 블로그 에서 가져 왔습니다 .

점을 유의 ^접두사부터 카운트를 나타내는 최종 배열. 문서 예제에 표시된대로

var words = new string[]
{
                // index from start    index from end
    "The",      // 0                   ^9
    "quick",    // 1                   ^8
    "brown",    // 2                   ^7
    "fox",      // 3                   ^6
    "jumped",   // 4                   ^5
    "over",     // 5                   ^4
    "the",      // 6                   ^3
    "lazy",     // 7                   ^2
    "dog"       // 8                   ^1
};              // 9 (or words.Length) ^0

Range그리고 Index또한 루프를 예를 들어, 슬라이스 배열의 외부 작업

Range range = 1..4; 
foreach (var name in names[range])

항목 1-4를 반복합니다.

_{이 답변을 작성할 당시 C # 8.0은 아직 공식적으로 릴리스되지 않은
C # 8.x이며 .Net Core 3.x는 Visual Studio 2019 이상에서 사용할 수 있습니다.}

에서 C # 7.2 , 당신은 사용할 수 있습니다 Span<T>. 새로운 System.Memory시스템 의 장점은 데이터를 복사 할 필요가 없다는 것입니다.

필요한 방법은 Slice다음과 같습니다.

Span<byte> slice = foo.Slice(0, 40);

방법의 많은 지금 지원 Span하고 IReadOnlySpan는이 새로운 유형을 사용하는 것은 매우 간단합니다, 그래서.

작성 당시 Span<T>유형은 최신 버전의 .NET (4.7.1)에 아직 정의되어 있지 않으므로이를 사용하려면 NuGet 에서 System.Memory 패키지 를 설치해야합니다 .

내가 여기에 언급하지 않은 또 다른 가능성 : Buffer.BlockCopy ()는 Array.Copy ()보다 약간 빠르며 프리미티브 배열에서 즉석에서 변환 할 수 있다는 추가 이점이 있습니다 (예 : 짧음 [])를 바이트 배열로 변환하면 소켓을 통해 전송해야하는 숫자 형 배열이있을 때 편리합니다.

당신이 원한다면 IEnumerable<byte>, 그냥

IEnumerable<byte> data = foo.Take(x);

다음은 슬라이스를 새 배열로 반환하는 간단한 확장 메서드입니다.

public static T[] Slice<T>(this T[] arr, uint indexFrom, uint indexTo) {
    if (indexFrom > indexTo) {
        throw new ArgumentOutOfRangeException("indexFrom is bigger than indexTo!");
    }

    uint length = indexTo - indexFrom;
    T[] result = new T[length];
    Array.Copy(arr, indexFrom, result, 0, length);

    return result;
}

그런 다음 다음과 같이 사용할 수 있습니다.

byte[] slice = foo.Slice(0, 40);

LINQ 또는 다른 확장 을 추가하지 않으려면 다음을 수행하십시오.

float[] subArray = new List<float>(myArray).GetRange(0, 8).ToArray();

이 (비평가) 코드와 같이 원래 배열 (IList) 주위에 래퍼를 사용할 수 있습니다.

public class SubList<T> : IList<T>
{
    #region Fields

private readonly int startIndex;
private readonly int endIndex;
private readonly int count;
private readonly IList<T> source;

#endregion

public SubList(IList<T> source, int startIndex, int count)
{
    this.source = source;
    this.startIndex = startIndex;
    this.count = count;
    this.endIndex = this.startIndex + this.count - 1;
}

#region IList<T> Members

public int IndexOf(T item)
{
    if (item != null)
    {
        for (int i = this.startIndex; i <= this.endIndex; i++)
        {
            if (item.Equals(this.source[i]))
                return i;
        }
    }
    else
    {
        for (int i = this.startIndex; i <= this.endIndex; i++)
        {
            if (this.source[i] == null)
                return i;
        }
    }
    return -1;
}

public void Insert(int index, T item)
{
    throw new NotSupportedException();
}

public void RemoveAt(int index)
{
    throw new NotSupportedException();
}

public T this[int index]
{
    get
    {
        if (index >= 0 && index < this.count)
            return this.source[index + this.startIndex];
        else
            throw new IndexOutOfRangeException("index");
    }
    set
    {
        if (index >= 0 && index < this.count)
            this.source[index + this.startIndex] = value;
        else
            throw new IndexOutOfRangeException("index");
    }
}

#endregion

#region ICollection<T> Members

public void Add(T item)
{
    throw new NotSupportedException();
}

public void Clear()
{
    throw new NotSupportedException();
}

public bool Contains(T item)
{
    return this.IndexOf(item) >= 0;
}

public void CopyTo(T[] array, int arrayIndex)
{
    for (int i=0; i<this.count; i++)
    {
        array[arrayIndex + i] = this.source[i + this.startIndex];
    }
}

public int Count
{
    get { return this.count; }
}

public bool IsReadOnly
{
    get { return true; }
}

public bool Remove(T item)
{
    throw new NotSupportedException();
}

#endregion

#region IEnumerable<T> Members

public IEnumerator<T> GetEnumerator()
{
    for (int i = this.startIndex; i < this.endIndex; i++)
    {
        yield return this.source[i];
    }
}

#endregion

#region IEnumerable Members

IEnumerator IEnumerable.GetEnumerator()
{
    return GetEnumerator();
}

#endregion

}

byte[] foo = new byte[4096]; 

byte[] bar = foo.Take(40).ToArray();

바이트 배열의 경우 System.Buffer.BlockCopy 는 최상의 성능을 제공합니다.

테이크 확장 방법을 사용할 수 있습니다

var array = new byte[] {1, 2, 3, 4};
var firstTwoItems = array.Take(2);

이것은 다음과 같은 해결책 일 수 있습니다.

var result = foo.Slice(40, int.MaxValue);

그런 다음 결과 는 IEnumerable <IEnumerable <byte >> 이고 첫 번째 IEnumerable <byte> 은 foo 의 첫 40 바이트를 포함하고 두 번째 IEnumerable <byte>입니다. 는 나머지를 보유합니다.

래퍼 클래스를 작성했는데 전체 반복이 게으 르며 도움이되기를 바랍니다.

public static class CollectionSlicer
{
    public static IEnumerable<IEnumerable<T>> Slice<T>(this IEnumerable<T> source, params int[] steps)
    {
        if (!steps.Any(step => step != 0))
        {
            throw new InvalidOperationException("Can't slice a collection with step length 0.");
        }
        return new Slicer<T>(source.GetEnumerator(), steps).Slice();
    }
}

public sealed class Slicer<T>
{
    public Slicer(IEnumerator<T> iterator, int[] steps)
    {
        _iterator = iterator;
        _steps = steps;
        _index = 0;
        _currentStep = 0;
        _isHasNext = true;
    }

    public int Index
    {
        get { return _index; }
    }

    public IEnumerable<IEnumerable<T>> Slice()
    {
        var length = _steps.Length;
        var index = 1;
        var step = 0;

        for (var i = 0; _isHasNext; ++i)
        {
            if (i < length)
            {
                step = _steps[i];
                _currentStep = step - 1;
            }

            while (_index < index && _isHasNext)
            {
                _isHasNext = MoveNext();
            }

            if (_isHasNext)
            {
                yield return SliceInternal();
                index += step;
            }
        }
    }

    private IEnumerable<T> SliceInternal()
    {
        if (_currentStep == -1) yield break;
        yield return _iterator.Current;

        for (var count = 0; count < _currentStep && _isHasNext; ++count)
        {
            _isHasNext = MoveNext();

            if (_isHasNext)
            {
                yield return _iterator.Current;
            }
        }
    }

    private bool MoveNext()
    {
        ++_index;
        return _iterator.MoveNext();
    }

    private readonly IEnumerator<T> _iterator;
    private readonly int[] _steps;
    private volatile bool _isHasNext;
    private volatile int _currentStep;
    private volatile int _index;
}

C #이 Range 의미를 지원하지 않는다고 생각합니다. 그래도 확장 방법을 작성할 수 있습니다.

public static IEnumerator<Byte> Range(this byte[] array, int start, int end);

그러나 다른 사람들이 말했듯이 시작 색인을 설정할 필요 Take가 없다면 필요한 것입니다.

다음은 제네릭을 사용하고 PHP 함수 array_slice 처럼 동작하는 확장 함수입니다 . 음수 오프셋과 길이가 허용됩니다.

public static class Extensions
{
    public static T[] Slice<T>(this T[] arr, int offset, int length)
    {
        int start, end;

        // Determine start index, handling negative offset.
        if (offset < 0)
            start = arr.Length + offset;
        else
            start = offset;

        // Clamp start index to the bounds of the input array.
        if (start < 0)
            start = 0;
        else if (start > arr.Length)
            start = arr.Length;

        // Determine end index, handling negative length.
        if (length < 0)
            end = arr.Length + length;
        else
            end = start + length;

        // Clamp end index to the bounds of the input array.
        if (end < 0)
            end = 0;
        if (end > arr.Length)
            end = arr.Length;

        // Get the array slice.
        int len = end - start;
        T[] result = new T[len];
        for (int i = 0; i < len; i++)
        {
            result[i] = arr[start + i];
        }
        return result;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace data_seniens
{
    class Program
    {
        static void Main(string[] args)
        {
            //new list
            float [] x=new float[]{11.25f,18.0f,20.0f,10.75f,9.50f, 11.25f, 18.0f, 20.0f, 10.75f, 9.50f };

            //variable
            float eat_sleep_area=x[1]+x[3];
            //print
            foreach (var VARIABLE in x)
            {
                if (VARIABLE < x[7])
                {
                    Console.WriteLine(VARIABLE);
                }
            }



            //keep app run
        Console.ReadLine();
        }
    }
}