c# कहत कैसे एक बाइट सरणी विभाजित




बिट और बाइट के बीच का अंतर (6)

मेरी स्मृति में एक बाइट सरणी है, एक फ़ाइल से पढ़ें। मैं एक निश्चित बिंदु (इंडेक्स) पर बाइट सरणी को सिर्फ एक नई बाइट सरणी बनाने और एक बार में प्रत्येक बाइट की प्रतिलिपि बनाने के बिना, ऑपरेशन के मेमोरी पैंट प्रिंट में बढ़ाना चाहता हूं। मैं क्या चाहूंगा, ऐसा कुछ है:

byte[] largeBytes = [1,2,3,4,5,6,7,8,9];  
byte[] smallPortion;  
smallPortion = split(largeBytes, 3);  

smallPortion 1,2,3,4 के बराबर होगा
largeBytes 5,6,7,8,9 के बराबर होगा


जैसा कि ईरेन ने कहा , आप ArraySegment<T> उपयोग कर सकते हैं। यहां एक एक्सटेंशन विधि और उपयोग का उदाहरण दिया गया है:

public static class ArrayExtensionMethods
{
    public static ArraySegment<T> GetSegment<T>(this T[] arr, int offset, int? count = null)
    {
        if (count == null) { count = arr.Length - offset; }
        return new ArraySegment<T>(arr, offset, count.Value);
    }
}

void Main()
{
    byte[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    var p1 = arr.GetSegment(0, 5);
    var p2 = arr.GetSegment(5);
    Console.WriteLine("First array:");
    foreach (byte b in p1)
    {
        Console.Write(b);
    }
    Console.Write("\n");
    Console.WriteLine("Second array:");
    foreach (byte b in p2)
    {
        Console.Write(b);
    }
}

ऐसा मैं कैसे कर सकता हूं:

using System;
using System.Collections;
using System.Collections.Generic;

class ArrayView<T> : IEnumerable<T>
{
    private readonly T[] array;
    private readonly int offset, count;

    public ArrayView(T[] array, int offset, int count)
    {
        this.array = array;
        this.offset = offset;
        this.count = count;
    }

    public int Length
    {
        get { return count; }
    }

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

    public IEnumerator<T> GetEnumerator()
    {
        for (int i = offset; i < offset + count; i++)
            yield return array[i];
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        IEnumerator<T> enumerator = this.GetEnumerator();
        while (enumerator.MoveNext())
        {
            yield return enumerator.Current;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        byte[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
        ArrayView<byte> p1 = new ArrayView<byte>(arr, 0, 5);
        ArrayView<byte> p2 = new ArrayView<byte>(arr, 5, 5);
        Console.WriteLine("First array:");
        foreach (byte b in p1)
        {
            Console.Write(b);
        }
        Console.Write("\n");
        Console.WriteLine("Second array:");
        foreach (byte b in p2)
        {
            Console.Write(b);
        }
        Console.ReadKey();
    }
}

आप नहीं कर सकते आप जो चाहते हैं, वह शुरुआती बिंदु और वस्तुओं की संख्या रखता है; संक्षेप में, iterators का निर्माण यदि यह सी ++ है, तो आप केवल std::vector<int> का उपयोग कर सकते हैं और बिल्ट-इन वाले का उपयोग कर सकते हैं।

सी # में, मैं एक छोटी इटरेटर क्लास का निर्माण करता हूं जो प्रारंभ सूचकांक रखता है, गणना करता है और IEnumerable<> लागू करता है IEnumerable<>


सी # में Linq में आप यह कर सकते हैं:

smallPortion = largeBytes.Take(4).ToArray();
largeBytes = largeBytes.Skip(4).Take(5).ToArray();

;)


FYI करें। System.ArraySegment<T> संरचना मूलतः एक ही चीज़ है, जैसा कि ऊपर कोड में ArrayView<T> है। यदि आप चाहें तो इस तरह से आउट-ऑफ-बॉक्स संरचना का उपयोग कर सकते हैं।


इसको आजमाओ:

private IEnumerable<byte[]> ArraySplit(byte[] bArray, int intBufforLengt)
    {
        int bArrayLenght = bArray.Length;
        byte[] bReturn = null;

        int i = 0;
        for (; bArrayLenght > (i + 1) * intBufforLengt; i++)
        {
            bReturn = new byte[intBufforLengt];
            Array.Copy(bArray, i * intBufforLengt, bReturn, 0, intBufforLengt);
            yield return bReturn;
        }

        int intBufforLeft = bArrayLenght - i * intBufforLengt;
        if (intBufforLeft > 0)
        {
            bReturn = new byte[intBufforLeft];
            Array.Copy(bArray, i * intBufforLengt, bReturn, 0, intBufforLeft);
            yield return bReturn;
        }
    }




split