• 转载连接:http://www.cnblogs.com/weihengblogs/archive/2013/12/23/3487257.html  ///  /// 将字符二进制  ///  ///  ///  public static string bianma(string

    转载连接:http://www.cnblogs.com/weihengblogs/archive/2013/12/23/3487257.html


            /// <summary>
            /// 将字符串转成二进制
            /// </summary>
            /// <param name="s"></param>
            /// <returns></returns>
            public static string bianma(string s)
            {
                byte[] data = Encoding.Unicode.GetBytes(s);
                StringBuilder result = new StringBuilder(data.Length * 8);


                foreach (byte b in data)
                {
                    result.Append(Convert.ToString(b, 2).PadLeft(8, '0'));
                }
                return result.ToString();
            }


        /// <summary>
              /// 将二进制转成字符串
              /// </summary>
              /// <param name="s"></param>
              /// <returns></returns>
              public static string jiema(string s)
              {
                  System.Text.RegularExpressions.CaptureCollection cs =
                      System.Text.RegularExpressions.Regex.Match(s, @"([01]{8})+").Groups[1].Captures;
                byte[] data = new byte[cs.Count];
                for (int i = 0; i < cs.Count; i++)
                {
                    data[i] = Convert.ToByte(cs[i].Value, 2);
                }
                return Encoding.Unicode.GetString(data, 0, data.Length);
            }


    展开全文
  • c#项目中用到的二进制、十六进制与字节数组的相互转换 class HexCommon { /// <summary> /// 16进制字符转字节数组 /// 如01 02 ff 0a /// </summary> /// <param name="hexString".....

    在c#项目中用到的二进制、十六进制与字节数组的相互转换

     class HexCommon
        {
    
            /// <summary> 
            /// 16进制字符串转字节数组 
            /// 如01 02 ff 0a
            /// </summary> 
            /// <param name="hexString"></param> 
            /// <returns></returns> 
            public static byte[] strHexToByte(string hexString)
            {
                hexString = hexString.Replace(" ", "");
                if ((hexString.Length % 2) != 0)
                    hexString += " ";
                byte[] returnBytes = new byte[hexString.Length / 2];
                for (int i = 0; i < returnBytes.Length; i++)
                {
                    string temp = hexString.Substring(i * 2, 2).Trim();
                    returnBytes[i] = Convert.ToByte(temp, 16);
                }
                return returnBytes;
            }
    
    
            /// <summary>
            /// 6进制字符串转字节数组 
            /// </summary>
            /// <param name="hexString"></param>
            /// <param name="separator">分隔符</param>
            /// <returns></returns>
            public static byte[] strHexToByte(string hexString, char separator)
            {
                if (separator == char.MinValue)
                {
                    return strHexToByte(hexString);
                }
                string[] hexarray = hexString.Split(separator);
                List<string> temphexarray = new List<string>(hexarray);
                var newhexarray = temphexarray.Where(u => u != string.Empty);
    
                int len = newhexarray.Count();
                byte[] returnBytes = new byte[len];
    
                int i = 0;
                foreach (string str in newhexarray)
                {
    
                    string temp = str.Trim();
                    returnBytes[i] = Convert.ToByte(temp, 16);
                    i = i + 1;
                }
    
                return returnBytes;
    
            }
    
    
            /// <summary> 
            /// 字节数组转16进制字符串 
            /// </summary> 
            /// <param name="bytes"></param> 
            /// <returns></returns> 
            public static string byteToHexStr(byte[] bytes)
            {
                string returnStr = "";
                if (bytes != null)
                {
                    for (int i = 0; i < bytes.Length; i++)
                    {
                        returnStr += bytes[i].ToString("x2") + " ";
                    }
                }
                return returnStr.Trim();
            }
            /// <summary> 
            /// 字节数组转16进制字符串 (高低位反)
            /// </summary> 
            /// <param name="bytes"></param> 
            /// <returns></returns> 
            public static string byteToHexStrHL(byte[] bytes)
            {
                string returnStr = "";
                try
                {
                    if (bytes != null)
                    {
                        for (int i = 1; i < bytes.Length;)
                        {
                            returnStr += bytes[i].ToString("x2") + " ";
                            returnStr += bytes[i - 1].ToString("x2") + " ";
                            i = i + 2;
                        }
                    }
                }
                catch (Exception ex)
                {
                }
                return returnStr.Trim();
            }
    
            /// <summary> 
            /// 二进制字符串转字节数组 
            /// 如01001111 011111111 
            /// </summary> 
            /// <param name="hexString"></param> 
            /// <returns></returns> 
            public static byte[] strBinaryToByte(string binaryString)
            {
                binaryString = binaryString.Replace(" ", "");
                int yu = binaryString.Length % 8;
                //将字符串长度变成8的倍数
                if (yu != 0)
                    binaryString = binaryString.PadRight(binaryString.Length + 8 - yu);
                StringBuilder builder = new StringBuilder();
    
                byte[] returnBytes = new byte[binaryString.Length / 8];
                for (int i = 0; i < returnBytes.Length; i++)
                {
                    string temp = binaryString.Substring(i * 8, 8).Trim();
                    returnBytes[i] = Convert.ToByte(temp, 2);
                }
    
                return returnBytes;
            }
    
            /// <summary> 
            /// 二进制字符串转字节数组 
            /// 如01001111 011111111 
            /// </summary> 
            /// <param name="hexString"></param> 
            /// <param name="separator">分隔符</param>
            /// <returns></returns> 
            public static byte[] strBinaryToByte(string binaryString, char separator)
            {
                if (separator == char.MinValue)
                {
                    return strBinaryToByte(binaryString);
                }
                string[] binarray = binaryString.Split(separator);
                List<string> tempbinarray = new List<string>(binarray);
                var newbinarray = tempbinarray.Where(u => u != string.Empty);
    
                int len = newbinarray.Count();
                byte[] returnBytes = new byte[len];
                int i = 0;
                foreach (string str in newbinarray)
                {
    
                    string temp = str.Trim();
                    returnBytes[i] = Convert.ToByte(temp, 2);
                    i = i + 1;
                }
    
                return returnBytes;
            }
    
            /// <summary>
            /// 二进制字符串转16进制字符串(无分隔符)
            /// </summary>
            /// <param name="binaryString"></param>
            /// <returns></returns>
            public static string strBinaryTostrHex(string binaryString)
            {
                binaryString = binaryString.Replace(" ", "");
                int yu = binaryString.Length % 8;
                //将字符串长度变成8的倍数
                if (yu != 0)
                    binaryString = binaryString.PadRight(binaryString.Length + 8 - yu);
                StringBuilder builder = new StringBuilder();
                int len = binaryString.Length / 8;
                for (int i = 0; i < len; i++)
                {
                    string temp = binaryString.Substring(i * 8, 8).Trim();
                    string str = Convert.ToInt32(temp, 2).ToString("x2");
                    builder = builder.Append(str);
                }
                return builder.ToString();
            }
            /// <summary>
            /// 二进制字符串转16进制字符串(有分隔符)
            /// </summary>
            /// <param name="binaryString"></param>
            /// <param name="separator">分隔符</param>
            /// <returns></returns>
            public static string strBinaryTostrHex(string binaryString, char separator)
            {
                if (separator == char.MinValue)
                {
                    return strBinaryTostrHex(binaryString);
                }
                string[] binarray = binaryString.Split(separator);
    
                StringBuilder builder = new StringBuilder();
                int len = binarray.Length;
                for (int i = 0; i < len; i++)
                {
                    string bin = binarray[i].Trim();
                    if (bin == string.Empty) continue;
                    string str = Convert.ToInt32(bin, 2).ToString("x2");
                    builder = builder.Append(str);
                    builder = builder.Append(separator);
                }
                string returnvalue = builder.ToString();
                returnvalue = returnvalue.TrimEnd(separator);
                return returnvalue;
            }
    
    
            /// <summary>
            /// 16进制字符串 转换成2进制字符串,此方法用于没有分隔符
            /// 16进制格式"ff 01" 2进制格式 "10101001 11111111"
            /// </summary>
            /// <param name="hexString"></param>
            /// <returns></returns>
            public static string strHexTostrBinary(string hexString)
            {
    
                hexString = hexString.Replace(" ", "");
                if ((hexString.Length % 2) != 0)
                {
                    hexString = hexString.PadRight(hexString.Length + 1);
                }
    
                StringBuilder builder = new StringBuilder();
                int len = hexString.Length / 2;
                for (int i = 0; i < len; i++)
                {
                    string hex = hexString.Substring(i * 2, 2).Trim();
                    int a = Convert.ToInt32(hex, 16);
                    string str = Convert.ToString(a, 2).PadLeft(8, '0');
                    builder = builder.Append(str);
                }
                return builder.ToString();
            }
    
            /// <summary>
            /// 16进制字符串 转换成2进制字符串,此方法用于有分隔符 如空格
            /// 16进制格式"ff 01" 2进制格式 "10101001 11111111"
            /// </summary>
            /// <param name="hexString"></param>
            /// <returns></returns>
            public static string strHexTostrBinary(string hexString, char separator)
            {
                if (separator == char.MinValue)
                    return strHexTostrBinary(hexString);
    
                string[] hexarray = hexString.Split(separator);
    
                StringBuilder builder = new StringBuilder();
                int len = hexarray.Length;
                for (int i = 0; i < len; i++)
                {
                    string hex = hexarray[i].Trim();
                    if (hex == string.Empty) continue;
                    int a = Convert.ToInt32(hex, 16);
                    string str = Convert.ToString(a, 2).PadLeft(8, '0');
                    builder = builder.Append(str);
                    builder = builder.Append(separator.ToString());
                }
                string returnvalue = builder.ToString();
                returnvalue = returnvalue.TrimEnd(separator);
                return returnvalue;
            }
        }
    
    展开全文
  • 1.请问c#中如何将十进制数的字符串转化成十六进制数的字符串 //十进制转二进制 Console.WriteLine("十进制166的二进制表示: "+Convert.ToString(166, 2)); //十进制八进制 Console.WriteLine("...

    1.请问c#中如何将十进制数的字符串转化成十六进制数的字符串
    //十进制转二进制

    Console.WriteLine("十进制166的二进制表示: "+Convert.ToString(166, 2));

    //十进制转八进制

    Console.WriteLine("十进制166的八进制表示: "+Convert.ToString(166, 8));

    //十进制转十六进制 Console.WriteLine("十进制166的十六进制表示: "+Convert.ToString(166, 16));  

    //二进制转十进制

    Console.WriteLine("二进制 111101 的十进制表示: "+Convert.ToInt32("111101", 2));

    //八进制转十进制

    Console.WriteLine("八进制 44 的十进制表示: "+Convert.ToInt32("44", 8));

    //十六进制转十进制

    Console.WriteLine("十六进制 CC的十进制表示: "+Convert.ToInt32("CC", 16));

     

    2.在串口通讯过程中,经常要用到 16进制与字符串、字节数组之间的转换

    private string StringToHexString(string s,Encoding encode)
            {
                byte[] b = encode.GetBytes(s);//按照指定编码将string编程字节数组
                string result = string.Empty;
                for (int i = 0; i < b.Length; i++)//逐字节变为16进制字符,以%隔开
                {
                    result += "%"+Convert.ToString(b[i], 16);
                }
                return result;
            }
            private string HexStringToString(string hs, Encoding encode)
            {
                //以%分割字符串,并去掉空字符
                string[] chars = hs.Split(new char[]{'%'},StringSplitOptions.RemoveEmptyEntries);
                byte[] b = new byte[chars.Length];
                //逐个字符变为16进制字节数据
                for (int i = 0; i < chars.Length; i++)
                {
                    b[i] = Convert.ToByte(chars[i], 16);
                }
                //按照指定编码将字节数组变为字符串
                return encode.GetString(b);
            }

    字符串转16进制字节数组
            /// <summary>
            /// 字符串转16进制字节数组
            /// </summary>
           /// <param name="hexString"></param>
            /// <returns></returns>
            private static byte[] strToToHexByte(string hexString)
            {
                 hexString = hexString.Replace(" ", "");
               if ((hexString.Length % 2) != 0)
                     hexString += " ";
                byte[] returnBytes = new byte[hexString.Length / 2];
                for (int i = 0; i < returnBytes.Length; i++)
                    returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
                return returnBytes;
             }

    字节数组转16进制字符串
    /// <summary>
            /// 字节数组转16进制字符串
            /// </summary>
            /// <param name="bytes"></param>
            /// <returns></returns>
            public static string byteToHexStr(byte[] bytes)
           {
                string returnStr = "";
                if (bytes != null)
                {
                    for (int i = 0; i < bytes.Length; i++)
                    {
                         returnStr += bytes[i].ToString("X2");
                     }
                 }
                return returnStr;
             }

    从汉字转换到16进制
    /// <summary>
            /// 从汉字转换到16进制
            /// </summary>
            /// <param name="s"></param>
            /// <param name="charset">编码,如"utf-8","gb2312"</param>
            /// <param name="fenge">是否每字符用逗号分隔</param>
           /// <returns></returns>
            public static string ToHex(string s, string charset, bool fenge)
            {
                if ((s.Length % 2) != 0)
                {
                     s += " ";//空格
                    //throw new ArgumentException("s is not valid chinese string!");
                 }
                 System.Text.Encoding chs = System.Text.Encoding.GetEncoding(charset);
                byte[] bytes = chs.GetBytes(s);
                string str = "";
                for (int i = 0; i < bytes.Length; i++)
                {
                    str += string.Format("{0:X}", bytes[i]);
                    if (fenge && (i != bytes.Length - 1))
                    {
                         str += string.Format("{0}", ",");
                     }
                 }
                return str.ToLower();
             }

     

    16进制转换成汉字
    ///<summary>
            /// 从16进制转换成汉字
            /// </summary>
            /// <param name="hex"></param>
            /// <param name="charset">编码,如"utf-8","gb2312"</param>
           /// <returns></returns>
            public static string UnHex(string hex, string charset)
            {
               if (hex == null)
                    throw new ArgumentNullException("hex");
                 hex = hex.Replace(",", "");
                 hex = hex.Replace("\n", "");
                 hex = hex.Replace("\\", "");
                 hex = hex.Replace(" ", "");
                if (hex.Length % 2 != 0)
                {
                     hex += "20";//空格
                 }
                // 需要将 hex 转换成 byte 数组。 
                byte[] bytes = new byte[hex.Length / 2];

               for (int i = 0; i < bytes.Length; i++)
                {
                    try
                    {
                        // 每两个字符是一个 byte。 
                         bytes[i] = byte.Parse(hex.Substring(i * 2, 2),
                         System.Globalization.NumberStyles.HexNumber);
                     }
                    catch
                    {
                        // Rethrow an exception with custom message. 
                        throw new ArgumentException("hex is not a valid hex number!", "hex");
                     }
                 }
                 System.Text.Encoding chs = System.Text.Encoding.GetEncoding(charset);
                return chs.GetString(bytes);
             }
    //上述文章为转载!

    https://www.cnblogs.com/dj1232090/p/5737556.html

    展开全文
  • string binaryText = Convert.ToString( Convert.ToInt32(hex, 16),2).PadLeft(16, '0');
    string binaryText = Convert.ToString(
                    Convert.ToInt32(hex, 16),2).PadLeft(16, '0');

     

    展开全文
  • C# 进制转换(二进制、十六进制、十进制互)由于二进制数在C#中无法直接表示,...//十进制转二进制字符串 Console.WriteLine(Convert.ToString(d,2)); //输出: 1010 //十进制十六进制字符串 Console.WriteL...
    C# 进制转换(二进制、十六进制、十进制互转)
    由于二进制数在C#中无法直接表示,所以所有二进制数都用一个字符串来表示

    例如: 二进制: 1010 表示为 字符串:"1010" 

    int d = 10;
    
    
    //十进制转二进制字符串
     Console.WriteLine(Convert.ToString(d,2));
    //输出: 1010
    
    
    
    
    //十进制转十六进制字符串
    Console.WriteLine(Convert.ToString(d,16));
    //输出: a
    
    
    //二进制字符串转十进制数
    string bin = "1010";
    Console.WriteLine(Convert.ToInt32(bin,2));
    //输出: 10
    
    
    //二进制字符串转十六进制数
    string bin = "1010";
    Console.WriteLine(string.Format("{0:x}",Convert.ToInt32(bin,2));
    //输出: a
    
    
    //十六进制转二进制字符串
    Console.WriteLine(Convert.ToString(0xa,2));
    //输出: 1010
    
    //MessageBox.Show(Convert.ToInt32(txtDaiZhuan.Text, 16).ToString()); //16进制转十进制
    //十六进制转十进制数
    Console.WriteLine(Convert.ToString(0xa,10));
    //输出: 10


    https://blog.csdn.net/fwj380891124/article/details/8775938



    展开全文
  • 二进制数组的字符串形式转换为二进制Byte数组
  • 在工程实践中,经常会将一些字节信息转换为16进制字符串,以便传递和分享,比如加密密钥信息。在这里提供一段转化示例, 以供交流学习。 将16进制字符串转化为 字节流 public static byte[] HexStringToBytes...
  • C# 16进制与字符串、字节数组之间的转换 C# 16进制与字符串、字节数组之间的转换   1.请问c#中如何将十进制数的字符串转化成十六进制数的字符串 //十进制转二进制 Console.WriteLine("十进制166的二进制...
  • 十六进制字符串与数值类型之间转换(C# 编程指南 以下示例演示如何执行下列任务: 获取字符串中每个字符的十六进制值。 获取与十六进制字符串中的每个值对应的字符。 将十六进制 string 转换为...
  • [code="java"]byte[] b = new byte[fis.available()];...现怎么将这种二进制字符串转换为byte[]数组?我知道有其它将byte[]和字符串之间互相转换的方法。但我现在只求这种二进制字符串的转换方法。拜托各位了。。
  • 十六进制字符串与数值类型之间转换(C# 编程指南)  以下示例演示如何执行下列任务:  获取字符串中每个字符的十六进制值。  获取与十六进制字符串中的每个值对应的字符。  将十六进制 string 转换为...
  • #region 把字符串转换成 byte 的二进制流。 /// <summary> /// 把字符串转换成 byte 的二进制流。 /// </summary> /// <param name="strmemo"></param> /// <param name=...
  • c# 16进制转10进制

    2019-04-13 09:11:59
    CPU卡、M1、ID卡,在一卡通平台通常做法是使用扇区的前4字节的10进制做为卡号,但实际扇区存储的都是16进制字符串。所以项目中就有对10进制和16进制转换的要求。 推荐工具:在线进制转换...
  • 十六进制字符串与数值类型之间转换(C# 编程指南) 以下示例演示如何执行下列任务:获取字符串中每个字符的十六进制值。获取与十六进制字符串中的每个值对应的字符。将十六进制 string 转换为整型。将十六进制 ...
  • c#中如何把一个96个字节二进制字符串转换成12个字节的十六进制数?
  • 一个字节包含8个二进制位,一个十六进制可表示4个二进制位,所以,一个字节可以由2个十六进制表示总结如下: (1)一个byte 对应两位十六进制位,而不是八位(32位二进制位); (2)转化为十六进制之后,不足两位...
  • C#中二进制数组h和各种常规数组的转换,二进制序列化和json序列化方法以及对应的反序列化方法的例子,帮助初学者。
1 2 3 4 5 ... 20
收藏数 22,451
精华内容 8,980