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

string <==> byte[]

string -> byte[]

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

byte[] -> string

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

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

hexString <==> byte[]

byte[] -> hexString

private static string ToHexString(byte[] bytes)
{
    string hexString = string.Empty;
    if (bytes != null)
    {
        StringBuilder strB = new StringBuilder();
        for (int i = 0; i < bytes.Length; i++)
        {
            strB.Append(bytes[i].ToString("X2"));
        }
        hexString = strB.ToString();
    }
    return hexString;
}

hexString -> byte[]

private static byte[] HexString2Byte(string input)
{
    var rslt = new byte[(input.Length + 1) / 2];
    var offset = 0;
    if (input.Length % 2 == 1)
    {
        // If length of input is odd, the first character has an implicit 0 prepended.
        rslt[0] = (byte)Convert.ToUInt32(input[0] + "", 16);
        offset = 1;
    }
    for (int i = 0; i < input.Length / 2; i++)
    {
        rslt[i + offset] = (byte)Convert.ToUInt32(input.Substring(i * 2 + offset, 2), 16);
    }
    return rslt;
}

合并byte[]数组 （不改变原数组）

/// <summary>
/// 合并byte[]数组 （不改变原数组）
/// </summary>
/// <param name="b1"></param>
/// <param name="b2"></param>
/// <returns>合并后的数组</returns>
public static byte[] MergeByte(byte[] b1, byte[] b2)
{
    byte[] result = new byte[b1.Length + b2.Length];
    Array.Copy(b1, 0, result, 0, b1.Length);
    Array.Copy(b2, 0, result, b1.Length, b2.Length);
    return result;
}

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">十六进制字符串</param>
/// <returns>整数int</returns>
public static int Hex2Int(string bits)
{
    ireturn Convert.ToInt32(hex, 10);
}

浮点数 <==> 二进制

浮点数 -> 二进制

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[]

public static byte[] BitmapToBytes(Bitmap bitmap)
{
    using (var ms = new MemoryStream())
    {
        bitmap.Save(ms, bitmap.RawFormat);
        return ms.ToArray();
    }
}

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 <==> 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);

ff <==> ss

ff -> ss

ss -> ff