C# 读取INI文件简单实现

使用方法

 NetCfg = ReadTool.Read<NetConfig>("配置文件.ini", "网络配置");

配置文件

[网络配置]

// 基本配置
ip=192.168.1.108
prot=8725
centerName=中控
listen=Pad1,Pad2,Pad3
sendProject=布局控制,布局控制2,布局控制3

# 主动响应项目
responseProject=布局控制

实体类

 internal class NetConfig
 {
     public string ip;
     public int prot;
     public string centerName;
     public string[] listen;
     public string[] sendProject;

     public string responseProject;
 }

代码实现

 internal class ReadTool
 {

     public static T Read<T>(string file, string node)
     {
         var type = typeof(T);
         var obj = (T)type.Assembly.CreateInstance(type.FullName);
         if (!File.Exists(file))
         {
             Log.Err("文件不存在：" + file);
             return obj;
         }

         using (FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read))
         {
             using (StreamReader sr = new StreamReader(fs))
             {

                 string line;
                 int state = 0;
                 while ((line = sr.ReadLine()) != null)
                 {
                     line.Trim();
                     if (string.IsNullOrEmpty(line)) continue;

                     // 注释行
                     if (line.StartsWith("#") || line.StartsWith("//")) continue;

                     if (state == 0)
                     {
                         if (line.StartsWith("[") && line.EndsWith("]"))
                         {
                             line = line.Substring(1, line.Length - 2);

                             if (line.Equals(node))
                             {
                                 state = 1;
                                 continue;
                             }

                         }
                     }
                     else if (state == 1)
                     {
                         if (line.StartsWith("[") && line.EndsWith("]"))
                         {
                             //读取结束
                             break;
                         }

                         // 读取命令
                         var index = line.IndexOf('=');
                         if (index == -1)
                         {
                             // 格式错误
                             continue;
                         }

                         // 属性
                         var att = line.Substring(0, index);
                         // 值
                         var data = line.Substring(index + 1);

                         if (string.IsNullOrEmpty(data))
                             continue;

                         // 属性反射赋值
                         var property = type.GetProperty(att);

                         if (property != null)
                         {
                             if (property.PropertyType.IsArray)
                             {
                                 property.SetValue(obj, ConvertArray(property.PropertyType, data));
                             }
                             else
                             {
                                 property.SetValue(obj, ConvertData(property.PropertyType, data));
                             }

                             continue;
                         }

                         // 字段反射赋值
                         var field = type.GetField(att);

                         if (field != null)
                         {
                             if (field.FieldType.IsArray)
                             {
                                 field.SetValue(obj, ConvertArray(field.FieldType, data));
                             }
                             else
                             {
                                 field.SetValue(obj, ConvertData(field.FieldType, data));
                             }

                         }
                     }
                 }
             }
         }

         return obj;
     }

     private static object ConvertArray(Type type, string data)
     {
         try
         {
             var array = data.Split(',');

             if (type == typeof(string[]))
                 return array;

             if (type == typeof(byte[]))
             {
                 byte[] v = new byte[array.Length];
                 for (int i = 0; i < array.Length; i++)
                     byte.TryParse(array[i], out v[i]);
                 return v;
             }

             if (type == typeof(short[]))
             {
                 short[] v = new short[array.Length];
                 for (int i = 0; i < array.Length; i++)
                     short.TryParse(array[i], out v[i]);
                 return v;
             }

             if (type == typeof(int[]))
             {
                 int[] v = new int[array.Length];
                 for (int i = 0; i < array.Length; i++)
                     int.TryParse(array[i], out v[i]);
                 return v;
             }

             if (type == typeof(float[]))
             {
                 float[] v = new float[array.Length];
                 for (int i = 0; i < array.Length; i++)
                     float.TryParse(array[i], out v[i]);
                 return v;
             }
             if (type == typeof(double[]))
             {
                 double[] v = new double[array.Length];
                 for (int i = 0; i < array.Length; i++)
                     double.TryParse(array[i], out v[i]);
                 return v;
             }

             if (type == typeof(DateTime[]))
             {
                 DateTime[] v = new DateTime[array.Length];
                 for (int i = 0; i < array.Length; i++)
                     DateTime.TryParse(array[i], out v[i]);
                 return v;
             }

             if (type == typeof(bool[]))
             {
                 bool[] v = new bool[array.Length];
                 for (int i = 0; i < array.Length; i++)
                     bool.TryParse(array[i], out v[i]);
                 return v;
             }

         }
         catch (Exception)
         {

         }
         return null;
     }

     private static object ConvertData(Type type, string str)
     {
         try
         {
             if (type == typeof(string))
                 return str;


             if (type == typeof(byte))
             {
                 byte.TryParse(str, out var val);
                 return val;
             }


             if (type == typeof(short))
             {
                 short.TryParse(str, out var val);
                 return val;
             }



             if (type == typeof(int))
             {
                 int.TryParse(str, out var val);
                 return val;
             }

             if (type == typeof(float))
             {
                 float.TryParse(str, out var val);
                 return val;
             }
             if (type == typeof(double))
             {
                 double.TryParse(str, out var val);
                 return val;
             }

             if (type == typeof(DateTime))
             {
                 DateTime.TryParse(str, result: out var val);
                 return val;
             }

             if (type == typeof(bool))
             {
                 bool.TryParse(str, out var val);
                 return val;
             }

         }
         catch (Exception)
         {


         }

         return null;
     }
 }