Convert डेटाप्रकार बाइट सरणी

Question

मैं बाइट्स मूल्यों (सी # में डबल/नाव) बदलने और कुछ मदद की ज़रूरत है करने के लिए 'लंबी' ..

// डाटाटाइप लंबे 4byte -99999999,99 99999999,99
को // डाटाटाइप लंबे 4byte -99999999,9 को 99999999,9
// डाटाटाइप कम 2byte -999,99 999,99 के लिए
// डाटाटाइप कम 2byte -999,9 को 999,9

में मेरी " घर पर दुनिया "मैं बस इसे स्ट्रिंग और ASCII.GetBytes() होगा।

लेकिन अब, इस दुनिया में, हमें कम संभव स्थान बनाना है।
और वास्तव में '-99 99 99 99,99' 4 की बजाय 12 बाइट्स लेता है! अगर यह एक 'लंबा' डेटाटाइप है।

[संपादित करें]
कुछ मदद करने के लिए और जवाब मैं यहाँ कुछ परिणाम देते हैं कारण,

long lng = -9999999999L; 
byte[] test = Encoding.ASCII.GetBytes(lng.ToString()); // 11 byte 
byte[] test2 = BitConverter.GetBytes(lng);    // 8 byte 
byte[] mybyt = BitConverter.GetBytes(lng);    // 8 byte 
byte[] bA = BitConverter.GetBytes(lng);     // 8 byte 

अभी भी एक विस्तार पता लगाने के लिए छोड़ दिया रहना होगा। Lng-variabel को 8 बाइट मिलते हैं, भले ही इसमें कम मान हों, यानी 99 951 (मैं ToString() नमूना शामिल नहीं करूंगा)।

यदि मान भी "छोटा" है, जिसका अर्थ है- 999,99 - 999,99 इसमें केवल 2 बाइट स्पेस लगेगा।
[अंत संपादित करें]

Answer 1

पता है कि 2 बाइट्स में आप केवल 4 पूर्ण हो सकता है हो सकता है अंक + चिह्न, और 4 बाइट्स में आपके पास केवल 9 अंक + चिह्न हो सकते हैं, इसलिए मुझे तदनुसार अपने प्रीरेक स्केल करना पड़ा।

public static byte[] SerializeLong2Dec(double value) 
{ 
    value *= 100; 
    value = Math.Round(value, MidpointRounding.AwayFromZero); 

    if (value < -999999999.0 || value > 999999999.0) 
    { 
     throw new ArgumentOutOfRangeException(); 
    } 

    int value2 = (int)value; 

    return BitConverter.GetBytes(value2); 
} 

public static double DeserializeLong2Dec(byte[] value) 
{ 
    int value2 = BitConverter.ToInt32(value, 0); 
    return (double)value2/100.0; 
} 

public static byte[] SerializeLong1Dec(double value) { 
    value *= 10; 
    value = Math.Round(value, MidpointRounding.AwayFromZero); 

    if (value < -999999999.0 || value > 999999999.0) { 
     throw new ArgumentOutOfRangeException(); 
    } 

    int value2 = (int)value; 

    return BitConverter.GetBytes(value2); 
} 

public static double DeserializeLong1Dec(byte[] value) { 
    int value2 = BitConverter.ToInt32(value, 0); 
    return (double)value2/10.0; 
} 

public static byte[] SerializeShort2Dec(double value) { 
    value *= 100; 
    value = Math.Round(value, MidpointRounding.AwayFromZero); 

    if (value < -9999.0 || value > 9999.0) { 
     throw new ArgumentOutOfRangeException(); 
    } 

    short value2 = (short)value; 

    return BitConverter.GetBytes(value2); 
} 

public static double DeserializeShort2Dec(byte[] value) { 
    short value2 = BitConverter.ToInt16(value, 0); 
    return (double)value2/100.0; 
} 

public static byte[] SerializeShort1Dec(double value) { 
    value *= 10; 
    value = Math.Round(value, MidpointRounding.AwayFromZero); 

    if (value < -9999.0 || value > 9999.0) { 
     throw new ArgumentOutOfRangeException(); 
    } 

    short value2 = (short)value; 

    return BitConverter.GetBytes(value2); 
} 

public static double DeserializeShort1Dec(byte[] value) { 
    short value2 = BitConverter.ToInt16(value, 0); 
    return (double)value2/10.0; 
} 

ताकि यह स्पष्ट है, एक की सीमा (हस्ताक्षरित) कम (16 बिट) 32,767 के -32,768 है तो यह काफी स्पष्ट है कि आप केवल 4 पूर्ण अंक के साथ साथ एक छोटा सा टुकड़ा (0-3) है , एक (हस्ताक्षरित) int (32 बिट्स) की श्रेणी -2,147,483,648 से 2,147,483,647 है, इसलिए यह स्पष्ट है कि आपके पास केवल 9 पूर्ण अंक और थोड़ा टुकड़ा (0-2) है। एक (हस्ताक्षरित) लंबे (64 बिट्स) पर जाकर आपके पास -9,223,372,036,854,775,808 से 9,223,372,036,854,775,807 हैं, इसलिए 18 अंक प्लस एक (बड़ा) टुकड़ा है। सटीकता में खोने वाले फ़्लोटिंग पॉइंट्स का उपयोग करना। एक फ्लोट (32 बिट्स) में लगभग 7 अंकों की सटीकता होती है, जबकि एक डबल (64 बिट्स) की लगभग 15-16 अंकों की सटीकता होती है।

Answer 2

आप BitConverter जाँच

long lng =-9999999999L; 
byte[] mybyt = BitConverter.GetBytes(lng); 

आशा है कि यह आप क्या देख रहे हैं इस तरह से यह करने के लिए

Answer 3

कोशिश है है:

long l = 4554334; 

byte[] bA = BitConverter.GetBytes(l); 

Answer 4

long longValue = 9999999999L; 

     Console.WriteLine("Long value: " + longValue.ToString()); 

     bytes = BitConverter.GetBytes(longValue); 

     Console.WriteLine("Byte array value:"); 

     Console.WriteLine(BitConverter.ToString(bytes)); 

Answer 5

जैसा कि अन्य उत्तरों ने इंगित किया है, आप प्राचीन प्रकार के बाइट प्रतिनिधित्व प्राप्त करने के लिए BitConverter का उपयोग कर सकते हैं।

तुमने कहा वर्तमान विश्व आप में निवास में, वहाँ के रूप में संक्षेप में संभव के रूप में, जिस स्थिति में आप पर विचार करना चाहिए variable length encoding (हालांकि उस दस्तावेज़ थोड़ा सार हो सकता है) इन मूल्यों का प्रतिनिधित्व करने पर एक जिम्मेदारी है।

यदि आप तय इस दृष्टिकोण अपने मामले के लिए लागू मैं कैसे इन प्रकार के कुछ के रूप में Protocol Buffers परियोजना represents scalar types चर लंबाई एन्कोडिंग जो कम उत्पादन का उत्पादन करता है, तो डेटा सेट छोटे शुद्ध मान के पक्ष में है का उपयोग कर इनकोड पर रखने का सुझाव देते हैं। (परियोजना एक New BSD license के तहत खुला स्रोत है, तो आप तकनीक source repository से कार्यरत जानने के लिए या यहां तक ​​कि अपने खुद के परियोजना में स्रोत का उपयोग करने में सक्षम हो जाएगा।)