Chuyển đổi kiểu dữ liệu 'dài' để byte mảng

Question

Tôi phải chuyển đổi các giá trị (double/float trong C#) để byte và cần một số giúp đỡ ..

// Datatype dài 4byte -99999999,99 để 99999999,99
// Datatype dài 4byte -99999999,9 để 99999999,9
// Datatype 2byte ngắn -999,99 đến 999,99
// Datatype 2byte ngắn -999,9 để hạt 999,9

Trong tôi " thế giới ở nhà "tôi sẽ chỉ chuỗi nó và ASCII.GetBytes().

Nhưng bây giờ, trong thế giới này, chúng ta phải tạo ra ít không gian có thể.
Và thực tế là '-99999999,99' mất 12 byte thay vì 4 byte! nếu đó là kiểu dữ liệu 'dài'.

[EDIT]
Do một số sự giúp đỡ và trả lời tôi đính kèm một số kết quả ở đây,

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 

Vẫn phải một chi tiết còn lại để tìm hiểu. Giá trị lng-variabel nhận được 8 byte ngay cả khi nó có giá trị thấp hơn, tức là 99951 (tôi sẽ không bao gồm mẫu ToString()).

Nếu giá trị thậm chí còn "ngắn hơn", nghĩa là -999,99 - 999,99, nó sẽ chỉ mất khoảng 2 byte.
[END EDIT]

Answer 1

Lưu ý rằng trong 2 byte bạn chỉ có thể có 4 đầy đủ chữ số + dấu, và trong 4 byte bạn chỉ có thể có 9 chữ số + dấu hiệu, vì vậy tôi đã phải quy mô prereqs của bạn cho phù hợp.

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

Vì vậy, nó là rõ ràng, phạm vi của một (đã ký) ngắn (16 bit) là -32,768 tới 32,767 vì vậy nó khá rõ ràng rằng bạn chỉ có 4 chữ số đầy đủ cộng với một mảnh nhỏ (các 0-3) , phạm vi của một (đã ký) int (32 bit) là −2,147,483,648 đến 2,147,483,647 vì vậy nó khá rõ ràng rằng bạn chỉ có 9 chữ số đầy đủ cộng với một mảnh nhỏ (0-2). Đi đến một (có chữ ký) dài (64 bit) bạn có -9,223,372,036,854,775,808 đến 9,223,372,036,854,775,807 để 18 chữ số cộng với một phần (lớn). Sử dụng các điểm nổi bạn mất chính xác. Một phao (32 bit) có độ chính xác khoảng 7 chữ số, trong khi một đôi (64 bit) có độ chính xác khoảng 15-16 chữ số.

Answer 2

Bạn đã kiểm tra BitConverter

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

hy vọng đây là những gì bạn đang tìm kiếm

Answer 3

Cố gắng làm điều đó theo cách này:

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

Như các câu trả lời khác đã chỉ ra, bạn có thể sử dụng BitConverter để có được biểu diễn byte của các kiểu nguyên thủy.

Bạn nói rằng trong thế giới hiện tại bạn sống, có một onus đại diện cho các giá trị này là chính xác càng tốt, trong trường hợp đó bạn nên xem xét variable length encoding (mặc dù tài liệu đó có thể là một chút trừu tượng).

Nếu bạn quyết định phương pháp này có thể áp dụng cho trường hợp của bạn, tôi khuyên bạn nên xem cách dự án represents scalar types như một số loại này được mã hóa bằng cách sử dụng mã hóa độ dài thay đổi. (Dự án là nguồn mở theo New BSD license, vì vậy bạn sẽ có thể tìm hiểu kỹ thuật được sử dụng từ source repository hoặc thậm chí sử dụng nguồn trong dự án của riêng bạn.)