C#操作配置文件

我一般写ini，很少直接操作config，以后还是多按照微软的方式来，下次使用心得贴上与大家一起共享，以下来自网络

说了对配置文件的修改，基本上都已经是全部了，后来也补充了SingleTagSectionHandler的访问，现在把对SingleTagSectionHandler的写以及一些能偷懒的方法一起说下，希望大家有好东西都能够分享下，有时用到了，就是好东西，不用到就当作是学习吧

提供二个访问配置文件的静态方法
/// <summary>
/// 打开默认的配置文件.exe.config
/// </summary>
/// <returns></returns>
public static Configuration GetConfiguration()
{
return ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
}

/// <summary>
/// 获取指定的配置文件。
/// </summary>
/// <param name="configFullPath">配置文件的全名称</param>
/// <returns></returns>
public static Configuration GetConfiguration(string configFullPath)
{
ExeConfigurationFileMap configFile = new ExeConfigurationFileMap();
configFile.ExeConfigFilename = configFullPath;
Configuration config = ConfigurationManager.OpenMappedExeConfiguration(configFile, ConfigurationUserLevel.None);
return config;
}

通过上两个静态方法可以获取到Configuration实例

获取SingleTagSectionHandler节点的值的多个方法
/// <summary>
/// 获取SingleTagSectionHandler某节点的值。
/// </summary>
/// <param name="config"></param>
/// <param name="sectionName"></param>
/// <param name="property"></param>
/// <returns></returns>
public static string GetSingleTagSectionItemValue(this Configuration config, string sectionName, string property)
{
Dictionary<string, string> dict = GetSingleTagSectionValues(config, sectionName);
if (dict != null && dict.Count > 0)
{
if (dict.ContainsKey(property))
return (string)dict[property];
}
return null;
}

/// <summary>
/// 获取SingleTagSectionHandler节点的值。
/// </summary>
/// <param name="config"></param>
/// <param name="sectionName"></param>
/// <returns></returns>
public static Dictionary<string, string> GetSingleTagSectionValues(this Configuration config, string sectionName)
{
var section = config.GetSection(sectionName);
if (section == null || section.SectionInformation == null)
return null;
ConfigXmlDocument xdoc = new ConfigXmlDocument();
xdoc.LoadXml(section.SectionInformation.GetRawXml());
System.Xml.XmlNode xnode = xdoc.ChildNodes[0];

Dictionary<string, string> result = new Dictionary<string, string>();
IDictionary dict = (IDictionary)(new SingleTagSectionHandler().Create(null, null, xnode));
foreach (string str in dict.Keys)
{
result[str] = (string)dict[str];
}

return result;
}

更新SingleTagSection只能通过Xml来实现，在些使用了ConfigXmlDocument类，通过更改DefaultSection的SectionInfomation的RawXml来完成，同时更改SectionInformation.Type为SingleTagSectionHandler的完全限定名。

更新和删除
/// <summary>
/// 更新配置节，相同的就修改，没有的就增加。
/// </summary>
/// <param name="config"></param>
/// <param name="sectionName"></param>
/// <param name="items"></param>
public static void UpdateSingleTagSectionValues(this Configuration config, string sectionName, Dictionary<string, string> items)
{
Dictionary<string, string> orgItem = GetSingleTagSectionValues(config, sectionName);
if (orgItem == null)
orgItem = new Dictionary<string, string>();
foreach (string key in items.Keys)
{
orgItem[key] = items[key];
}
UpdateSingleTagSection(config, sectionName, orgItem);
}

/// <summary>
/// 删除配置点的一些配置。
/// </summary>
/// <param name="config"></param>
/// <param name="sectionName"></param>
/// <param name="items"></param>
public static void RemoveSingleTagSectionValues(this Configuration config, string sectionName, Dictionary<string, string> items)
{
Dictionary<string, string> orgItem = GetSingleTagSectionValues(config, sectionName);
if (orgItem != null)
{
foreach (string key in items.Keys)
{
orgItem.Remove(key);
}
UpdateSingleTagSection(config, sectionName, orgItem);
}
}

