将数组数组转换为字节，反之亦然C＃

Question

我有以下C＃代码将我的数组数组转换为字节数组，然后将其保存为base64字符串，反之亦然，但它不适用于长因为长是8字节，我的代码仅适用于4字节数字。

private static int _endianDiff1; 
private static int _endianDiff2; 
private static int _idx; 
private static byte[] _byteBlock; 

enum ArrayType { Float, Int32, UInt32, Int64, UInt64 } 

public static bool SetIntArray(string key, int[] intArray) 
{ 
    return SetValue(key, intArray, ArrayType.Int32, 1, ConvertFromInt); 
} 

public static bool SetLongArray(string key, long[] longArray) 
{ 
    return SetValue(key, longArray, ArrayType.Int64, 1, ConvertFromLong); 
} 

private static bool SetValue<T>(string key, T array, ArrayType arrayType, int vectorNumber, Action<T, byte[], int> convert) where T : IList 
{ 
    var bytes = new byte[(4 * array.Count) * vectorNumber + 1]; 
    bytes[0] = Convert.ToByte(arrayType); // Identifier 
    Initialize(); 

    for (var i = 0; i < array.Count; i++) 
    { 
     convert(array, bytes, i); 
    } 
    return SaveBytes(key, bytes); 
} 

private static void ConvertFromInt(int[] array, byte[] bytes, int i) 
{ 
    ConvertInt32ToBytes(array[i], bytes); 
} 

private static void ConvertFromLong(long[] array, byte[] bytes, int i) 
{ 
    ConvertInt64ToBytes(array[i], bytes); 
} 

public static int[] GetIntArray(string key) 
{ 
    var intList = new List<int>(); 
    GetValue(key, intList, ArrayType.Int32, 1, ConvertToInt); 
    return intList.ToArray(); 
} 

public static long[] GetLongArray(string key) 
{ 
    var longList = new List<long>(); 
    GetValue(key, longList, ArrayType.Int64, 1, ConvertToLong); 
    return longList.ToArray(); 
} 

private static void GetValue<T>(string key, T list, ArrayType arrayType, int vectorNumber, Action<T, byte[]> convert) where T : IList 
{ 
    if (!PlayerPrefs.HasKey(key)) 
     return; 
    var bytes = Convert.FromBase64String(PlayerPrefs.GetString(key)); 
    if ((bytes.Length - 1) % (vectorNumber * 4) != 0) 
    { 
     Debug.LogError("Corrupt preference file for " + key); 
     return; 
    } 
    if ((ArrayType)bytes[0] != arrayType) 
    { 
     Debug.LogError(key + " is not a " + arrayType + " array"); 
     return; 
    } 
    Initialize(); 

    var end = (bytes.Length - 1)/(vectorNumber * 4); 
    for (var i = 0; i < end; i++) 
    { 
     convert(list, bytes); 
    } 
} 

private static void ConvertToInt(List<int> list, byte[] bytes) 
{ 
    list.Add(ConvertBytesToInt32(bytes)); 
} 

private static void ConvertToLong(List<long> list, byte[] bytes) 
{ 
    list.Add(ConvertBytesToInt64(bytes)); 
} 

private static void Initialize() 
{ 
    if (BitConverter.IsLittleEndian) 
    { 
     _endianDiff1 = 0; 
     _endianDiff2 = 0; 
    } 
    else 
    { 
     _endianDiff1 = 3; 
     _endianDiff2 = 1; 
    } 
    if (_byteBlock == null) 
    { 
     _byteBlock = new byte[4]; 
    } 
    _idx = 1; 
} 

private static bool SaveBytes(string key, byte[] bytes) 
{ 
    try 
    { 
     PlayerPrefs.SetString(key, Convert.ToBase64String(bytes)); 
    } 
    catch 
    { 
     return false; 
    } 
    return true; 
} 

private static void ConvertInt32ToBytes(int i, byte[] bytes) 
{ 
    _byteBlock = BitConverter.GetBytes(i); 
    ConvertTo4Bytes(bytes); 
} 

private static void ConvertInt64ToBytes(long i, byte[] bytes) 
{ 
    _byteBlock = BitConverter.GetBytes(i); 
    ConvertTo8Bytes(bytes); 
} 

private static int ConvertBytesToInt32(byte[] bytes) 
{ 
    ConvertFrom4Bytes(bytes); 
    return BitConverter.ToInt32(_byteBlock, 0); 
} 

private static long ConvertBytesToInt64(byte[] bytes) 
{ 
    ConvertFrom8Bytes(bytes); 
    return BitConverter.ToInt64(_byteBlock, 0); 
} 

private static void ConvertTo4Bytes(byte[] bytes) 
{ 
    bytes[_idx] = _byteBlock[_endianDiff1]; 
    bytes[_idx + 1] = _byteBlock[1 + _endianDiff2]; 
    bytes[_idx + 2] = _byteBlock[2 - _endianDiff2]; 
    bytes[_idx + 3] = _byteBlock[3 - _endianDiff1]; 
    _idx += 4; 
} 

