example - string to byte array c#

Convierta byte[] a matriz 2d original

Question

Tomé una matriz 2D de valores UInt16 y la convertí en bytes sin formato. Me gustaría tomar esos bytes y convertirlos nuevamente en la matriz 2D original, pero no estoy seguro de cómo hacerlo cuando solo tengo los bytes, es decir, ¿hay alguna manera de determinar las dimensiones de una matriz original cuando todo tienes es esa matriz convertida en bytes?

Aquí está mi código:

UInt16[,] dataArray = new UInt16[,] {
{4, 6, 2},
{0, 2, 0},
{1, 3, 4}
};
long byteCountUInt16Array = dataArray.GetLength(0) * dataArray.GetLength(1) * sizeof(UInt16);
var bufferUInt16 = new byte[byteCountUInt16Array];
Buffer.BlockCopy(dataArray, 0, bufferUInt16, 0, bufferUInt16.Length);
//Here is where I try to convert the values and print them out to see if the values are still the same:
UInt16[] originalUInt16Values = new UInt16[bufferUInt16.Length / 2];
Buffer.BlockCopy(bufferUInt16, 0, originalUInt16Values, 0, BufferUInt16.Length);
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Values---: " + originalUInt16Values[i]);
}

Este código pondrá los bytes en una matriz de 1 dimensión, pero me gustaría ponerlos en la matriz 2d original. ¿Es esto posible si todo lo que tengo son los bytes sin formato? Eventualmente estaré enviando estos bytes a través de una llamada REST y el lado receptor solo tendrá los bytes para convertir de nuevo a la matriz 2D original.

Answer 1

Entonces ... no estoy seguro de cuáles son sus especificaciones, pero podría enviar las dimensiones (x, y) de la matriz como los primeros cuatro bytes de su búfer. abajo está mi grieta en eso. Lo comenté fuertemente, así que espero que tenga sentido allí. Haga cualquier pregunta si ese código no está claro.

 /**** SENDER *****/
// ushort and UInt16 are the same (16-bit, 2 bytes)
ushort[,] dataArray = new ushort[,] {
{4, 6, 2},
{0, 2, 0},
{1, 3, 4}
};
// get the X and Y dimensions
ushort xDim = (ushort)dataArray.GetLength(0);
ushort yDim = (ushort)dataArray.GetLength(1);
// Make an array for the entire 2D array and the dimension sizes
ushort[] toSend = new ushort[xDim * yDim + 2];
// load the dimensions into first two spots in the array
toSend[0] = xDim;
toSend[1] = yDim;
// load everything else into the array
int pos = 2;
for (int i = 0; i < xDim; i++)
{
for (int j = 0; j < yDim; j++)
{
toSend[pos] = dataArray[i, j];
pos += 1;
}
}
// size of the array in bytes
long byteCountUInt16Array = sizeof(ushort) * (xDim * yDim + 2);
// create the byte buffer
var bufferUInt16 = new byte[byteCountUInt16Array];
// copy everything (including dimensions) into the byte beffer
Buffer.BlockCopy(toSend, 0, bufferUInt16, 0, bufferUInt16.Length);
/***********RECEIVER************/
// get the dimensions from the received bytes
ushort[] xyDim = new ushort[2];
Buffer.BlockCopy(bufferUInt16, 0, xyDim, 0, sizeof(ushort) * 2);
// create buffer to read the bytes as ushorts into, size it based off of
// dimensions received.
ushort[] readIn = new ushort[xyDim[0] * xyDim[1]];
Buffer.BlockCopy(bufferUInt16, sizeof(ushort) * 2, readIn, 0, sizeof(ushort) * readIn.Length);
// create 2D array to load everything into, size based off of received sizes
ushort[,] originalUInt16Values = new ushort[xyDim[0], xyDim[1]];
// load everything in
int cur = 0;
for (int i = 0; i < xyDim[0]; i++)
{
for (int j = 0; j < xyDim[1]; j++)
{
originalUInt16Values[i, j] = readIn[cur];
cur += 1;
}
}
// print everything out to prove it works
for (int i = 0; i < xyDim[0]; i++)
{
for (int j = 0; j < xyDim[1]; j++)
{
Console.WriteLine("Values at {0},{1}: {2}", i, j, originalUInt16Values[i, j]);
}
}
// uhh... keep the console open
Console.ReadKey();

Answer 2

No puedes obtener las dimensiones originales. Ejemplo:

8 bytes = [0, 1, 0, 2, 0, 1, 0, 2]

en una matriz de 16 bits (2 bytes): = [1, 2, 1, 2]

en una matriz de 64 bits (4 bytes): = [65538, 65538]

y todas estas formas (1 byte, 2 bytes, 4 bytes) son válidas para el análisis sintáctico, por lo que debe indicar sus tamaños originales, o al menos uno de ellos. Por suerte, puede enviar los tamaños (o tamaños) en los encabezados de la solicitud. Esto puede hacer el truco para lo que quieras. Otra forma de hacerlo es lo que hacen los sistemas en serie: simplemente concatena tu tamaño (o tamaños) y tu memoria intermedia.

tamaño [4 bytes = Int32] + búfer [n bytes]

finalmente analiza los primeros bytes para leer el tamaño y bloquea la copia comenzando desde 1 primer byte de tu búfer (no olvides el desplazamiento. En el ejemplo anterior, debes comenzar a copiar bloques desde el número de bytes 5)