从程序中删除 byte[] 和 C# 中的 memory

Question

I'm making a program in which one of its functions, in order to correctly create the message to be sent, keeps calling a function I have generated to add each of the parts to the array. The thing is, in C# you can't do this because the byte arrays (and if I'm not wrong, any kind of array) has a finite Length which cannot be changed.

Due to this, I thought of creating 2 byte variables. The first one would get the first to values. The second one would be created after you know the quantity of new bytes you have to add, and after this, you would delete the first variable and create it again, with the Length of the previous variable, but adding the Length of the new values, doing the same you did with the second variable. The code I've generated is:

                byte[] message_mod_0 = adr_and_func;
                byte[] byte_memory_adr = AddAndTypes.ToByteArray(memory_adr);
                byte[] message_mod_1 = new byte[2 + byte_memory_adr.Length];
                message_mod_1 = AddAndTypes.AddByteArrayToByteArray(message_mod_0, byte_memory_adr);
                AddAndTypes.AddByteArrayToByteArray(message_mod_0, AddAndTypes.IntToByte(value));
                byte[] CRC = Aux.CRC(message_mod_0);
                AddAndTypes.AddByteArrayToByteArray(message_mod_0, CRC);

In this code, the two variables I've meant are message_mod_0 and message_mod_1. I also think of doing the deleting and redeclaring the byte_memory_adr variable that is required in order to know which is the Length of the byte array you want to add to the ouput message.

The parameters adr_and_func, memory_adr and value are given as input parameters of the function I'm making.

The question can be summed up as: is there any way to delete variables in the same scope they were created? And, in case it can be done, would there be any problem if I created a new variable with the same name after I have deleted the first one? I can't think of any reason why that could happen, but I'm pretty new to this programming language.

Also, I don't know if there is any less messy way of doing this.

Answer 1

This sounds like you are writing your own custom serializer.

I would recommend just using a existing library, like protobuf.net to define your messages if at all possible.

If this is not possible you can use a BinaryWriter to write your values to a Stream . If you want to keep it in memory use a MemoryStream and use.ToArray() when your done to get a array of all bytes.

As for memory, do not worry about it. Unless you have gigabyte sized messages the memory requirements should not be an issue, and the garbage collector will automatically recycle memory when it is no longer needed, and it can do this after the last usage, regardless of scope. If you have huge memory streams you might want to look at something like recyclable memory stream since this can avoid some allocation performance issues and fragmentation issues.