如何从byte []数组中获取数组的一部分

Question

I have a byte[] array, mostly only part of array is used while the rest are 0x00. In this case, how can I get only the array elements that are needed and not the entire array? I have a int rxlen which would be the length of actual elements in the array.

Example:

byte[] framessent = {0xff, 0x53, 0x7e, 0x80, 0x00, 0x07, 0x60, 0x96, 0x2d, 0x00, 0x00.....} 
byte[] framereceived = {0xff, 0x53, 0x7e, 0x80, 0x00, 0x07, 0x60, 0x96, 0x2d, 0x00, 0x00.....}

framesent is usually 150 bytes, which I have a control on but framereceived is 300. I would like to simply compare the array elements (valid data) between framesent and framereceived and not the 0x00 that follows.

I tried using Buffer.BlockCopy and Array.Copy as follows but I still get the entire array and not the ones I need.

Buffer.BlockCopy(RxBuffer, 0, framereceived, 0, rxlen);

Answer 1

使用一些扩展方法，您可以从原始数组中获取rxlen ，如下所示：

var newArray = framereceived.Take(rxlen).ToArray();

Answer 2

I roughly have an idea of what you need (Apologies if I'm wrong). If you need to take the elements of framereceived that are not 0x00 , use Linq:

byte[] validbytes = framereceived.Where(frame => frame != 0x00).ToArray();

If you need to compare the data between the two arrays and get only the elements that are contained in both arrays, Linq can do that as well (My method might not be efficient):

byte[] validbytes = framereceived.Where(frame => framessent.Contains(frame)).ToArray();

If you need to take bytes from a specific index of a specific length, use .Skip() and .Take() .

Answer 3

If there is a possibility that your data arrives in several chunks, doing this check might be a little bit more complex, actually.

First of all, I would not use an array to store incoming data, but rather enqueue it in a FIFO (ie a Queue<byte> ). Meaning that your receiving event handler would look something like:

// this is the byte "producer" part
private readonly Queue<byte> _inputQueue = new Queue<byte>();
void OnDataReceived(byte[] data)
{
    foreach (var b in data)
        _inputQueue.Enqueue(b);  

    ConsumeData();
}

And then you "consume" the incoming data, which in your case means you would be comparing it to an array of fixed size, something like:

void ConsumeData()
{
    if (_inputQueue.Count < framessent.Length)
         return;

    int index = 0;
    foreach (var item in _inputQueue)
    {
        // item doesn't match?
        if (item != framessent[index++])
        {
            // data doesn't match
            OnFailed();
            return;
        }

        // reached the end of the array?
        if (index >= _inputQueue.Length)
        {
            // data matches
            OnSuccess();
            return;
        }
}

The following question you need to ask is what happens if the data indeed doesn't match (eg one of the bytes doesn't match). What do you do? Skipping a single byte and retrying might be the most sensible thing to do, meaning the ConsumeData method might be rewritten to look something like:

void ConsumeData()
{
    while (_inputQueue.Count < framessent.Length)
    {
        int index = 0;
        bool success = false;
        foreach (var item in _inputQueue)
        {
            // item doesn't match?
            if (item != framessent[index++])
            {
                // data doesn't match
                success = false;
                break;
            }

            // reached the end of the array?
            if (index >= _inputQueue.Length)
            {
                // data matches
                success = true;
                break;
            }
        }

        if (success)
        {
            OnSuccess();
            return;
        }
        else
        {
            // remove first byte and retry
            _inputQueue.Dequeue();
        }
    }
}

You will also need to take timeouts into account. If your ConsumeData method is not called in a while, it's a timeout and the operation should fail.