INI配置文件读写工具类

最新推荐文章于 2024-08-30 09:07:08 发布
最新推荐文章于 2024-08-30 09:07:08 发布
阅读量1.6k 收藏
点赞数
分类专栏： winform 文章标签： INI c# 配置文件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyong_net/article/details/52242183
版权

INI配置文件读写工具类

using System;

using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.IO;

namespace Yong.CommonLib
{
    /// <summary>
    /// ini 配置文件读写
    /// TODO:应该使用“单例”来创建实例，以提高效率
    /// TODO:考虑使用Nini或Win32 api调用实现,好处：稳定代码，速度更快
    /// Nini还可以读取配置文件和注册表
    /// </summary>

    public class CIni
    {
        private StreamReader aStreamReader;
        private StreamWriter aStreamWriter;
        private ArrayList aSegList = new ArrayList();
        public string strLastError = "没有错误";
        private string strRoot = "";
        private string strKey = "";
        struct StructSeg
        {
            public string strSeg;
            public ArrayList ItemValue;
            public StructSeg(string strSeg)
            {
                this.strSeg = strSeg;
                ItemValue = new ArrayList();
            }
        }
        /// <summary>
        /// </summary>


        public CIni()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }
        /// <summary>
        /// TODO:使用map优化!
        /// </summary>
        /// <returns></returns>
        public int SetCrypto(string strSetKey)
        {
            byte[] aBytes = Encoding.GetEncoding("gb2312").GetBytes(strSetKey);
            if (aBytes.Length != 8 && aBytes.Length != 16)
            {
                strLastError = "密钥长度错误";
                return -1;
            }
            this.strKey = strSetKey;
            return 0;
        }
        public int SetRoot(string strSetRoot)
        {
            strSetRoot = strSetRoot.Trim();
            if (strSetRoot != "")
            {
                this.strRoot = strSetRoot + "\\";
            }
            else
            {
                this.strRoot = "";
            }
            return 0;
        }
        /// <summary>
        /// 获取所有段中同名的项目的值
        /// </summary>
        /// <returns></returns>
        public ArrayList getAllSegName()
        {
            ArrayList al = new ArrayList();
            foreach (StructSeg aSeg in aSegList)
            {
                al.Add(trimBracket(aSeg.strSeg));
            }
            return al;
        }
        private string trimBracket(string source)
        {
            int begin = source.IndexOf('[');
            int end = source.IndexOf(']');
            if (begin >= end || begin < 0 || end < 0)
            {
                return source;
            }
            return source.Substring(begin + 1, end - begin - 1);
        }
        public int LoadFromString(string strContent)
        {
            try
            {
                byte[] byteContent = Encoding.GetEncoding("gb2312").GetBytes(strContent);
                return LoadFromBytes(byteContent);
            }
            catch (Exception e)
            {
                strLastError = "加载失败,系统提示:" + e.Message;
                return (-1);
            }
            finally
            {
                try
                {
                    aStreamReader.Close();
                }
                catch
                {
                }
            }
        }
        public int LoadFromBytes(byte[] byteContent)
        {
            try
            {
                MemoryStream stream = new MemoryStream();
                stream.Write(byteContent, 0, byteContent.Length);
                stream.Flush();
                stream.Position = 0;
                aStreamReader = new StreamReader(stream, Encoding.GetEncoding("gb2312"));
                return Load();
            }
            catch (Exception e)
            {
                strLastError = "加载失败,系统提示:" + e.Message;
                return (-1);
            }
            finally
            {
                try
                {
                    aStreamReader.Close();
                }
                catch
                {
                }
            }

        }
        private int Load()
        {
            try
            {
                aSegList = new ArrayList();
                string strHead;
                string aLine;
                StructSeg aSeg = new StructSeg("[]");
                while ((aLine = aStreamReader.ReadLine()) != null)
                {
                    aLine = aLine.Trim().TrimEnd(new char[] { '\0' });
                    if (aLine.Length > 0)
                    {
                        strHead = aLine.Substring(0, 1);
                    }
                    else
                    {
                        continue;
                    }
                    if (strHead == "[")
                    {
                        aSegList.Add(aSeg);
                        aSeg = new StructSeg(aLine);
                    }
                    else
                    {
                        aSeg.ItemValue.Add(aLine);
                    }
                }
                aSegList.Add(aSeg);
                return 0;
            }
            catch (Exception e)
            {
                strLastError = "加载失败,系统提示:" + e.Message;
                return (-1);
            }
        }
        public int Load(string strFileName)
        {


            ClassCrypto aClassCrypto = null;
            try
            {
                if (strKey != "")
                {
                    aClassCrypto = new ClassCrypto(strKey);
                    if (aClassCrypto.GetCryptoStreamReader(strFileName) < 0)
                    {
                        strLastError = aClassCrypto.strLastError;
                        return -1;
                    }
                    aStreamReader = aClassCrypto.aReader;
                }
                else
                {
                    aStreamReader = new StreamReader(strFileName, Encoding.GetEncoding("gb2312"), true);
                }
                return Load();
            }
            catch (Exception e)
            {

                strLastError = "加载失败,系统提示:" + e.Message;
                return (-1);
            }
            finally
            {
                try
                {
                    if (strKey != "")
                    {

                        aClassCrypto.CloseReader();
                    }
                    else
                    {
                        aStreamReader.Close();
                    }
                }
                catch
                {
                }
            }
        }
        public int PushToString(out string strContent)
        {
            strContent = null;
            try
            {
                byte[] byteContent = null;
                if (PushToBytes(out byteContent) < 0)
                {
                    return -1;
                }
                strContent = Encoding.GetEncoding("gb2312").GetString(byteContent, 0, byteContent.Length).Trim(new char[] { '\0' });
                return 0;
            }
            catch (Exception e)
            {
                strLastError = "输出失败,系统提示:" + e.Message;
                return (-1);
            }
        }
        public int PushToBytes(out byte[] byteContent)
        {
            byteContent = null;
            try
            {
                MemoryStream stream = new MemoryStream();
                aStreamWriter = new StreamWriter(stream, Encoding.GetEncoding("gb2312"));
                Push();
                byteContent = stream.ToArray();
                return 0;
            }
            catch (Exception e)
            {
                strLastError = "输出失败,系统提示:" + e.Message;
                return (-1);
            }
            finally
            {
                try
                {
                    aStreamWriter.Close();
                }
                catch
                {
                }
            }
        }

