string、byte[]、hex、float、int、octal、binary、stream、object 类型转换

string <==> 基础类型

string -> 基础类型

using System.ComponentModel;
var typeConverter = TypeDescriptor.GetConverter(typeof(int));
int value = typeConverter.ConvertFromInvariantString(txt);

基础类型 -> string

var typeConverter = TypeDescriptor.GetConverter(typeof(int));
string txt = typeConverter.ConvertToInvariantString(value);

字符串转换成指定类型的值

string <==> string[]

string -> string[]

var arr = str.Split(',');

string[] -> string

var str = string.Join(",", arr);

string <==> byte[]

string -> byte[]

byte[] byteArray = System.Text.Encoding.Default.GetBytes ( str );

byte[] -> string

string str = System.Text.Encoding.Default.GetString ( byteArray );

/// <summary>
/// 字节值字符串显示
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static string ToByteString(byte[] data)
{
    if (data == null)
    {
        return string.Empty;
    }
    StringBuilder sb = new StringBuilder(data.Length);
    foreach (var item in data)
    {
        sb.Append(item);
        sb.Append(" ");
    }
    return sb.ToString().Trim();
}

string <==> ASCII byte[]

string -> ASCII byte[]

byte[] byteArray = System.Text.Encoding.ASCII.GetBytes ( str );

ASCII byte[] -> string

string str = System.Text.Encoding.ASCII.GetString ( byteArray );

字节序

计算机内部处理都是小端字节序（Little Endian）。低位数据存放在内存低地址处。
更适合计算机读取内存。数值的四则运算更高效。
大端字节序（Big Endian）符合人类读写习惯。内存低地址处存放的是高位数据。
常用于 网络传输、文件存储等场景。

int <==> byte[]

int -> byte[]

// 4个字节的数组
// 数组中的字节顺序取决于计算机体系结构是小端还是大端
byte[] data = BitConverter.GetBytes(value);

byte[] -> int

/// <summary>
/// 字节数组转换整数
/// </summary>
/// <param name="data">字节数组（高字节在前、低字节在后）</param>
/// <remarks>常见约定是按网络字节顺序传输数据 (大端序) </remarks>
/// <returns></returns>
public static int BigEndianByte2Int(params byte[] data)
{
    switch (data.Length)
    {
        case 0:
            return 0;
        case 1:
            return data[0];
        case 2:
            // 若在计算机中是小端排列，反转数组中的字节顺序
            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(data);
            }
            return BitConverter.ToInt16(data, 0);
        case 3:
            return BigEndianByte2Int(0, data[0], data[1], data[2]);
        case 4:
            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(data);
            }
            return BitConverter.ToInt32(data, 0);
        default:    // 截断
            return BigEndianByte2Int(data[0], data[1], data[2], data[3]);
    }
}
/// <summary>
/// 字节数组转换整数(小端序)
/// </summary>
/// <param name="data">字节数组（低字节在前、高字节在后）</param>
/// <returns></returns>
public static int LittleEndianByte2Int(params byte[] data)
{
    switch (data.Length)
    {
        case 0:
            return 0;
        case 1:
            return data[0];
        case 2:
            // 若在计算机中是大端排列，反转数组中的字节顺序
            if (!BitConverter.IsLittleEndian)
            {
                Array.Reverse(data);
            }
            return BitConverter.ToInt16(data, 0);
        case 3:
            return LittleEndianByte2Int(data[0], data[1], data[2], 0);
        case 4:
            if (!BitConverter.IsLittleEndian)
            {
                Array.Reverse(data);
            }
            return BitConverter.ToInt32(data, 0);
        default:    // 截断
            return LittleEndianByte2Int(data[0], data[1], data[2], data[3]);
    }
}

var rslt = BigEndianByte2Int(0,C,8); // rslt = 200

hexString <==> byte[]

byte[] -> hexString

/// <summary>
/// 字节的字符串形式（十六进制）
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static string Byte2HexStringX(params byte[] data)
{
    if (data == null)
    {
        return string.Empty;
    }
    StringBuilder sb = new StringBuilder(data.Length);
    foreach (var item in data)
    {
        sb.Append(item.ToString("X"));
    }
    return sb.ToString();
}
/// <summary>
/// 字节的字符串形式（十六进制）
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static string Byte2HexStringX2(params byte[] data)
{
    if (data == null)
    {
        return string.Empty;
    }
    StringBuilder sb = new StringBuilder(data.Length);
    foreach (var item in data)
    {
        sb.Append(item.ToString("X2"));
    }
    return sb.ToString();
}

