c# - कन्वर्ट बाइट[] मूल 2 डी सरणी के लिए




arrays byte (2)

आप मूल आयाम नहीं प्राप्त कर सकते उदाहरण:

8 बाइट्स = [0, 1, 0, 2, 0, 1, 0, 2]

16 बिट (2 बाइट्स) की सरणी में: = [1, 2, 1, 2]

64 बिट (4 बाइट) की सरणी में: = [65538, 65538]

और इन सभी तरीकों (1 बाइट, 2 बाइट्स, 4 बाइट्स) पार्स करने के लिए मान्य हैं, इसलिए आपको अपने मूल आकार, या उनमें से कम से कम एक को इंगित करना चाहिए। सौभाग्य से आप अनुरोध के शीर्ष लेखों में आकार (या आकार) भेज सकते हैं यह आप क्या चाहते हैं, यह चाल के लिए कर सकते हैं। यह करने का एक और तरीका है जो सीरियल सिस्टम करता है: बस अपने आकार (या आकार) और आपके बफर को दबाएं

आकार [4 बाइट्स = इंट 32] + बफर [एन बाइट्स]

अंत में पहले बाइट्स को पार्स करने के लिए आकार और ब्लॉक की प्रतिलिपि पढ़ने के लिए अपने बफ़र के 1 पहले बाइट से शुरू करें (ऑफसेट को मत भूलें। ऊपर दिए गए उदाहरण में बाइट संख्या 5 से प्रतिलिपि बनाना शुरू करना चाहिए)

मैंने UINT16 मानों की एक 2 डी सरणी ली है, और उसे कच्चे बाइट्स में परिवर्तित कर दिया है। मैं उन बाइटों को ले जाना चाहता हूं और उन्हें मूल 2 डी सरणी में वापस रूपांतरित करना चाहता हूं, लेकिन मुझे यह अनिश्चित है कि यह कैसे करना है जब मेरे पास केवल बाइट्स होते हैं, यानी, एक मूल सरणी के आयामों को निर्धारित करने का एक तरीका है, जब सभी आपके पास बाइट में परिवर्तित सरणी है?

यहां मेरा कोड है:

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]);
}

यह कोड बाइट्स को 1-आयामी सरणी में डाल देगा, लेकिन मैं उन्हें मूल 2 डी सरणी में रखना चाहता हूं। क्या यह संभव है जब सभी मेरे पास कच्चे बाइट हैं? मैं अंत में इन बाइट्स को एक बाकी कॉल के जरिए भेजूंगा और प्राप्त पक्ष में मूल 2 डी सरणी में वापस कन्वर्ट करने के लिए केवल बाइट होंगे।


इसलिए ... निश्चित नहीं कि आप विशिष्ट रूप से विशिष्ट हैं, लेकिन आप अपने बफर के पहले चार बाइट्स के रूप में सरणी के आयाम (एक्स, वाई) भेज सकते हैं। नीचे इस पर मेरी दरार है मैंने भारी टिप्पणी की तो उम्मीद है कि इसे वहां जाना चाहिए। कोई प्रश्न पूछें अगर वह कोड स्पष्ट नहीं है।

  /**** 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();




type-conversion