        public int Push(string strFileName)
        {
            ClassCrypto aClassCrypto = null;
            try
            {
                if (strKey != "")
                {
                    aClassCrypto = new ClassCrypto(strKey);
                    if (aClassCrypto.GetCryptoStreamWriter(strFileName) < 0)
                    {
                        strLastError = aClassCrypto.strLastError;
                        return -1;
                    }
                    aStreamWriter = aClassCrypto.aWriter;
                }
                else
                {
                    aStreamWriter = new StreamWriter(strFileName, false, Encoding.GetEncoding("gb2312"));

                }
                return Push();
            }
            catch (Exception e)
            {

                strLastError = "写文件失败,系统提示:" + e.Message;
                return (-1);
            }
            finally
            {
                if (strKey != "")
                {
                    aClassCrypto.CloseWriter();
                }
                else
                {
                    aStreamWriter.Close();
                }
            }
        }
        private int Push()
        {
            try
            {
                foreach (StructSeg aSeg in aSegList)
                {
                    if (aSeg.strSeg != "[]") aStreamWriter.WriteLine(aSeg.strSeg);
                    //System.Windows.Forms.MessageBox.Show(aSeg.strSeg);
                    foreach (string aLine in aSeg.ItemValue)
                    {
                        //System.Windows.Forms.MessageBox.Show(aLine);
                        aStreamWriter.WriteLine(aLine);
                    }
                }
                aStreamWriter.Flush();
                return 0;
            }
            catch (Exception e)
            {
                strLastError = "输出失败,系统提示:" + e.Message;
                return (-1);
            }
        }
        public int GetIniItem(string strSeg, string strItem, out string strValue)
        {
            strSeg = "[" + strRoot + strSeg.Trim() + "]";
            strValue = "";
            try
            {
                foreach (StructSeg aSeg in aSegList)
                {
                    if (GetSeg(aSeg.strSeg).ToUpper() == strSeg.ToUpper())
                    {
                        foreach (string aLine in aSeg.ItemValue)
                        {
                            if (GetItem(aLine).ToUpper() == strItem.ToUpper())
                            {
                                strValue = GetValue(aLine);
                                return (0);
                            }
                        }
                    }
                }
                strLastError = "未找到数据:" + strSeg + " " + strItem;
                return (-1);
            }
            catch (Exception e)
            {
                strLastError = "获取数据异常:" + strSeg + " " + strItem + " 系统提示:" + e.Message;
                return (-2);
            }
        }
        public int GetIniItemBlock(string strSeg, string strItem, out byte[] bytesValue)
        {
            strSeg = "[" + strRoot + strSeg.Trim() + "]";
            bytesValue = new byte[0];
            string strValue = "";
            try
            {
                foreach (StructSeg aSeg in aSegList)
                {
                    if (GetSeg(aSeg.strSeg).ToUpper() == strSeg.ToUpper())
                    {
                        for (int i = 0; i < aSeg.ItemValue.Count; i++)
                        {
                            string aLine = (string)aSeg.ItemValue[i];
                            if (GetItem(aLine).ToUpper() == strItem.ToUpper())
                            {
                                strValue = GetValue(aLine);
                                if (strValue.EndsWith("-"))
                                {
                                    strValue = strValue.Substring(0, strValue.Length - 1);
                                    for (int j = i + 1; j < aSeg.ItemValue.Count; j++)
                                    {
                                        aLine = (string)aSeg.ItemValue[j];
                                        aLine = aLine.Trim();
                                        if (!aLine.StartsWith(";-")) break;
                                        aLine = aLine.Substring(2);
                                        strValue += aLine;
                                        if (!strValue.EndsWith("-")) break;
                                        strValue = strValue.Substring(0, strValue.Length - 1);
                                    }
                                }
                                try
                                {
                                    bytesValue = Convert.FromBase64String(strValue);
                                }
                                catch (Exception e)
                                {
                                    strLastError = "数据处理异常:" + strSeg + " " + strItem + " 系统提示:" + e.Message;
                                    return (-1);
                                }
                                //if(HexToBytes(strValue,out bytesValue)!=0){
                                //    return (-1);
                                //}
                                return (0);
                            }
                        }
                    }
                }
                strLastError = "未找到数据:" + strSeg + " " + strItem;
                return (-1);
            }
            catch (Exception e)
            {
                strLastError = "获取数据异常:" + strSeg + " " + strItem + " 系统提示:" + e.Message;
                return (-2);
            }
        }
        public int GetIniItem(string strSeg, string strItem, out int iValue)
        {
            string strValue;
            iValue = 0;
            int iRetCode = GetIniItem(strSeg, strItem, out strValue);
            if (iRetCode < 0) return (iRetCode);
            try
            {
                iValue = Convert.ToInt32(strValue);
            }
            catch
            {
            }
            return (0);
        }
        public int GetIniItem(string strSeg, string strItem, out Single sValue)
        {
            string strValue;
            sValue = 0f;
            int iRetCode = GetIniItem(strSeg, strItem, out strValue);
            if (iRetCode < 0) return (iRetCode);
            try
            {
                sValue = Convert.ToSingle(strValue);
            }
            catch
            {
            }
            return (0);
        }
        public int GetIniItem(string strSeg, string strItem, out bool bValue)
        {
            string strValue;
            bValue = false;
            int iRetCode = GetIniItem(strSeg, strItem, out strValue);
            if (iRetCode < 0) return (iRetCode);
            if (strValue == "true" || strValue == "TRUE" || strValue == "True" ||
                strValue == "是" ||
                strValue == "yes" || strValue == "YES" || strValue == "Yes")
            {
                bValue = true;
            }
            else
            {
                bValue = false;
            }
            return (0);
        }
        public int GetIniItem(string strSeg, string strItem, out byte[] byetsValue)
        {
            string strValue;
            byetsValue = new byte[0];
            int iRetCode = GetIniItem(strSeg, strItem, out strValue);
            if (iRetCode < 0) return (iRetCode);
            return (HexToBytes(strValue, out byetsValue));
        }
        public int SetIniItem(string strSeg, string strItem, byte[] bytesValue)
        {
            return (SetIniItem(strSeg, strItem, bytesValue, ""));
        }
        public int SetIniItem(string strSeg, string strItem, byte[] bytesValue, string strDescription)
        {
            string strHex;
            int iRetCode = BytesToHex(out strHex, bytesValue);
            if (iRetCode < 0) return (iRetCode);
            return (SetIniItem(strSeg, strItem, strHex, strDescription));
        }
        public int SetIniItem(string strSeg, string strItem, bool bValue)
        {
            return (SetIniItem(strSeg, strItem, bValue, ""));
        }

