Aucma.Scada/HighWayIot.Common/StringChange.cs

using System;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;

namespace HighWayIot.Common
{
    public class StringChange
    {
        private static readonly Lazy<StringChange> lazy = new Lazy<StringChange>(() => new StringChange());
        public static StringChange Instance
        {
            get
            {
                return lazy.Value;
            }
        }

        private StringChange() { }

        /// <summary>
        /// 将字符串强制转换成int，转换失败则返回0
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public int ParseToInt(string str)
        {
            int returnInt = 0;
            if (str == null || str.Trim().Length < 1)
            {
                return returnInt;
            }
            if (int.TryParse(str, out returnInt))
            {
                return returnInt;
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// char数组转Array
        /// </summary>
        /// <param name="cha"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public string CharArrayToString(char[] cha, int len)
        {
            string str = "";
            for (int i = 0; i < len; i++)
            {
                str += string.Format("{0}", cha[i]);
            }

            return str;
        }

        public string bytesToHexStr(byte[] bytes, int iLen)//e.g. { 0x01, 0x01} ---> " 01 01"
        {
            string returnStr = "";
            if (bytes != null)
            {
                for (int i = 0; i < iLen; i++)
                {
                    returnStr += bytes[i].ToString("X2");
                }
            }
            return returnStr;
        }

        public byte[] HexStrTorbytes(string strHex)//e.g. " 01 01" ---> { 0x01, 0x01}
        {
            strHex = strHex.Replace(" ", "");
            if ((strHex.Length % 2) != 0)
                strHex += " ";
            byte[] returnBytes = new byte[strHex.Length / 2];
            for (int i = 0; i < returnBytes.Length; i++)
                returnBytes[i] = Convert.ToByte(strHex.Substring(i * 2, 2), 16);
            return returnBytes;
        }

        public 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;
        }

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

        public byte[] Swap16Bytes(byte[] OldU16)
        {
            byte[] ReturnBytes = new byte[2];
            ReturnBytes[1] = OldU16[0];
            ReturnBytes[0] = OldU16[1];
            return ReturnBytes;
        }


        /// <param name="strbase64">64Base码</param>
        /// <param name="path">保存路径</param>
        /// <param name="filename">文件名称</param>
        /// <returns></returns>
        public bool Base64ToImage(string strbase64, string path, string filename)
        {
            bool Flag = false;
            try
            {
                //base64编码的文本 转为 图片
                //图片名称
                byte[] arr = Convert.FromBase64String(strbase64);//将指定的字符串（它将二进制数据编码为 Base64 数字）转换为等效的 8 位无符号整数数组。
                using (MemoryStream ms = new MemoryStream(arr))
                {
                    Bitmap bmp = new Bitmap(ms);//加载图像
                    if (!Directory.Exists(path))//判断保存目录是否存在
                    {
                        Directory.CreateDirectory(path);
                    }
                    bmp.Save((path + "\\" + filename + ".png"), System.Drawing.Imaging.ImageFormat.Png);//将图片以JPEG格式保存在指定目录(可以选择其他图片格式)
                    ms.Close();//关闭流并释放
                    if (File.Exists(path + "\\" + filename + ".png"))//判断是否存在
                    {
                        Flag = true;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("图片保存失败：" + ex.Message);
            }
            return Flag;
        }

        /// <summary>
        /// 获取时间戳
        /// </summary>
        /// <returns></returns>
        public long GetTimeStamp()
        {
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds);
        }

        public byte[] ConvertFloatToINt(byte[] floatBytes)
        {
            byte[] intBytes = new byte[floatBytes.Length / 2];
            for (int i = 0; i < intBytes.Length; i++)
            {
                intBytes[i] = floatBytes[i * 2];
            }
            return intBytes;
        }

        //CRC异或校验
        public byte CalculateVerify(byte[] pMessage, int iLength)
        {
            UInt16 i;
            byte iVerify = 0;

            iVerify = pMessage[0];
            for (i = 1; i < iLength; i++)
            {
                iVerify = (byte)(iVerify ^ pMessage[i]);
            }
            return iVerify;
        }

        public int HexStringToNegative(string strNumber)
        {

            int iNegate = 0;
            int iNumber = Convert.ToInt32(strNumber, 16);
            if (iNumber > 127)
            {
                int iComplement = iNumber - 1;
                string strNegate = string.Empty;
                char[] binchar = Convert.ToString(iComplement, 2).PadLeft(8, '0').ToArray();
                foreach (char ch in binchar)
                {
                    if (Convert.ToInt32(ch) == 48)
                    {
                        strNegate += "1";
                    }
                    else
                    {
                        strNegate += "0";
                    }
                }
                iNegate = -Convert.ToInt32(strNegate, 2);
            }
            return iNegate;
        }
    }
}