'फ्लोट' से 'बाइट [4]' में कनवर्ट करना और .NET माइक्रो फ्रेमवर्क

Question

को byte[4] और फिर वापस 'फ्लोट' में परिवर्तित करने का सबसे अच्छा तरीका क्या है?

मैं इसे सी # .NET Micro Framework में कर रहा हूं, इसलिए मेरे उपयोग के लिए BitConverter उपलब्ध नहीं है।

Answer 1

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

using System; 
using System.Diagnostics; 

namespace netduino 
{ 
    public static class BitConverter 
    { 
     public static byte[] GetBytes(uint value) 
     { 
      return new byte[4] { 
        (byte)(value & 0xFF), 
        (byte)((value >> 8) & 0xFF), 
        (byte)((value >> 16) & 0xFF), 
        (byte)((value >> 24) & 0xFF) }; 
     } 

     public static unsafe byte[] GetBytes(float value) 
     { 
      uint val = *((uint*)&value); 
      return GetBytes(val); 
     } 

     public static unsafe byte[] GetBytes(float value, ByteOrder order) 
     { 
      byte[] bytes = GetBytes(value); 
      if (order != ByteOrder.LittleEndian) 
      { 
       System.Array.Reverse(bytes); 
      } 
      return bytes; 
     } 

     public static uint ToUInt32(byte[] value, int index) 
     { 
      return (uint)(
       value[0 + index] << 0 | 
       value[1 + index] << 8 | 
       value[2 + index] << 16 | 
       value[3 + index] << 24); 
     } 

     public static unsafe float ToSingle(byte[] value, int index) 
     { 
      uint i = ToUInt32(value, index); 
      return *(((float*)&i)); 
     } 

     public static unsafe float ToSingle(byte[] value, int index, ByteOrder order) 
     { 
      if (order != ByteOrder.LittleEndian) 
      { 
       System.Array.Reverse(value, index, value.Length); 
      } 
      return ToSingle(value, index); 
     } 

     public enum ByteOrder 
     { 
      LittleEndian, 
      BigEndian 
     } 

     static public bool IsLittleEndian 
     { 
      get 
      { 
       unsafe 
       { 
        int i = 1; 
        char* p = (char*)&i; 

        return (p[0] == 1); 
       } 
      } 
     } 
    } 
} 

namespace BitConverterTest 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      byte[] msbFirst = new byte[] { 0x42, 0xF6, 0xE9, 0xE0 }; 
      byte[] lsbFirst = new byte[] { 0xE0, 0xE9, 0xF6, 0x42 }; 
      const float f = 123.456789F; 

      byte[] b = netduino.BitConverter.GetBytes(f, netduino.BitConverter.ByteOrder.BigEndian); 
      for (int i = 0; i < b.Length; i++) 
      { 
       Debug.Assert(msbFirst[i] == b[i], "BitConverter.GetBytes(float, BigEndian) i=" + i); 
      } 

      Debug.Assert(f == netduino.BitConverter.ToSingle(msbFirst, 0, netduino.BitConverter.ByteOrder.BigEndian)); 

      Console.WriteLine("All tests passed"); 
      Console.ReadKey(); 
     } 
    } 
} 

Answer 2

float को uint से रूपांतरण (और रिवर्स) "सुरक्षित" कोड के साथ किया जा सकता है के रूप में अच्छी तरह से (हालांकि मैं अगर यह NETMF पर संभव है या नहीं पता नहीं है)।

[StructLayout(LayoutKind.Explicit)] 
struct UIntFloat 
{  
    [FieldOffset(0)] 
    public float FloatValue; 

    [FieldOffset(0)] 
    public uint IntValue;   
} 

public static float ToSingle(byte[] value, int index)   
{   
    uint i = ToUInt32(value, index);    
    return ToSingle(i); 
} 

public static float ToSingle(uint value) 
{ 
    UIntFloat uf = new UIntFloat(); 
    uf.IntValue = value; 
    return uf.FloatValue; 
} 

Answer 3

यह मेरे लिए काम किया, सबसे पूरा जवाब लेकिन सरल

void floatToByte(GLubyte b[], float n) 
{ 
unsigned int val = *((unsigned int*)&n); 

b[0] = (GLubyte)(val & 0xFF); 
b[1] = (GLubyte)((val >> 8) & 0xFF); 
b[2] = (GLubyte)((val >> 16) & 0xFF); 
b[3] = (GLubyte)((val >> 24) & 0xFF); 
} 



float byteToFloat(GLubyte b[]) 
{ 
unsigned int ret = (unsigned int)(b[0] << 0 | b[1] << 8 | b[2] << 16 | b[3] << 24); 
float r = *(((float*)&ret)); 
return r; 
}