        public int SetIniItem(string strSeg, string strItem, bool bValue, string strDescription)
        {
            return (SetIniItem(strSeg, strItem, bValue.ToString(), strDescription));
        }
        public int SetIniItem(string strSeg, string strItem, string strValue)
        {
            return (SetIniItem(strSeg, strItem, strValue, ""));
        }
        public int SetIniItem(string strSeg, string strItem, string strValue, string strDescription)
        {
            strSeg = "[" + strRoot + strSeg.Trim() + "]";
            strValue = CheckValue(strValue);
            string aNewLine = strItem + "\t=\t" + strValue;
            StructSeg aSeg;
            int i, j;
            string aLine;
            try
            {
                for (i = 0; i < aSegList.Count; i++)
                {
                    aSeg = (StructSeg)aSegList[i];
                    if (GetSeg(aSeg.strSeg).ToUpper() == strSeg.ToUpper())
                    {
                        for (j = 0; j < aSeg.ItemValue.Count; j++)
                        {
                            aLine = (string)aSeg.ItemValue[j];
                            if (GetItem(aLine).ToUpper() == strItem.ToUpper())
                            {
                                if (strDescription != "")
                                {
                                    aNewLine = aNewLine + "\t;" + strDescription;
                                }
                                else if (GetDescription(aLine) != "")
                                {
                                    aNewLine = aNewLine + "\t;" + GetDescription(aLine);
                                }
                                aSeg.ItemValue[j] = aNewLine;
                                aSegList[i] = aSeg;
                                return (0);
                            }
                        }
                        if (strDescription != "") aNewLine = aNewLine + "\t;" + strDescription;
                        aSeg.ItemValue.Add(aNewLine);
                        aSegList[i] = aSeg;
                        return (0);
                    }
                }
                aSeg = new StructSeg(strSeg);
                if (strDescription != "") aNewLine = aNewLine + "\t;" + strDescription;
                aSeg.ItemValue.Add(aNewLine);
                aSegList.Add(aSeg);
                return (0);
            }
            catch (Exception e)
            {
                strLastError = "设置数据异常:" + strSeg + " " + strItem + " 系统提示:" + e.Message;
                return (-2);
            }
        }
        public int SetIniItemBlock(string strSeg, string strItem, byte[] bytesValue)
        {
            strSeg = "[" + strRoot + strSeg.Trim() + "]";
            string strValue;
            string[] strArray = new string[0];
            //if (BytesToHex(out strValue, bytesValue) != 0) return -1;
            try
            {
                strValue = Convert.ToBase64String(bytesValue);
            }
            catch (Exception e)
            {
                strLastError = "数据处理异常:" + strSeg + " " + strItem + " 系统提示:" + e.Message;
                return -1;
            }
            string aNewLine = strItem + "\t=\t-";
            int i, j;
            i = (strValue.Length + 63) / 64;
            if (i > 0)
            {
                strArray = new string[i];
                for (j = 0; j < (i - 1); j++)
                {
                    strArray[j] = ";-" + strValue.Substring(j * 64, 64) + "-";
                }
                strArray[i - 1] = ";-" + strValue.Substring((i - 1) * 64);
            }
            StructSeg aSeg;
            string aLine;
            try
            {
                for (i = 0; i < aSegList.Count; i++)
                {
                    aSeg = (StructSeg)aSegList[i];
                    if (GetSeg(aSeg.strSeg).ToUpper() == strSeg.ToUpper())
                    {
                        for (j = 0; j < aSeg.ItemValue.Count; j++)
                        {
                            aLine = (string)aSeg.ItemValue[j];
                            if (GetItem(aLine).ToUpper() == strItem.ToUpper())
                            {
                                aSeg.ItemValue[j] = aNewLine;
                                for (int k = j + 1; k < aSeg.ItemValue.Count; k++)
                                {
                                    aLine = (string)aSeg.ItemValue[k];
                                    aLine = aLine.Trim();
                                    if (aLine.StartsWith(";-"))
                                    {
                                        aSeg.ItemValue.RemoveAt(k);
                                        k--;
                                        continue;
                                    }
                                }
                                for (int k = 0; k < strArray.Length; k++)
                                {
                                    aSeg.ItemValue.Insert(j + k + 1, strArray[k]);
                                }
                                aSegList[i] = aSeg;
                                return (0);
                            }
                        }
                        aSeg.ItemValue.Add(aNewLine);
                        for (int k = 0; k < strArray.Length; k++)
                        {
                            aSeg.ItemValue.Add(strArray[k]);
                        }
                        aSegList[i] = aSeg;
                        return (0);
                    }
                }
                aSeg = new StructSeg(strSeg);
                aSeg.ItemValue.Add(aNewLine);
                for (int k = 0; k < strArray.Length; k++)
                {
                    aSeg.ItemValue.Add(strArray[k]);
                }
                aSegList[i] = aSeg;
                aSegList.Add(aSeg);
                return (0);
            }
            catch (Exception e)
            {
                strLastError = "设置数据异常:" + strSeg + " " + strItem + " 系统提示:" + e.Message;
                return (-2);
            }
        }
        public int RemoveIniItem(string strSeg, string strItem)
        {
            strSeg = "[" + strRoot + strSeg.Trim() + "]";
            StructSeg aSeg;
            int i, j;
            string aLine;
            try
            {
                for (i = 0; i < aSegList.Count; i++)
                {
                    aSeg = (StructSeg)aSegList[i];
                    if (GetSeg(aSeg.strSeg).ToUpper() == strSeg.ToUpper())
                    {
                        for (j = 0; j < aSeg.ItemValue.Count; j++)
                        {
                            aLine = (string)aSeg.ItemValue[j];
                            if (GetItem(aLine).ToUpper() == strItem.ToUpper())
                            {
                                aSeg.ItemValue.RemoveAt(j);
                                aSegList[i] = aSeg;
                                break;
                            }
                        }
                        if (aSeg.ItemValue.Count <= 0)
                        {
                            aSegList.RemoveAt(i);
                        }
                        break;
                    }
                }
                return (0);
            }
            catch (Exception e)
            {
                strLastError = "删除数据异常:" + strSeg + " " + strItem + " 系统提示:" + e.Message;
                return (-2);
            }
        }
        private string Clear(string aLine)
        {
            int iPos = 0;
            while ((iPos = aLine.IndexOf(';', iPos)) >= 0)
            {
                if (iPos == 0) break;
                if (aLine.Substring(iPos - 1, 1) != "\\") break;
                iPos++;
            }
            if (iPos >= 0) aLine = aLine.Substring(0, iPos);
            aLine = aLine.Trim();
            return (aLine);
        }
        private string GetSeg(string aLine)
        {
            aLine = Clear(aLine);
            return (aLine);
        }
        private string GetItem(string aLine)
        {
            aLine = Clear(aLine);
            string[] strArray = aLine.Split("=".ToCharArray());
            return (strArray[0].Trim());
        }
        private string GetValue(string aLine)
        {
            aLine = Clear(aLine);
            int iPos = aLine.IndexOf("=");
            if (iPos >= 0 && iPos < (aLine.Length - 1))
            {
                aLine = aLine.Substring(iPos + 1).Trim() + " ";
                iPos = 0;
                while ((iPos = aLine.IndexOf('\\', iPos)) >= 0)
                {
                    switch (aLine.Substring(iPos + 1, 1))
                    {
                        case "r":
                            aLine = aLine.Substring(0, iPos) + "\r" + aLine.Substring(iPos + 2);
                            break;
                        case "n":
                            aLine = aLine.Substring(0, iPos) + "\n" + aLine.Substring(iPos + 2);
                            break;
                        case "t":
                            aLine = aLine.Substring(0, iPos) + "\t" + aLine.Substring(iPos + 2);
                            break;
                        default:
                            aLine = aLine.Substring(0, iPos) + aLine.Substring(iPos + 1);
                            break;
                    }
                    iPos += 1;
                }
                return (aLine.Trim());
            }
            else
            {
                return ("");
            }
        }
        private string CheckValue(string strValue)
        {
            int iPos = 0;
            while ((iPos = strValue.IndexOf('\\', iPos)) >= 0)
            {
                strValue = strValue.Substring(0, iPos) + "\\" + strValue.Substring(iPos);
                iPos += 2;
            }
            iPos = 0;
            while ((iPos = strValue.IndexOf(';', iPos)) >= 0)
            {
                strValue = strValue.Substring(0, iPos) + "\\" + strValue.Substring(iPos);
                iPos += 2;
            }
            iPos = 0;
            while ((iPos = strValue.IndexOf('\r', iPos)) >= 0)
            {
                strValue = strValue.Substring(0, iPos) + "\\r" + strValue.Substring(iPos + 1);
                iPos += 3;
                if (iPos >= strValue.Length) break;
            }
            iPos = 0;
            while ((iPos = strValue.IndexOf('\n', iPos)) >= 0)
            {
                strValue = strValue.Substring(0, iPos) + "\\n" + strValue.Substring(iPos + 1);
                iPos += 3;
                if (iPos >= strValue.Length) break;
            }
            iPos = 0;
            while ((iPos = strValue.IndexOf('\t', iPos)) >= 0)
            {
                strValue = strValue.Substring(0, iPos) + "\\t" + strValue.Substring(iPos + 1);
                iPos += 3;
                if (iPos >= strValue.Length) break;
            }
            return (strValue);
        }
        private string GetDescription(string aLine)
        {
            int iPos = 0;
            while ((iPos = aLine.IndexOf(';', iPos)) >= 0)
            {
                if (iPos == 0) break;
                if (aLine.Substring(iPos - 1, 1) != "\\") break;
                iPos++;
            }
            if (iPos >= 0)
            {
                aLine = aLine.Substring(iPos + 1);
            }
            else
            {
                aLine = "";
            }
            aLine = aLine.Trim();
            return (aLine);
        }
        /// <summary>
        /// TODO:应该放在公共库中
        /// </summary>
        /// <param name="strHex"></param>
        /// <param name="aBytes"></param>
        /// <returns></returns>
        public int HexToBytes(string strHex, out byte[] aBytes)
        {
            strHex = strHex.ToUpper();
            char[] tmpCharArray = strHex.ToCharArray();
            aBytes = new byte[0];
            if ((tmpCharArray.Length % 2) != 0)
            {
                strLastError = "HEX数据长度错误";
                return (-1);
            }
            aBytes = new byte[tmpCharArray.Length / 2];
            for (int i = 0; i < tmpCharArray.Length; i += 2)
            {
                if (tmpCharArray[i] >= 'A' && tmpCharArray[i] <= 'F')
                {
                    aBytes[i / 2] = (byte)((tmpCharArray[i] - 'A' + 10) * 16);
                }
                else if (tmpCharArray[i] >= '0' && tmpCharArray[i] <= '9')
                {
                    aBytes[i / 2] = (byte)((tmpCharArray[i] - '0') * 16);
                }
                else
                {
                    strLastError = "HEX数据中有非法字符";
                    return (-1);
                }
                if (tmpCharArray[i + 1] >= 'A' && tmpCharArray[i + 1] <= 'F')
                {
                    aBytes[i / 2] += (byte)((tmpCharArray[i + 1] - 'A' + 10));
                }
                else if (tmpCharArray[i + 1] >= '0' && tmpCharArray[i + 1] <= '9')
                {
                    aBytes[i / 2] += (byte)((tmpCharArray[i + 1] - '0'));
                }
                else
                {
                    strLastError = "HEX数据中有非法字符";
                    return (-1);
                }
            }
            return (0);
        }
        /// <summary>
        /// TODO:应该放在公共库中
        /// </summary>
        /// <param name="strHex"></param>
        /// <param name="aBytes"></param>
        /// <returns></returns>
        public int BytesToHex(out string strHex, byte[] aBytes)
        {
            strHex = "";
            int iBlock = aBytes.Length / 16;
            int i, j;
            for (j = 0; j < iBlock; j++)
            {
                i = j * 16;
                strHex += String.Format("{0:X2}{1:X2}{2:X2}{3:X2}{4:X2}{5:X2}{6:X2}{7:X2}{8:X2}{9:X2}{10:X2}{11:X2}{12:X2}{13:X2}{14:X2}{15:X2}",
                    aBytes[i], aBytes[i + 1], aBytes[i + 2], aBytes[i + 3], aBytes[i + 4], aBytes[i + 5], aBytes[i + 6], aBytes[i + 7],
                    aBytes[i + 8], aBytes[i + 9], aBytes[i + 10], aBytes[i + 11], aBytes[i + 12], aBytes[i + 13], aBytes[i + 14], aBytes[i + 15]);
            }
            for (i = iBlock * 16; i < aBytes.Length; i++)
            {
                strHex += String.Format("{0:X2}", aBytes[i]);
            }
            return (0);
        }

    }
}