/// <summary>
/// 字节的字符串形式（十六进制，带空格）
/// </summary>
/// <param name="bSpace">false无空格，true有空格</param>
/// <param name="data"></param>
/// <returns></returns>
public static string Byte2HexStringX2(bool bSpace, params byte[] data)
{
    if (data == null)
    {
        return string.Empty;
    }
    StringBuilder sb = new StringBuilder(data.Length);
    foreach (var item in data)
    {
        sb.Append(item.ToString("X2"));
        if (bSpace)
        {
            sb.Append(" ");
        }
    }
    return sb.ToString();
}

这几个方法，都是字节数组按顺序的十六进制表示。
BitConverter.ToString(data).Replace("-","");
此方法的十六进制字符串的顺序取决于计算机体系结构是小端还是 big-endian。与Byte2HexStringX2方法的结果可能会不同。

hexString -> byte[]

/// <summary>
/// 十六进制字符串转字节数组
/// </summary>
/// <param name="input"></param>
/// <remarks>FF11->[255,17]</remarks>
/// <returns></returns>
public static byte[] HexString2Byte(string input)
{
    var rslt = new byte[(input.Length + 1) / 2];
    var offset = 0;
    if (input.Length % 2 == 1)
    {
        // 如果输入长度为奇数，则第一个字符的前面有一个隐式0
        rslt[0] = (byte)System.Convert.ToUInt32(input[0].ToString(), 16);
        offset = 1;
    }
    for (int i = 0; i < input.Length / 2; i++)
    {
        rslt[i + offset] = (byte)System.Convert.ToUInt32(input.Substring(i * 2 + offset, 2), 16);
    }
    return rslt;
}

int -> binary

/// <summary>
/// 整数->二进制
/// </summary>
/// <param name="bits">整数</param>
/// <param name="removeTrailingZero">是否清除前导0，默认false</param>
/// <returns>二进制string</returns>
public static string Int2Binary(int bits, bool removeTrailingZero = false)
{
    if (removeTrailingZero)
        return Convert.ToString(bits, 2).PadLeft(32, '0');
    else
        return Convert.ToString(bits, 2);
}

byte -> binary

/// <summary>
/// 字节->二进制
/// </summary>
/// <param name="bit">字节</param>
/// <param name="removeTrailingZero">是否清除前导0，默认false</param>
/// <returns>二进制string</returns>
public static string Byte2Binary(byte bit, bool removeTrailingZero = false)
{
    if (removeTrailingZero)
        return Convert.ToString(bit, 2).PadLeft(8, '0');
    else
        return Convert.ToString(bit, 2);
}

binary -> int

/// <summary>
/// 二进制转换为十进制
/// </summary>
/// <param name="binary"></param>
/// <returns></returns>
public static int Binary2Int(string binary)
{
    return Convert.ToInt32(binary, 2);
}

hex -> int

/// <summary>
/// 十六进制->整数
/// </summary>
/// <param name="bits">十六进制字符串（比如：FFFF）</param>
/// <returns>整数int</returns>
public static int Hex2Int(string bits)
{
    return Convert.ToInt32(hex, 16);
}

int -> hexStr

/// <summary>
/// 整数转大端字节字符串
/// </summary>
/// <param name="value">整数</param>
/// <param name="strLen">字符串长度</param>
/// <returns>十六进制字符串</returns>
public static string Int2HexStr_BigEndian(int value, int strLen = 3)
{
    var arr = BitConverter.GetBytes(value);
    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(arr);
    }
    return BitConverter.ToString(arr).Replace("-", "").TrimStart('0').PadLeft(strLen, '0');
}

var rslt = Int2HexStr_BigEndian(200); // "08C"

浮点数 <==> HexString

float value = 67.89f;
// 4 个字节的数组
// 数组中的字节顺序取决于计算机体系结构是小端还是大端
var data = BitConverter.GetBytes(value);
// 次序展示
var str = WSCommFunc.Byte2HexStringX2(data);
// 次序转换
data = WSCommFunc.HexString2Byte(str);
// 顺序不变，转换结果相同
value = BitConverter.ToSingle(data, 0);

浮点数 <==> 二进制

浮点数 -> 二进制

public static string FloatToBinary(float value)
{
    byte[] bytes = BitConverter.GetBytes(value);
    StringBuilder stringBuffer = new StringBuilder();
    for (int i = 0; i < bytes.Length; i++)
    {
        if (i != 0)
        {
            stringBuffer.Insert(0, " ");
        }
        string hex = Convert.ToString(bytes[i], 2);
        stringBuffer.Insert(0, hex);
        // 位数不够补0
        for (int j = hex.Length; j < 8; j++)
        {
            stringBuffer.Insert(0, "0");
        }
    }
    return stringBuffer.ToString();
}

