高效byte[]和string互转的方法

public   static   class  Utils
    {
         ///   <summary>
         ///  普通方法——字节数组转字符串，最容易想到
         ///   </summary>
         ///   <param name="input"></param>
         ///   <returns></returns>
         public   static   string  BytesToString( byte [] input)
        {
            StringBuilder sb  =   new  StringBuilder();
             foreach  ( byte  b  in  input)
            {
                sb.Append(b.ToString( " X2 " ));
            }
             return  sb.ToString();
        }

         ///   <summary>
         ///  高效的字节数组转字符串
         ///   </summary>
         ///   <param name="input"></param>
         ///   <returns></returns>
         public   static   string  BytesToStringH( byte [] input)
        {
             int  len  =  input.Length;
             char [] chars  =   new   char [len  *   2 ];
             for  ( int  i  =   0 ; i  <  len; i ++ )
            {
                chars[i  *   2 ]  =  IntToChar(input[i]  >>   4 );
                chars[i  *   2   +   1 ]  =  IntToChar(input[i]  &   15 );
            }
             return   new   string (chars);
        }
         ///   <summary>
         ///  使用指针效率最高
         ///   </summary>
         ///   <param name="input"></param>
         ///   <returns></returns>
         public   static   unsafe   string  BytesToStringS( byte [] input)
        {
             int  len  =  input.Length;
             char [] chars  =   new   char [len  *   2 ];
             fixed  ( char *  lchars  =  chars)
            {
                 fixed  ( byte *  linput  =  input)
                {
                     char *  pchar  =  lchars;
                     byte *  pbyte  =  linput;
                     for  ( int  i  =   0 ; i  <  len; i ++ )
                    {
                         * pchar  =  IntToChar( * pbyte  >>   4 );
                        pchar ++ ;
                         * pchar  =  IntToChar( * pbyte  &   15 );
                        pchar ++ ;
                        pbyte ++ ;
                    }
                }
            }
             return   new   string (chars);
        }

         ///   <summary>
         ///  普通方法——字符串转字节数组，最容易想到
         ///   </summary>
         ///   <param name="input"></param>
         ///   <returns></returns>
         public   static   byte [] StringToBytes( string  input)
        {
             int  len  =  input.Length;
             if  (len  %   2   !=   0 )
            {
                 throw   new  Exception( " 输入的字符串长度有误，必须是偶数。 " );
            }
             byte [] bytes  =   new   byte [len  /   2 ];
             for  ( int  i  =   0 ; i  <  len  /   2 ; i ++ )
            {
                 if  ( ! byte .TryParse(input.Substring(i  *   2 ,  2 ), System.Globalization.NumberStyles.HexNumber,  null ,  out  bytes[i]))
                {
                     throw   new  Exception( string .Format( " 在位置{0}处的字符无法转换为16进制字节 " , i  *   2   +   1 ));
                }
            }
             return  bytes;
        }

         ///   <summary>
         ///  高效的字符串转字节数组
         ///   </summary>
         ///   <param name="input"></param>
         ///   <returns></returns>
         public   static   byte [] StringToBytesH( string  input)
        {
             int  len  =  input.Length;
             if  (len  %   2   !=   0 )
            {
                 throw   new  Exception( " 输入的字符串长度有误，必须是偶数。 " );
            }
             byte [] bytes  =   new   byte [len  /   2 ];
             for  ( int  i  =   0 ; i  <  len  /   2 ; i ++ )
            {
                 try
                {
                    bytes[i]  =  ( byte )((CharToInt(input[ 2   *  i])  <<   4 )  +  CharToInt(input[ 2   *  i  +   1 ]));
                }
                 catch  (Exception e)
                {
                     throw   new  Exception( string .Format( " 在位置{0}处的字符无法转换为16进制字节，原始信息为：{1} " , i  *   2   +   1 , e.Message));
                }
            }
             return  bytes;
        }

         ///   <summary>
         ///  使用指针效率最高
         ///   </summary>
         ///   <param name="input"></param>
         ///   <returns></returns>
         public   static   unsafe   byte [] StringToBytesS( string  input)
        {
             int  len  =  input.Length;
             if  (len  %   2   !=   0 )
            {
                 throw   new  Exception( " 输入的字符串长度有误，必须是偶数。 " );
            }
             byte [] bytes  =   new   byte [len  /   2 ];
             fixed  ( byte *  lbytes  =  bytes)
            {
                 fixed  ( char *  linput  =  input)
                {
                     byte *  pbyte  =  lbytes;
                     char *  pchar  =  linput;
                     for  ( int  i  =   0 ; i  <  len  /   2 ; i ++ )
                    {
                         try
                        {
                             * pbyte  =  ( byte )(CharToInt( * pchar)  <<   4 );
                            pchar ++ ;
                             * pbyte  +=  ( byte )CharToInt( * pchar);
                            pchar ++ ;
                            pbyte ++ ;
                        }
                         catch  (Exception e)
                        {
                             throw   new  Exception( string .Format( " 在位置{0}处的字符无法转换为16进制字节，原始信息为：{1} " , i  *   2   +   1 , e.Message));
                        }
                    }
                }
            }
             return  bytes;
        }
         ///   <summary>
         ///  输入一个16进制字符，返回小于16的正整数
         ///   </summary>
         ///   <param name="input"> 16进制字符 </param>
         ///   <returns> 小于16的正整数 </returns>
         private   static   int  CharToInt( char  input)
        {
             if  (input  >=   ' 0 '   &&  input  <=   ' 9 ' )
            {
                 return  input  -   ' 0 ' ;
            }
             else   if  (input  >=   ' a '   &&  input  <=   ' z ' )
            {
                 return  input  -   ' a '   +   10 ;
            }
             else   if  (input  >=   ' A '   &&  input  <=   ' Z ' )
            {
                 return  input  -   ' A '   +   10 ;
            }
             throw   new  Exception( string .Format( " 字符({0})超出16进制范围，无法转换 " , input));
        }

         ///   <summary>
         ///  输入一个小于16的正整数，返回对应的16进制字符。
         ///   </summary>
         ///   <param name="input"> 小于16的正整数 </param>
         ///   <returns> 16进制字符 </returns>
         private   static   char  IntToChar( int  input)
        {
             if  (input  >=   0   &&  input  <=   9 )
            {
                 return  ( char )(input  +   ' 0 ' );
            }
             else   if  (input  >=   10   &&  input  <=   15 )
            {
                 return  ( char )(input  -   10   +   ' A ' );
            }
             throw   new  Exception( string .Format( " 输入({0})超出16进制范围，无法转换 " , input));
        }
    }

转载于:https://www.cnblogs.com/leeolevis/archive/2011/04/18/2019917.html