ClassCryptole类：

using System;

using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace Yong.CommonLib
{
    public class ClassCrypto
    {
        private string strKey = "12345678";
        public StreamReader aReader;
        public StreamWriter aWriter;
        private FileStream aFileStreamRead;
        private FileStream aFileStreamWrite;
        private CryptoStream aCryptoStreamRead;
        private CryptoStream aCryptoStreamWrite;
        private DESCryptoServiceProvider aDes;
        public string strLastError = "";
        public ClassCrypto()
        {
            aDes = new DESCryptoServiceProvider();
            aDes.Key = Encoding.ASCII.GetBytes(strKey);
            aDes.IV = Encoding.ASCII.GetBytes(strKey);
        }
        public ClassCrypto(string _strKey)
        {
            strKey = _strKey;
            aDes = new DESCryptoServiceProvider();
            aDes.Key = Encoding.ASCII.GetBytes(strKey);
            aDes.IV = Encoding.ASCII.GetBytes(strKey);
        }
        public int GetCryptoStreamReader(string strFileName)
        {
            return GetCryptoStreamReader(strFileName, Encoding.Default);
        }
        public int GetCryptoStreamReader(string strFileName, Encoding aEncoding)
        {
            try
            {
                ICryptoTransform desencrypt = aDes.CreateDecryptor();
                aFileStreamRead = new FileStream(strFileName, FileMode.Open);
                aCryptoStreamRead = new CryptoStream(aFileStreamRead, desencrypt, CryptoStreamMode.Read);
                aReader = new StreamReader(aCryptoStreamRead, aEncoding, true);
                return 0;
            }
            catch (Exception e)
            {
                strLastError = "在打开文件" + strFileName + "时发生异常" + e.Message;
                return -1;
            }
        }
        public int GetCryptoStreamReader(string strFileName, Encoding aEncoding, int bufferSize)
        {
            try
            {
                ICryptoTransform desencrypt = aDes.CreateDecryptor();
                aFileStreamRead = new FileStream(strFileName, FileMode.Open);
                aCryptoStreamRead = new CryptoStream(aFileStreamRead, desencrypt, CryptoStreamMode.Read);
                aReader = new StreamReader(aCryptoStreamRead, aEncoding, true, bufferSize);
                return 0;
            }
            catch (Exception e)
            {
                strLastError = "在打开文件" + strFileName + "时发生异常" + e.Message;
                return -1;
            }
        }
        public int GetCryptoStreamWriter(string strFileName)
        {
            return GetCryptoStreamWriter(strFileName, false, Encoding.Default);
        }
        public int GetCryptoStreamWriter(string strFileName, bool append, Encoding aEncoding)
        {
            try
            {
                ICryptoTransform desencrypt = aDes.CreateEncryptor();
                if (append)
                {
                    aFileStreamWrite = new FileStream(strFileName, FileMode.Append);
                }
                else
                {
                    aFileStreamWrite = new FileStream(strFileName, FileMode.Create);
                }
                aCryptoStreamWrite = new CryptoStream(aFileStreamWrite, desencrypt, CryptoStreamMode.Write);
                aWriter = new StreamWriter(aCryptoStreamWrite, aEncoding);
                return 0;
            }
            catch (Exception e)
            {
                strLastError = "在打开文件" + strFileName + "时发生异常" + e.Message;
                return -1;
            }
        }
        public int CloseWriter()
        {
            try
            {
                aWriter.Close();
            }
            catch
            {
            } try
            {
                aCryptoStreamWrite.Close();
            }
            catch { }
            try
            {
                aFileStreamWrite.Close();
            }
            catch (Exception e)
            {
                strLastError = "在关闭输出文件时发生异常:" + e.Message;
                return -1;
            }
            return 0;
        }
        public int CloseReader()
        {
            try
            {
                aReader.Close();
            }
            catch { }
            try
            {
                aCryptoStreamRead.Close();
            }
            catch { }
            try
            {
                aFileStreamRead.Close();
            }
            catch (Exception e)
            {
                strLastError = "在关闭输入文件时发生异常:" + e.Message;
                return -1;
            }
            return 0;
        }
    }
}