private static void UpdateSingleTagSection(Configuration config, string sectionName, Dictionary<string, string> items)
{
config.Sections.Remove(sectionName);

DefaultSection section = new DefaultSection();
config.Sections.Add(sectionName, section);
ConfigXmlDocument xdoc = new ConfigXmlDocument();
XmlNode secNode = xdoc.CreateNode(XmlNodeType.Element, sectionName, xdoc.NamespaceURI);
xdoc.AppendChild(secNode);
foreach (string key in items.Keys)
{
XmlAttribute attr = xdoc.CreateAttribute(key);
attr.Value = items[key];
secNode.Attributes.Append(attr);
}
section.SectionInformation.SetRawXml(xdoc.OuterXml);
section.SectionInformation.Type = typeof(SingleTagSectionHandler).AssemblyQualifiedName;
config.Save(ConfigurationSaveMode.Modified);
}

应该还得提供一个对自定义的配置节访问和读写的方法，以更好的扩充

自定义配置节
/// <summary>
/// 获取自定义的配置节。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="config"></param>
/// <param name="sectionName"></param>
/// <returns></returns>
public static T GetCustomSection<T>(this Configuration config, string sectionName) where T : ConfigurationSection
{
return (T)config.GetSection(sectionName);
}

/// <summary>
/// 保存自定义配置节。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="config"></param>
/// <param name="section"></param>
/// <param name="sectionName"></param>
public static void SaveCustomSection<T>(this Configuration config, T section, string sectionName) where T : ConfigurationSection
{
config.RemoveSection(sectionName);
config.Sections.Add(sectionName, section);
config.Save(ConfigurationSaveMode.Modified);
}

至于配置组，本人觉得用处不大，实现起来也很别扭，所在就不实现了，如果真的是很复杂的配置，建议自己定义一个配置节吧。

下面一些懒人的方法，本人觉得还是很不错的，至少会省掉不少的开发时间。

通过反射对实体或静态属性进行赋值，在此假设obj如果为null就使用静态属性。

