YG-OPP-WCS-Client/WCS_Client/Utility/BinaryHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WCS_Client
{
    public class BinaryHelper
    {
        /// <summary>
        /// Char字符转成7位二进制
        /// </summary>
        /// <param name="ss"></param>
        /// <returns></returns>
        public string StringToBinary(string ss)
        {
            byte[] u = Encoding.ASCII.GetBytes(ss);
            string binaryNum = string.Empty;
            string result = string.Empty;
            foreach (byte a in u)
            {

                binaryNum = Convert.ToString(a, 2);
                if (binaryNum.Length < 7)
                {
                    for (int i = 0; i < 7 - binaryNum.Length; i++)
                    {
                        binaryNum = '0' + binaryNum;
                    }
                }
                result += binaryNum;
            }
            return result;
        }
        /// <summary>
        /// 存储二进制的字符串转成对应的数据
        /// </summary>
        /// <param name="binstr"></param>
        /// <returns></returns>
        public string BinaryToString(string binstr)
        {
            char[] np = binstr.ToCharArray();//"1000001000000001100010110010".ToCharArray();
            string username = "";
            string password = "";
            bool flag = false;
            string result = "";
            for (int i = 0; i < np.Length; i++)
            {


                result += np[i];
                if (result.Length % 7 == 0)
                {

                    if (Convert.ToInt32(result, 2) == 0)
                    {
                        flag = true;
                        result = string.Empty;
                        continue;
                    }
                    if (flag)
                        password += Convert.ToChar(Convert.ToInt32(result, 2));
                    else
                        username += Convert.ToChar(Convert.ToInt32(result, 2));
                    result = string.Empty;
                }
            }
            return result;
        }

        /// <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();
        }
        //public static byte[] bianma2(string s)
        //{
        //    byte[] data = Encoding.Unicode.GetBytes(s);
        //    return data;
        //}
        /// <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);
        }
        public static string jiema2(byte[] data)
        {
            return Encoding.Unicode.GetString(data, 0, data.Length);
        }
        /// <summary>
        /// byte数组转二进制样式的字符串
        /// </summary>
        /// <param name="byteArr">byte数组</param>
        /// <returns></returns>
        public static string ByteArray2BinaryStr(byte[] byteArr)
        {
            List<string> strList = new List<string>();
            var bl = byteArr.Length;
            if (bl == 0)
                return "";
            else
            {
                var tempStr = string.Empty;
                for (var i = 0; i < bl; i++)
                {
                    tempStr = Convert.ToString(byteArr[i], 2);
                    if (tempStr.Length < 4)
                        tempStr = tempStr.PadLeft(4, '0');
                    strList.Add(tempStr);
                }
            }

            return string.Join("", strList.ToArray());
        }
        /// <summary>
        /// 二进制样式的字符串转byte数组
        /// </summary>
        /// <param name="binaryStr">二进制样式的字符串</param>
        /// <returns></returns>
        public static byte[] BinaryStr2ByteArray(string binaryStr)
        {
            if (string.IsNullOrEmpty(binaryStr)) binaryStr = string.Empty;

            List<byte> byte_List = new List<byte>();
            var strL = binaryStr.Length;
            if (strL == 0)
                byte_List.Add(0);
            else if (strL > 0 && strL <= 4)
                byte_List.Add(Convert.ToByte(binaryStr, 2));
            else
            {
                var tempStr = string.Empty;
                for (var i = strL; i > 0; i = i - 4)
                {
                    if (i - 4 > 0)
                        tempStr = binaryStr.Substring(i - 4, 4);
                    else
                        tempStr = binaryStr.Substring(0, i);
                    byte_List.Add(Convert.ToByte(tempStr, 2));
                }
            }

            byte_List.Reverse();
            return byte_List.ToArray();
        }
    }
}