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