张云勇
关注
专栏目录
读取ini配置工具类
weixin_40151334的博客
03-26 192
该工具类为读取ini配置文件工具类： package com.bgxt.utils; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOExceptio...
C# ini文件操作工具类 亲测可用 超详细 带说明文档
07-27
有了这样一个工具类，C#开发者可以方便地管理ini配置文件，提高代码的可维护性和效率。 总结来说，C#操作ini文件主要涉及文件I/O操作和字符串解析。通过封装成工具类，可以简化这些操作，使得在实际项目中能够快速...
[C++][工具分享]读写ini文件类
PangCoder的博客
07-09 625
IniFileOperate.h //_CRT_SECURE_NO_WARNINGS #pragma once #include <string> #include <vector> typedef struct _nRoot { std::string name;//根节点的名字 int begin;//开始的行数 std::vector<std::s...
探索mINI：一个轻量级的C++ INI文件操作库
最新发布
gitblog_01147的博客
08-30 403
探索mINI：一个轻量级的C++ INI文件操作库 mINIINI file reader and writer项目地址:https://gitcode.com/gh_mirrors/mini/mINI 在现代软件开发中，配置文件的管理是一个不可或缺的环节。INI文件作为一种简洁的配置文件格式，广泛应用于各种系统和应用程序中。今天，我们将介绍一个名为mINI的轻量级C++库，它专门用于操作INI...
【工具类】-ini配置文件读写操作类
番茄酱的黑科技小屋
05-24 265
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Runtime.InteropServices; namespace QRS_Lis { public static class INIHelper { //获取ini
ini配置文件读取工具
似水流年风萧兮
05-26 774
从ini配置文件中读取变量的值；修改ini配置文件中变量的值
C# INI文件读写工具类
Ushino的博客
03-24 644
INI文件结构解释 C#读写ini文件之前要了解的概念：INI就是扩展名为"INI"的文件,其实他本身是个文本文件,可以用记事本打开,主要存放的是用户所做的选择或系统的各种参数. C#读写ini文件其实并不是普通的文本文件.它有自己的结构.由若干段落(SECTION)组成,在每个带括号的标题下面,是若干个以单个单词开头的关键字(KEYWORD)和一个等号,等号右边就是关键字的值(VALUE).例如: [Section1] KeyWord1 = Value1 KeyWord2 = Va
ini配置文件读写（C/C++版本）
01-09
本工具功能为读取ini配置文件中的配置项，包含有样例程序，编译脚本，如需自编译验证，可在安装有G++4.4.7以上版本的linux环境下直接运行makefile(命令make),即可生成可执行文件parse 运行样例见本说明第四...
Ini配置文件读写类
10-18
Ini配置文件是软件开发中常用的一种轻量级的配置存储格式，主要由...总之，C++中的Ini配置文件读写类通过自定义的数据结构和一系列操作函数，实现了对ini文件的读取、写入和管理，为开发者提供了方便的配置管理工具。
标准C/C++读写配置文件类，读写ini文件,加入工程就可以用
11-29
标题提到的“标准C/C++读写配置文件类”是指一个专门用于处理INI文件的C++类，它使得开发者能够方便地读取和写入配置文件。这类库通常会封装文件操作的复杂性，提供简洁的API供程序员调用。描述中提到的“非常完美的...
Ini配置文件读写.zip
04-06
本文将深入探讨Ini配置文件的读写操作，包括基本结构、API函数以及在编程中的应用。 Ini配置文件的基本结构通常包含三个部分：节（Section）、键（Key）和值（Value）。一个简单的Ini文件可能如下所示： ``` ...
易语言制作的INI文件编辑工具
08-24
ini文件的编辑工具源代码，可以对INI文件进行全面操作
ini文件读写工具
03-07
将ini读写制作成工具类，直接建立工程，将文件.h，.cpp添加，然后直接调用即可，在文件目录下建立ini文件，读写直接调用函数即可
配置文件ini的生成
11-03
由于现代软件中，很多时候需要保留一些配置信息，而ini文件就是其中的方法之一，该工程简单而详细体现了ini文件的读写调用方式
ini配置文件编辑器（通用，Qt源码+可执行程序）
07-07
详细描述见博客http://blog.csdn.net/d759378563 Qt读取ini配置文件
INI文件设置工具V1[1].4
10-22
INI文件设置工具V1[1].4 INI文件设置工具V1[1].4
【MFC】CIniRw类，用于读写后缀为ini的配置文件
sunriver2000的专栏
04-01 497
.h文件 #pragma once #include <iostream> #include <windows.h> #include <tchar.h> #include <stdio.h> #include <stdlib.h> #include <string> #include "atlstr.h" ...
ini文件读取工具类
爆笑弟的博客
09-04 366
package com.sylincom.sydtlauncher.Utils; import android.util.Log; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java..
IniReader：一个简单、小巧的INI阅读器
寒冰屋的专栏
05-01 763
这是一个用于C#项目的简单单文件INI阅读器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值