二进制 -> 浮点数

public static float BinaryToFloat(string str)
{
    str = str.Replace(" ", string.Empty);
    if (str.Length != 32)
    {
        str = str.PadLeft(32, '0');
    }
    byte[] intBuffer = new byte[4];
    // 将二进制串按字节逆序化（一个字节8位）
    for (int i = 0; i < 4; i++)
    {
        string hex = str.Substring(24 - 8 * i, 8);
        intBuffer[i] = Convert.ToByte(hex, 2);
    }
    return BitConverter.ToSingle(intBuffer, 0);
}

object <==> byte[]

object -> byte[]

/// <summary>
/// 将对象转换为byte数组
/// </summary>
/// <param name="obj">被转换对象</param>
/// <returns>转换后byte数组</returns>
public static byte[] Object2Bytes(object obj)
{
    byte[] buff = new byte[System.Runtime.InteropServices.Marshal.SizeOf(obj)];
    IntPtr ptr = System.Runtime.InteropServices.Marshal.UnsafeAddrOfPinnedArrayElement(buff, 0);
    System.Runtime.InteropServices.Marshal.StructureToPtr(obj, ptr, true);
    return buff;
}

byte[] -> object

/// <summary>
/// 将byte数组转换成对象
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="data">被转换byte数组</param>
/// <returns>转换完成后的对象</returns>
public static T Bytes2Object<T>(byte[] data)
{
    var obj = default(T);
    IntPtr ptr = System.Runtime.InteropServices.Marshal.UnsafeAddrOfPinnedArrayElement(data, 0);
    return (T)System.Runtime.InteropServices.Marshal.PtrToStructure(ptr, obj.GetType());
}

File <==> byte[]

File -> byte[]

/// <summary>
/// 将文件转换为byte数组
/// </summary>
/// <param name="path">文件地址</param>
/// <returns>转换后的byte数组</returns>
public static byte[] File2Bytes(string path)
{
    if (!System.IO.File.Exists(path))
    {
        return new byte[0]; // 防止空指针异常
    }
    var fi = new System.IO.FileInfo(path);
    byte[] buff = new byte[fi.Length];
    var fs = fi.OpenRead();
    fs.Read(buff, 0, Convert.ToInt32(fs.Length));
    fs.Close();
    return buff;
}

byte[] -> File

/// <summary>
/// 将byte数组转换为文件并保存到指定地址
/// </summary>
/// <param name="buff">byte数组</param>
/// <param name="savepath">保存地址</param>
public static void Bytes2File(byte[] data, string path)
{
    if (System.IO.File.Exists(path))
    {
        System.IO.File.Delete(path);
    }
    var fs = new System.IO.FileStream(path, System.IO.FileMode.CreateNew);
    var bw = new System.IO.BinaryWriter(fs);
    bw.Write(data, 0, data.Length);
    bw.Close();
    fs.Close();
}

stream <==> byte[]

stream -> byte[]

/// <summary> 
/// 将 Stream 转成 byte[] 
/// </summary> 
public async Task<byte[]> StreamToBytes(Stream stream)
{
    var rslt = new byte[stream.Length];
    _ = await stream.ReadAsync(rslt, 0, rslt.Length);
    stream.Seek(0, SeekOrigin.Begin);
    return rslt;
}

byte[] -> stream

/// <summary> 
/// 将 byte[] 转成 Stream 
/// </summary> 
public Stream BytesToStream(byte[] bytes) 
{ 
    Stream stream = new MemoryStream(bytes); 
    return stream; 
} 

Bitmap <==> byte[]

Bitmap -> byte[]

using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
// 1
public static byte[] BitmapToBytes(Bitmap bitmap)
{
    using (var ms = new MemoryStream())
    {
        bitmap.Save(ms, bitmap.RawFormat);
        return ms.ToArray();
    }
}
// 2
public static byte[] BitmapToBytes(Bitmap bmp)
{
    Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
    BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadOnly, bmp.PixelFormat);
    IntPtr ptr = bmpData.Scan0;
    int stride = Math.Abs(bmpData.Stride);
    int bytes = stride * bmp.Height;
    byte[] rslt = new byte[bytes];
    Marshal.Copy(ptr, rslt, 0, bytes);
    bmp.UnlockBits(bmpData);
    return rslt;
}