private static void ConvertFrom4Bytes(byte[] bytes) 
{ 
    _byteBlock[_endianDiff1] = bytes[_idx]; 
    _byteBlock[1 + _endianDiff2] = bytes[_idx + 1]; 
    _byteBlock[2 - _endianDiff2] = bytes[_idx + 2]; 
    _byteBlock[3 - _endianDiff1] = bytes[_idx + 3]; 
    _idx += 4; 
} 

private static void ConvertTo8Bytes(byte[] bytes) 
{ 

} 

private static void ConvertFrom8Bytes(byte[] bytes) 
{ 

} 

到目前为止，我有工作了INT，UINT和浮动因为他们都是4字节和我的问题是这样它的工作原理基础上，通过型式尺寸改变我的初始化函数。

我想也应该有ConvertTo8Bytes和ConvertFrom8Bytes功能，我不知道该怎么做，因为我设置_endianDiff和_byteBlock只有4个字节。我知道_byteBlock应该有动态大小而不是4，但我不知道在这种情况下如何处理字节序。

在侧面说明，我已经通过拆分长到2个INT S和刚刚将其存储为两个INT阵列解决了这个问题，但我没用分配内存喜欢这个只是因为我不能使这个算法工作。

Answer 1

好像很多代码，如果你正在做的是试图获得数值数组的Base64表示。我错过了目标吗？

如果你想要做的就是int或长数组和字符串的base64，试试这个：

private static string ConvertArrayToBase64<T>(IList<T> array) where T : struct 
    { 
     if (typeof(T).IsPrimitive) 
     { 
      int size = System.Runtime.InteropServices.Marshal.SizeOf<T>(); 
      var byteArray = new byte[array.Count * size]; 
      Buffer.BlockCopy(array.ToArray(), 0, byteArray, 0, byteArray.Length); 
      return Convert.ToBase64String(byteArray); 
     } 
     throw new InvalidOperationException("Only primitive types are supported."); 
    } 

    private static T[] ConvertBase64ToArray<T>(string base64String) where T : struct 
    { 
     if (typeof(T).IsPrimitive) 
     { 
      var byteArray = Convert.FromBase64String(base64String); 
      var array = new T[byteArray.Length/System.Runtime.InteropServices.Marshal.SizeOf<T>()]; 
      Buffer.BlockCopy(byteArray, 0, array, 0, byteArray.Length); 
      return array; 
     } 
     throw new InvalidOperationException("Only primitive types are supported."); 
    } 

有几件事情要考虑此代码虽然...

它确实构成了数组的完整副本，所以如果您正在处理大型数组或性能敏感的操作，它可能不是最好的方法。

这应与任何“原始值类型”阵列，其中应包括所有的数字类型如int，长，UINT，float等

为了证明使用工作，见下面的例子：

 var longArray = new long[] { 11111, 22222, 33333, 44444 }; 
     var intArray = new int[] { 55555, 66666, 77777, 88888}; 

     string base64longs = ConvertArrayToBase64(longArray); 
     Console.WriteLine(base64longs); 
     Console.WriteLine(string.Join(", ", ConvertBase64ToArray<long>(base64longs))); 

     string base64ints = ConvertArrayToBase64(intArray); 
     Console.WriteLine(base64ints); 
     Console.WriteLine(string.Join(", ", ConvertBase64ToArray<int>(base64ints))); 

做些什么：

• 验证阵列只有原始类型。
• 确定数组中元素的大小为 计算要分配的字节数组的长度。
• 它将阵列复制到字节数组。
• 返回base64表示。

补充功能正好相反。

更新：这里是.NET 2.0兼容版本...

private static string ConvertArrayToBase64<T>(IList<T> array) where T : struct 
    { 
     if (typeof(T).IsPrimitive) 
     { 
      int size = System.Runtime.InteropServices.Marshal.SizeOf(typeof(T)); 
      var byteArray = new byte[array.Count * size]; 
      Buffer.BlockCopy((Array)array, 0, byteArray, 0, byteArray.Length); 
      return Convert.ToBase64String(byteArray); 
     } 
     throw new InvalidOperationException("Only primitive types are supported."); 
    } 

    private static T[] ConvertBase64ToArray<T>(string base64String) where T : struct 
    { 
     if (typeof(T).IsPrimitive) 
     { 
      var byteArray = Convert.FromBase64String(base64String); 
      var array = new T[byteArray.Length/System.Runtime.InteropServices.Marshal.SizeOf(typeof(T))]; 
      Buffer.BlockCopy(byteArray, 0, array, 0, byteArray.Length); 
      return array; 
     } 
     throw new InvalidOperationException("Only primitive types are supported."); 
    }