反射获取属性值
private static void SetPropertiesValue(object obj, Dictionary<string, string> items, Type cfgEtyType)
{
BindingFlags bf = BindingFlags.Public;
if (obj == null)
bf |= BindingFlags.Static;
else
bf |= BindingFlags.Instance;

PropertyInfo[] pinfos = cfgEtyType.GetProperties(bf);

foreach (PropertyInfo p in pinfos)
{
try
{
if (items.ContainsKey(p.Name))
{
string val = items[p.Name];
if (!string.IsNullOrEmpty(val))
{
if (p.PropertyType.IsEnum)
{
//判断是否为数字
if (isDigital(val))
{
p.SetValue(obj, Enum.Parse(p.PropertyType, val, true), null);
}
else
{
//判断是否存在该名称
if (isExistEnumKey(p.PropertyType, val))
p.SetValue(obj, Enum.Parse(p.PropertyType, val, true), null);
}
}
else if (p.PropertyType.IsValueType) //值类型
{
MethodInfo minfo = p.PropertyType.GetMethod("Parse", new Type[] { typeof(string) });
if (minfo != null)
{
p.SetValue(obj, minfo.Invoke(null, new object[] { val }), null);
}
}
else
p.SetValue(obj, val, null);
}
else if (!p.PropertyType.IsEnum && !p.PropertyType.IsValueType)
p.SetValue(obj, val, null);
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}
}

/// <summary>
/// 判断枚举值是否为数字
/// </summary>
/// <param name="strValue"></param>
/// <returns></returns>
private static bool isDigital(string strValue)
{
return Regex.IsMatch(strValue, @"^(\d+)$");
}

/// <summary>
/// 判断是否存在枚举的名称
/// </summary>
/// <param name="type"></param>
/// <param name="keyName"></param>
/// <returns></returns>
private static bool isExistEnumKey(Type type, string keyName)
{
bool isExist = false;
foreach (string key in Enum.GetNames(type))
{
if (key.Equals(keyName, StringComparison.OrdinalIgnoreCase))
{
isExist = true;
break;
}
}
return isExist;
}

动态获取值，在此再次强调，属性值必需和配置节的Key等相同，包括大小写。

使用抽象类的静态属性来取出配置节的值
/// <summary>
/// 使用反射获取实体配置节的值，实体的静态属性必需和配置的Key相同。
/// </summary>
/// <param name="config">打开的配置实例</param>
/// <typeparam name="T">要取值的类，类的静态属性要和Key值对应</typeparam>
/// <param name="sectionName">T 对就的配置节的名称</param>
public static void GetKeyValueSectionConfigValue<T>(this Configuration config, string sectionName) where T : class
{
try
{
Dictionary<string, string> dict = GetKeyValueSectionValues(config, sectionName);
Type cfgEtyType = typeof(T);
SetPropertiesValue(null, dict, cfgEtyType);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}

提供几个和Configuration实例无关的辅助方法，但也作为扩展方法来实现，以方便操作，只要由实例和抽象类来获取到HashTable的值，和反过来取得实例的值

辅助方法
/// <summary>
/// 由集合根据字段的属性生成实体。属性名为key，属性值为value。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="config"></param>
/// <param name="items"></param>
/// <returns></returns>
public static T GetConfigEntityByItems<T>(this Configuration config, Dictionary<string, string> items) where T : class
{
Type etyType = typeof(T);
Func<object> func = etyType.CreateInstanceDelegate();
object ety = func.Invoke();

SetPropertiesValue(ety, items, etyType);

return (T)ety;
}

/// <summary>
/// 由实例生成配置的项。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="config">没有实际使用到</param>
/// <param name="instance"></param>
/// <returns></returns>
public static Dictionary<string, string> GetItemsByConfigEntity<T>(this Configuration config, T instance) where T : class
{
Type cfgEtyType = typeof(T);
BindingFlags bf = BindingFlags.Public;
if (instance == null)
bf |= BindingFlags.Static;
else
bf |= BindingFlags.Instance;
PropertyInfo[] pinfos = cfgEtyType.GetProperties(bf);
Dictionary<string, string> dict = new Dictionary<string, string>();

foreach (PropertyInfo p in pinfos)
{
dict[p.Name] = "" + p.GetValue(instance, null);
}
return dict;
}

/// <summary>
/// 由类的静态属性生成配置项。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Dictionary<string, string> GetItemsByClass<T>(this Configuration config) where T : class
{
return GetItemsByConfigEntity<T>(config, null);
}

从appSettings获取值
/// <summary>
/// 获取appSettings的配置值。Key值 和 T 的静态属性相同才能取出来。
/// </summary>
/// <param name="config">打开的配置实例</param>
/// <typeparam name="T">要取值的类，类的静态属性要和Key值对应</typeparam>
public static void GetAppSettingsConfigValue<T>(this Configuration config) where T : class
{
//通过反射自动值，增加属性只需把配置的key值和属性的名称相同即可。
////Type cfgType = typeof(ConfigUtility);

////MethodInfo getAppConfigMethod = cfgType.GetMethod("GetAppConfig", BindingFlags.Static | BindingFlags.Public);
Type etyType = typeof(T);

Dictionary<string, string> items = GetAppSettings(config);

SetPropertiesValue(null, items, etyType);
}

配置节的保存

保存配置节
/// <summary>
/// 保存 Section 配置的值。保存为DictionarySectionHandler配置节。
/// </summary>
/// <param name="config"></param>
/// <typeparam name="T"></typeparam>
/// <param name="sectionName"></param>
public static void SaveKeyValueSectionConfig<T>(this Configuration config, string sectionName) where T : class
{
var orgsection = config.GetSection(sectionName);
if (orgsection != null)
config.Sections.Remove(sectionName);

AppSettingsSection section = new AppSettingsSection();
config.Sections.Add(sectionName, section);

Type etyType = typeof(T);
foreach (PropertyInfo pinfo in etyType.GetProperties(BindingFlags.Static | BindingFlags.Public))
{
string keyName = pinfo.Name;
object objValue = pinfo.GetValue(null, null);
////section.Settings.Remove(keyName);
section.Settings.Add(new KeyValueConfigurationElement(keyName, "" + objValue));
}
section.SectionInformation.Type = typeof(DictionarySectionHandler).AssemblyQualifiedName;
config.Save(ConfigurationSaveMode.Modified);
}

/// <summary>
/// 保存为 AppSettings 配置的值。
/// </summary>
/// <typeparam name="T"></typeparam>
public static void SaveAppSettingsConfig<T>(this Configuration config) where T : class
{
try
{
Type etyType = typeof(T);
foreach (PropertyInfo pinfo in etyType.GetProperties(BindingFlags.Static | BindingFlags.Public))
{
string keyName = pinfo.Name;

object objValue = pinfo.GetValue(null, null);

UpdateAppSettingsItemNoSave(config, keyName, "" + objValue);
}

config.Save(ConfigurationSaveMode.Modified);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}

配置文件修改系列在此告一段落了，再附加上创建实体用到的Type的扩展，是从网络抄摘下来的，在本息用了代替Activator来创建实例，效率会快点。

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

namespace System
{
public static class TypeExtensions
{
public static Func<object> CreateInstanceDelegate(this Type type)
{
NewExpression newExp = Expression.New(type);
Expression<Func<object>> lambdaExp =
Expression.Lambda<Func<object>>(newExp, null);
Func<object> func = lambdaExp.Compile();
return func;
}

public static Func<T, object> CreateInstanceDelegate<T>(this Type type)
{
Type paramType = typeof(T);
var construtor = type.GetConstructor(new Type[] { paramType });
var param = new ParameterExpression[] { Expression.Parameter(paramType, "arg") };

NewExpression newExp = Expression.New(construtor, param);
Expression<Func<T, object>> lambdaExp =
Expression.Lambda<Func<T, object>>(newExp, param);
Func<T, object> func = lambdaExp.Compile();
return func;
}

public static Func<T1, T2, object> CreateInstanceDelegate<T1, T2>(this　Type type)
{
var types = new Type[] { typeof(T1), typeof(T2) };
var construtor = type.GetConstructor(types);
int i = 0;
var param = types.Select(t => Expression.Parameter(t, "arg" + (i++))).ToArray();
NewExpression newExp = Expression.New(construtor, param);
Expression<Func<T1, T2, object>> lambdaExp = Expression.Lambda<Func<T1, T2, object>>(newExp, param);
Func<T1, T2, object> func = lambdaExp.Compile();
return func;
}

//以下方法中的Lambda表达式“Expression<Func<object[], object>> ”已经定义参数是object[], 而构造函数的参数却不能自动转化。当使用以下代码作测试，

//////以下代码有bug!
////public static Func<object[], object> CreateInstanceDelegate(this Type type, params object[] args)
////{
//// var construtor = type.GetConstructor(args.Select(c => c.GetType()).ToArray());
//// var param = buildParameters(args);

//// NewExpression newExp = Expression.New(construtor, param);
//// Expression<Func<object[], object>> lambdaExp =
//// Expression.Lambda<Func<object[], object>>(newExp, param);
//// Func<object[], object> func = lambdaExp.Compile();
//// return func;
////}

////static ParameterExpression[] buildParameters(object[] args)
////{
//// int i = 0;
//// List<ParameterExpression> list = new List<ParameterExpression>();
//// foreach (object arg in args)
//// {
//// list.Add(Expression.Parameter(arg.GetType(), "arg" + (i++)));
//// }
//// return list.ToArray();
////}

}
}

-----------------The End----------------

谢谢大家！

本文出自 Lance Yang