方法2速度更快，若是Bitmap尺寸更大，对比效果更明显。
1M左右大小的图（循环100次）

60M左右大小的图（循环10次）

byte[] -> Bitmap

public static Bitmap BytesToBitmap(byte[] buffer)
{
    using var ms = new MemoryStream(buffer);
    return new Bitmap(ms);
}

Image <==> byte[]

Image -> byte[]

/// <summary>
/// 将图片Image转换成Byte[]
/// </summary>
/// <param name="image">image对象</param>
/// <param name="format">后缀名</param>
/// <returns></returns>
public static byte[] Image2Bytes(Image image, ImageFormat format = null)
{
    if (image == null)
    {
        return new byte[0];
    }
    using (MemoryStream ms = new MemoryStream())
    {
        using (Bitmap bmp = new Bitmap(image))
        {
            if (format == null)
            {
                format = ImageFormat.Bmp;
            }
            bmp.Save(ms, format);
            ms.Position = 0;
            return ms.ToArray();
        }
    }
}

byte[] -> Image

/// <summary>
/// byte[]转换成Image
/// </summary>
/// <param name="data">二进制图片流</param>
/// <returns>Image</returns>
public static Image Bytes2Image(byte[] data)
{
    if (data == null || data.Length == 0)
    {
        return null;
    }
    using (MemoryStream ms = new MemoryStream(data))
    {
        Image rslt = Image.FromStream(ms, true, true);
        ms.Flush();
        return rslt;
    }
}

Bitmap <==> Image

Bitmap -> Image

Image -> Bitmap

// 直接强制转换
var bmp = (Bitmap)img;

Bitmap bmp;
using (var img = Bitmap.FromFile(filePath))
{
    // 复制不冲突
    bmp = img.Clone() as Bitmap;
}
_ = bmp.Width * bmp3.Height;
bmp.Save("D:\\bmp.bmp");

BitmapImage <==> byte[]

BitmapImage -> byte[]

byte[] -> BitmapImage

GenerateBitmapImage

Bitmap <==> stream

Bitmap -> stream

public static Stream BitmapToStream(Bitmap bitmap, ImageFormat imageFormat)
{
    Stream stream = new MemoryStream();
    bitmap.Save(stream, imageFormat);
    stream.Seek(0, SeekOrigin.Begin);
    return stream;
}

stream -> Bitmap

public static Bitmap StreamToBitmap(Stream stream)
{
    return (Bitmap)Image.FromStream(stream);
}

string <==> DateTime

string -> DateTime

/// <summary>
/// 日期格式的字符串转成标准日期
/// </summary>
/// <param name="dateTimeStr">日期格式的字符串</param>
/// <param name="dateTimeFormatStr">对应的字符串形式，默认yyyyMMddHHmmss</param>
/// <returns></returns>
public static DateTime Str2DateTime(string dateTimeStr, string dateTimeFormatStr = "yyyyMMddHHmmss")
{
   if (DateTime.TryParseExact(dateTimeStr, dateTimeFormatStr, System.Globalization.CultureInfo.CurrentCulture, System.Globalization.DateTimeStyles.None, out DateTime dt))
   {
       return dt;
   }
   return DateTime.MinValue;
}

DateTime -> string

dt.ToString("yyyy-MM-dd")
dt.ToString("HH:mm:ss")

int <==> char

int -> char

var ch = '0' + i;

char -> int

i = System.Globalization.GetDecimalDigitValue(ch);

IntPtr <==> T[]

IntPtr -> T[]

private void PtrSetValue<T>(IntPtr ptr, T[] arr)
{
    if (arr == null)
    {
        return;
    }
    int structSize = Marshal.SizeOf(typeof(T));
    var startPoint = ptr.ToInt64();
    var length = arr.Length;
    for (int i = 0; i < length; i++)
    {
        var tmp = new IntPtr(startPoint + i * structSize);
        var value = (T)Marshal.PtrToStructure(tmp, typeof(T));
        arr[i] = value;
    }
}

注意需要主动释放指针 Marshal.FreeHGlobal(ptr); 或者使用可自动释放的类型；
UnmanagedArray 非托管数组，可随时释放内存

T[] -> IntPtr

private IntPtr Arr2Ptr<T>(T[] arr)
{
    int structSize = Marshal.SizeOf(typeof(T));
    IntPtr rslt = Marshal.AllocHGlobal(structSize * arr.Length);
    return rslt;
}

ff <==> ss

ff -> ss

ss -> ff

​