Konvertiere Byte [] in UInt16.

Question

Ich habe ein 2d-Array von UInt16s, die ich in rohe Bytes konvertiert habe - ich möchte diese Bytes nehmen und sie zurück in das ursprüngliche 2D-Array konvertieren. Ich habe es geschafft, dies mit einem 2D-Array von Doppel zu machen, aber ich kann nicht herausfinden, wie es mit UInt16 geht.

Hier ist mein Code:

UInt16[,] dataArray; 
//This array is populated with this data: 
[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(newUint16Array, 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/8]; 
for (int i = 0; i < 5; i++) 
{ 
    originalUInt16Values[i] = BitConverter.ToUInt16(bufferUInt16, i * 8); 
    Console.WriteLine("Values: " + originalUInt16Values[i]); 
} 

Die print-Anweisung zeigt nicht die gleichen Werte wie die ursprünglichen 2D-Array. Ich bin ziemlich neu beim Codieren mit Bytes und UInt16, also lerne ich das meiste dabei.

* Außerdem weiß ich, dass der letzte Teil meines Codes keine Werte in ein 2D-Array wie das ursprüngliche Array schreibt - im Moment versuche ich nur die Werte auszudrucken, um zu sehen, ob sie sogar mit den Originaldaten übereinstimmen .

Answer 1

Wenn das, was Sie wollen, nur werfen UInt16 [,] -> Byte und dann Byte-> UInt16 können Sie das andere tun Blockkopie, die zur Laufzeit ist sehr schnell, Code sollte wie folgt aussehen:

UInt16[,] dataArray = new UInt16[,] { 
    {4, 6, 2}, 
    {0, 2, 0}, 
    {1, 3, 4} 
}; 
for (int j = 0; j < 3; j++) 
{ 
    for (int i = 0; i < 3; i++) 
    { 
     Console.WriteLine("Value[" + i + ", " + j + "] = " + dataArray[j,i]); 
    } 
} 
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++) 
{ 
    //originalUInt16Values[i] = BitConverter.ToUInt16(bufferUInt16, i * 8); 
    Console.WriteLine("Values---: " + originalUInt16Values[i]); 
} 

durch die Art und Weise, unterteilt man nur jedes UInt16 in zwei Bytes, so dass Sie Ihre neue Größe durch zwei geteilt berechnen soll , nicht acht

Answer 2

Ihr Casting, so sollten Sie in der Lage, Dinge zu tun implizit

var list = new List<byte> { 1, 2 , 
var uintList = new List<UInt16>(); 

//Cast in your select 
uintList = list.Select(x => (UInt16)x).ToList(); 

Answer 3

Das Programm

public static void Main(string[] args) 
    { 
     UInt16[,] dataArray = new ushort[,]{ {4,6,2}, {0,2,0}, {1,3,4}}; 
     //This array is populated with this data: 

     long byteCountUInt16Array = dataArray.GetLength(0) * dataArray.GetLength(1) * sizeof(UInt16); 

     var byteBuffer = new byte[byteCountUInt16Array]; 
     Buffer.BlockCopy(dataArray, 0, byteBuffer, 0, byteBuffer.Length); 

     for(int i=0; i < byteBuffer.Length; i++) { 
      Console.WriteLine("byteBuf[{0}]= {1}", i, byteBuffer[i]); 
     } 


     Console.WriteLine("Byte buffer len: {0} data array len: {1}", byteBuffer.Length, dataArray.GetLength(0)* dataArray.GetLength(1)); 
     UInt16[] originalUInt16Values = new UInt16[byteBuffer.Length/2]; 
     for (int i = 0; i < byteBuffer.Length; i+=2) 
     { 
      ushort _a = (ushort)((byteBuffer[i]) | (byteBuffer[i+1]) << 8); 
      originalUInt16Values[i/2] = _a; 
      Console.WriteLine("Values: " + originalUInt16Values[i/2]); 
     } 
    } 

Ausgänge

byteBuf[0]= 4 
byteBuf[1]= 0 
byteBuf[2]= 6 
byteBuf[3]= 0 
byteBuf[4]= 2 
byteBuf[5]= 0 
byteBuf[6]= 0 
byteBuf[7]= 0 
byteBuf[8]= 2 
byteBuf[9]= 0 
byteBuf[10]= 0 
byteBuf[11]= 0 
byteBuf[12]= 1 
byteBuf[13]= 0 
byteBuf[14]= 3 
byteBuf[15]= 0 
byteBuf[16]= 4 
byteBuf[17]= 0 
Byte buffer len: 18 data array len: 9 
Values: 4 
Values: 6 
Values: 2 
Values: 0 
Values: 2 
Values: 0 
Values: 1 
Values: 3 
Values: 4 

Sie sehen, dass ein ushort, auch bekannt als UInt16 gespeichert in einer Byte-Reihenfolge, in der 4 = 0x04 0x00, die i der Grund, warum ich die Umrechnungsformel wählte

  ushort _a = (ushort)((byteBuffer[i]) | (byteBuffer[i+1]) << 8); 

, die die byte bei Index i und nehmen Sie die nächsten byte bei i+1 und Verschiebung nach links durch die Größe eines Byte (8 Bit) zu bilden, die 16 Bits greifen werden a ushort. In orhter Worten, ushort _a = 0x[second byte] 0x[first byte], die dann wiederholt wird. Dieser Konvertierungscode ist spezifisch für die Endgültigkeit der Maschine, auf der Sie sich befinden, und ist daher nicht portabel.

Auch ich reparierte den Fehler, wo das byteBuffer Array zu groß war, weil es mit Faktor 8 multipliziert wurde. Eine ushort ist doppelt so groß wie eine byte, daher brauchen wir nur Faktor 2 in der Array-Länge.

Answer 4

den Titel Ihrer Frage Adressierung (Rechnen byte [] zu UInt16):

UInt16 result = (UInt16)BitConverter.ToInt16(yourByteArray, startIndex = 0);