保存类中变量或属性到XML配置文件

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Xml;
using System.Reflection;

namespace MasterCom.Util
{
[System.AttributeUsage(System.AttributeTargets.Field |
System.AttributeTargets.Property)]
public class NonSaveConfig : System.Attribute
{ }

/// <summary>
/// 配置文件，用来保存类的Field和Propertie为XML文件
/// 只保存public 的Field 和 有get和set的Propertie
/// 如果存在[NonSaveConfig]属性则不保存
/// by:Gene
/// </summary>
public class AConfig
{
public virtual string ConfigFile
{
get
{
return System.Windows.Forms.Application.StartupPath + "/config/" + this.GetType().Name + ".xml";
}
}

public virtual void Load()
{
if (!System.IO.File.Exists(ConfigFile)) return;
MyXmlConfigFile configFile = new MyXmlConfigFile(ConfigFile);
try
{
ConfigParames = configFile.GetItemValue(this.GetType().Name, "ConfigParames") as Dictionary<string, object>;
}
catch { }
}

public virtual void Save()
{
MyXmlConfigFile configFile = new MyXmlConfigFile();
XmlElement con = configFile.AddConfig(this.GetType().Name);
configFile.AddItem(con, "ConfigParames", ConfigParames);
configFile.Save(ConfigFile);
}

public virtual Dictionary<string, object> ConfigParames
{
get
{
Dictionary<string, object> objs = new Dictionary<string, object>();
foreach (FieldInfo fi in this.GetType().GetFields())
{
if (fi.Name.Equals("ConfigParames") || fi.FieldType.Equals(this.GetType()))
{
continue;
}
else
{
object obj = fi.GetValue(this);
if (IsNeedSave(fi.GetCustomAttributes(true)))
objs.Add(fi.Name, getGetData(obj));
}
}
foreach (PropertyInfo pi in this.GetType().GetProperties())
{
if (pi.Name.Equals("ConfigParames") || pi.DeclaringType.Equals(this.GetType()))
{
continue;
}
else
{
object obj = pi.GetValue(this, null);
if (IsNeedSave(pi.GetCustomAttributes(true)) && pi.CanRead && pi.CanWrite)
objs.Add(pi.Name, getGetData(obj));
}
}
return objs;
}
set
{
if (value == null) return;
foreach (FieldInfo fi in this.GetType().GetFields())
{
if (!value.ContainsKey(fi.Name) || !fi.IsPublic) continue;
fi.SetValue(this, getSetData(fi.FieldType, value[fi.Name]));
}
foreach (PropertyInfo pi in this.GetType().GetProperties())
{
if (!value.ContainsKey(pi.Name) || !(pi.CanRead && pi.CanWrite)) continue;
pi.SetValue(this, getSetData(pi.DeclaringType, value[pi.Name]), null);
}
}
}

private object getSetData(Type type, object obj2)
{

object obj = null;
try
{
obj = System.Activator.CreateInstance(type);
}
catch { }
try
{
if (obj == null)
{
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
obj = System.Activator.CreateInstance(assembly.FullName, type.FullName);
}
}
catch { }
if (obj is AConfig)
{
AConfig idc = obj as AConfig;
idc.ConfigParames = obj2 as Dictionary<string, object>;
return idc;
}
else if (obj is IList && obj2 is IList)
{
IList idc = obj as IList;
foreach (object obj1 in (IList)obj2)
{
idc.Add(getSetData(type.GetGenericArguments()[0], obj1));
}
return idc;
}
else if (obj is Array && obj2 is Array)
{
Array idc = obj as Array;
for (int i = 0; i < idc.Length; i++)
{
idc.SetValue(getSetData(type.GetGenericArguments()[0], ((Array)obj2).GetValue(i)), i);
}
return idc;
}
else if (obj is IDictionary && obj2 is Array)
{
IDictionary idc = obj as IDictionary;
foreach (object obj1 in ((IDictionary)obj2).Keys)
{
idc.Add(obj1.ToString(), getSetData(type.GetGenericArguments()[1], ((IDictionary)obj2)[obj1]));
}
return idc;
}
else
return obj2;
}

private object getGetData(object obj)
{
if (obj is AConfig)
{
return ((AConfig)obj).ConfigParames;
}
else if (obj is IList)
{
List<object> objs = new List<object>();
foreach (object obj2 in (IList)obj)
{
objs.Add(getGetData(obj2));
}
return objs;
}
else if (obj is Array)
{
object[] objs = new object[((Array)obj).Length];
for (int i = 0; i < objs.Length; i++)
{
objs.SetValue(getGetData(objs.GetValue(i)), i);
}
return objs;
}
else if (obj is IDictionary)
{
Dictionary<string, object> objs = new Dictionary<string, object>();
IDictionary ids = obj as IDictionary;
foreach (object obj2 in ids.Keys)
{
objs.Add(obj2.ToString(), getGetData(obj2));
}
return objs;
}
else
return obj;
}

private bool IsNeedSave(object[] attrs)
{
foreach (System.Attribute attr in attrs)
{
if (attr is NonSaveConfig)
{
return false;
}
}
return true;
}
}
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Collections;

namespace MasterCom.Util
{
/// <summary>
/// by:Gene
/// </summary>
public class MyXmlConfigFile
{
public delegate object GetItemValueObject(MyXmlConfigFile configFile, XmlElement item, string typeName);

public delegate XmlElement AddItemObject(MyXmlConfigFile configFile, XmlElement config, string name, object value);

public MyXmlConfigFile()
{
doc.AppendChild(doc.CreateXmlDeclaration("1.0", null, null));
doc.AppendChild(doc.CreateElement(TagConfigs));
}

public MyXmlConfigFile(string filePath)
{
this.filePath = filePath;
try
{
doc.Load(filePath);
}
catch
{
}
}

public XmlElement AddConfig(string name)
{
XmlElement config = doc.CreateElement(TagConfig);
AddNameAttribute(config, name);
doc.DocumentElement.AppendChild(config);
return config;
}

public XmlElement AddItem(XmlElement config)
{
XmlElement item = doc.CreateElement(TagItem);
config.AppendChild(item);
return item;
}

public XmlElement AddItem(XmlElement config, string name)
{
XmlElement item = AddItem(config);
if (name != null && name.Length > 0)
{
AddNameAttribute(item, name);
}
return item;
}

public XmlElement AddItem(XmlElement config, string name, Type type)
{
XmlElement item = AddItem(config, name);
AddTypeAttribute(item, type);
return item;
}

public XmlElement AddItem(XmlElement config, string name, string value)
{
XmlElement item = AddItem(config, name, typeof(string));
if (value != null && value.Length > 0)
{
item.AppendChild(doc.CreateTextNode(value));
}
return item;
}

public XmlElement AddItem(XmlElement config, string name, string value, AddItemObject callBack)
{
return AddItem(config, name, value);
}

public XmlElement AddItem(XmlElement config, string name, int value)
{
XmlElement item = AddItem(config, name, typeof(int));
item.AppendChild(doc.CreateTextNode(value.ToString()));
return item;
}

public XmlElement AddItem(XmlElement config, string name, int value, AddItemObject callBack)
{
return AddItem(config, name, value);
}

public XmlElement AddItem(XmlElement config, string name, long value)
{
XmlElement item = AddItem(config, name, typeof(long));
item.AppendChild(doc.CreateTextNode(value.ToString()));
return item;
}

public XmlElement AddItem(XmlElement config, string name, long value, AddItemObject callBack)
{
return AddItem(config, name, value);
}

public XmlElement AddItem(XmlElement config, string name, float value)
{
XmlElement item = AddItem(config, name, typeof(float));
item.AppendChild(doc.CreateTextNode(value.ToString()));
return item;
}

public XmlElement AddItem(XmlElement config, string name, float value, AddItemObject callBack)
{
return AddItem(config, name, value);
}

public XmlElement AddItem(XmlElement config, string name, double value)
{
XmlElement item = AddItem(config, name, typeof(double));
item.AppendChild(doc.CreateTextNode(value.ToString()));
return item;
}

public XmlElement AddItem(XmlElement config, string name, decimal value)
{
XmlElement item = AddItem(config, name, typeof(decimal));
item.AppendChild(doc.CreateTextNode(value.ToString()));
return item;
}

public XmlElement AddItem(XmlElement config, string name, double value, AddItemObject callBack)
{
return AddItem(config, name, value);
}

public XmlElement AddItem(XmlElement config, string name, char value)
{
XmlElement item = AddItem(config, name, typeof(char));
item.AppendChild(doc.CreateTextNode(value.ToString()));
return item;
}

public XmlElement AddItem(XmlElement config, string name, char value, AddItemObject callBack)
{
return AddItem(config, name, value);
}

public XmlElement AddItem(XmlElement config, string name, bool value)
{
XmlElement item = AddItem(config, name, typeof(bool));
item.AppendChild(doc.CreateTextNode(value.ToString()));
return item;
}

public XmlElement AddItem(XmlElement config, string name, bool value, AddItemObject callBack)
{
return AddItem(config, name, value);
}

public XmlElement AddItem(XmlElement config, string name, System.Drawing.Color value)
{
XmlElement item = AddItem(config, name, typeof(System.Drawing.Color));
item.AppendChild(doc.CreateTextNode(value.A+","+value.R+","+value.G+","+value.B));
return item;
}

public XmlElement AddItem(XmlElement config, string name, System.Drawing.Color value, AddItemObject callBack)
{
return AddItem(config, name, value);
}

public XmlElement AddItem<T>(XmlElement config, string name, IList<T> value)
{
return AddItem(config, name, value, null);
}

public XmlElement AddItem<T>(XmlElement config, string name, List<T> value, AddItemObject callBack)
{
XmlElement item = AddItem(config, name, typeof(IList));
if (value != null && value.Count > 0)
{
foreach (T childValue in value)
{
AddItem(item, null, childValue, callBack);
}
}
return item;
}

public XmlElement AddItem<K, V>(XmlElement config, string name, Dictionary<K, V> value)
{
return AddItem(config, name, value, null);
}

public XmlElement AddItem<K, V>(XmlElement config, string name, Dictionary<K, V> value, AddItemObject callBack)
{
XmlElement item = AddItem(config, name, typeof(IDictionary));
if (value != null && value.Count > 0)
{
foreach (K key in value.Keys)
{
V childValue = value[key];
XmlElement itemChild = AddItem(item, null, childValue, callBack);
AddKeyAttribute(itemChild, key.ToString());
}
}
return item;
}

public XmlElement AddItem(XmlElement config, string name, object value)
{
return AddItem(config, name, value, null);
}

public XmlElement AddItem(XmlElement config, string name, object value, AddItemObject callBack)
{
XmlElement item = null;
if (value != null)
{
if (value is string)
{
item = AddItem(config, name, (string)value);
}
else if (value is int)
{
item = AddItem(config, name, (int)value);
}
else if (value is long)
{
item = AddItem(config, name, (long)value);
}
else if (value is float)
{
item = AddItem(config, name, (float)value);
}
else if (value is double)
{
item = AddItem(config, name, (double)value);
}
else if (value is decimal)
{
item = AddItem(config, name, (decimal)value);
}
else if (value is char)
{
item = AddItem(config, name, (char)value);
}
else if (value is bool)
{
item = AddItem(config, name, (bool)value);
}
else if (value is System.Drawing.Color)
{
item = AddItem(config, name, (System.Drawing.Color)value);
}
else if (value is IList)
{
IList list = (IList)value;
item = AddItem(config, name, typeof(IList));
if (value != null && list.Count > 0)
{
foreach (object childValue in list)
{
AddItem(item, null, childValue, callBack);
}
}
}
else if (value is IDictionary)
{
IDictionary dictionary = (IDictionary)value;
item = AddItem(config, name, typeof(IDictionary));
if (value != null && dictionary.Count > 0)
{
foreach (object key in dictionary.Keys)
{
object childValue = dictionary[key];
XmlElement itemChild = AddItem(item, null, childValue, callBack);
AddKeyAttribute(itemChild, key.ToString());
}
}
}
else if (callBack != null)
{
item = callBack(this, config, name, value);
}
else
{
item = AddItem(config, name, value.GetType());
}
}
else
{
item = AddItem(config, name);
}
return item;
}

public XmlAttribute AddNameAttribute(XmlElement item, string name)
{
return AddAttribute(item, TagName, name);
}

public XmlAttribute AddTypeAttribute(XmlElement item, Type type)
{
return AddAttribute(item, TagTypeName, type.Name);
}

public XmlAttribute AddKeyAttribute(XmlElement item, string key)
{
return AddAttribute(item, TagKey, key);
}

public XmlAttribute AddAttribute(XmlElement item, string name, string value)
{
XmlAttribute attribute = doc.CreateAttribute(name);
attribute.Value = value;
item.Attributes.Append(attribute);
return attribute;
}

public XmlElement GetConfig(string name)
{
foreach (XmlElement config in doc.DocumentElement.ChildNodes)
{
if (name != null && name.Equals(config.Attributes[TagName].Value))
{
return config;
}
}
return null;
}

public XmlElement GetItem(XmlElement config, string name)
{
if (config != null)
{
foreach (XmlElement item in config.ChildNodes)
{
if (name != null && name.Equals(item.Attributes[TagName].Value))
{
return item;
}
}
}
return null;
}

public XmlElement GetItem(string configName, string ItemName)
{
return GetItem(GetConfig(configName), ItemName);
}

public object GetItemValue(string configName, string itemName)
{
return GetItemValue(configName, itemName, null);
}

public object GetItemValue(string configName, string itemName, GetItemValueObject callBack)
{
return GetItemValue(GetConfig(configName), itemName, callBack);
}

public object GetItemValue(XmlElement config, string itemName)
{
return GetItemValue(config, itemName, null);
}

public object GetItemValue(XmlElement config, string itemName, GetItemValueObject callBack)
{
return GetItemValue(GetItem(config, itemName), callBack);
}

public object GetItemValue(XmlElement item)
{
return GetItemValue(item, (GetItemValueObject)null);
}

public object GetItemValue(XmlElement item, GetItemValueObject callBack)
{
if (item != null && item.Attributes[TagTypeName] != null)
{
string typeName = item.Attributes[TagTypeName].Value;
if (typeName != null)
{
if (typeName.Equals(typeof(string).Name))
{
return item.FirstChild == null ? null : item.FirstChild.InnerText;
}
else if (typeName.Equals(typeof(int).Name))
{
return item.FirstChild == null ? null : (object)int.Parse(item.FirstChild.InnerText);
}
else if (typeName.Equals(typeof(long).Name))
{
return item.FirstChild == null ? null : (object)long.Parse(item.FirstChild.InnerText);
}
else if (typeName.Equals(typeof(float).Name))
{
return item.FirstChild == null ? null : (object)float.Parse(item.FirstChild.InnerText);
}
else if (typeName.Equals(typeof(double).Name))
{
return item.FirstChild == null ? null : (object)double.Parse(item.FirstChild.InnerText);
}
else if (typeName.Equals(typeof(decimal).Name))
{
return item.FirstChild == null ? null : (object)decimal.Parse(item.FirstChild.InnerText);
}
else if (typeName.Equals(typeof(char).Name))
{
return item.FirstChild == null ? null : (object)char.Parse(item.FirstChild.InnerText);
}
else if (typeName.Equals(typeof(bool).Name))
{
return item.FirstChild == null ? null : (object)bool.Parse(item.FirstChild.InnerText);
}
else if (typeName.Equals(typeof(System.Drawing.Color).Name))
{
if (item.FirstChild == null) return null;
string[] strs = item.FirstChild.InnerText.Split(',');
if (strs.Length < 4) return null;
System.Drawing.Color col = System.Drawing.Color.FromArgb(
int.Parse(strs[0]),
int.Parse(strs[1]),
int.Parse(strs[2]),
int.Parse(strs[3]));
return col;
}
else if (typeName.Equals(typeof(IList).Name))
{
List<object> value = new List<object>();
foreach (XmlElement itemChild in item.ChildNodes)
{
object childValue = GetItemValue(itemChild, callBack);
value.Add(childValue);
}
return value;
}
else if (typeName.Equals(typeof(IDictionary).Name))
{
Dictionary<string, object> value = new Dictionary<string, object>();
foreach (XmlElement itemChild in item.ChildNodes)
{
string key = itemChild.Attributes[TagKey].InnerText;
object childValue = GetItemValue(itemChild, callBack);
value[key] = childValue;
}
return value;
}
}
if (callBack != null)
{
return callBack(this, item, typeName);
}
}
return null;
}

public bool Load()
{
try
{
doc.Load(filePath);
}
catch
{
return false;
}
return true;
}

public bool Save()
{
try
{
new System.IO.FileInfo(filePath).Directory.Create();
doc.Save(filePath);
}
catch
{
return false;
}
return true;
}

public bool Save(string filePath)
{
this.filePath = filePath;
return Save();
}

private static string TagConfigs = "Configs";

private static string TagConfig = "Config";

private static string TagItem = "Item";

private static string TagName = "name";

private static string TagTypeName = "typeName";

private static string TagKey = "key";

private XmlDocument doc = new XmlDocument();

private string filePath;
}
}