通用序列化基类 只须实现该类抽象成员即可进行序列化与反序列化

#region 文件序列化的类型

/// <summary>

/// 序列化文件的类型

/// </summary>

public enum SerializeType

{

/// <summary>

/// 字节

/// </summary>

Binary,

/// <summary>

/// xml

/// </summary>

Xml,

/// <summary>

/// soap协议的xml

/// </summary>

SoapXml

}

#endregion

/// <summary>

/// 序列化基类 by TangJingbo 2007/06

/// 进行了修改 优化 ，读取或保存失败时对原有配置文件进行备份，以防丢失配置

/// </summary>

/// <typeparam name="T">必须有无参数的构造函数</typeparam>

[Serializable]

public abstract class ConfigBase<T> where T : ConfigBase<T>, new()

{

#region 序列化类型 可重写

protected SerializeType _CurrentSerializeType = SerializeType.Xml;

/// <summary>

/// 序列化的方式

/// </summary>

[XmlIgnore]

protected virtual SerializeType CurrentSerializeType

{

get

{

return _CurrentSerializeType;

}

set

{

_CurrentSerializeType = value;

}

}

#endregion

#region 获取

/// <summary>

/// 读取缓存中的实例如果不存在则

/// 从ConfigFileName指定文件以CurrentSerializeType读取实例

/// 如果不存在则以InitConfig初始化类,创建并保存文件

/// </summary>

/// <returns></returns>

protected T Read()

{

return Read(ConfigFileName, CurrentSerializeType);

}

/// <summary>

/// 从ConfigFileName指定文件以CurrentSerializeType读取实例，如果存在缓存则移除并重新进行缓存

/// 如果不存在则以InitConfig初始化类,创建并保存文件

/// </summary>

/// <returns></returns>

protected T ResetCacheAndRead()

{

ResetCache();

return Read();

}

/// <summary>

/// 移除CacheKEY 缓存

/// </summary>

public void ResetCache()

{

HttpRuntime.Cache.Remove(CacheKEY);

}

/// <summary>

/// 获取当前类的实例

/// </summary>

public static T Instance

{

get

{

T c = HttpRuntime.Cache[CacheKEY] as T;

if (c == null)

{

c = new T().Read();

}

return c;

}

}

/// <summary>

/// 获取Cache缓存的key

/// </summary>

public static string CacheKEY

{

get

{

return typeof(T).FullName;

}

}

/// <summary>

/// 从ConfigFileName指定文件以CurrentSerializeType读取实例

/// 如果不存在则以InitConfig初始化类,创建并保存文件

/// </summary>

/// <param name="configFileName"></param>

/// <param name="serializeType"></param>

/// <returns></returns>

protected T Read(string configFileName, SerializeType serializeType)

{

T t = HttpRuntime.Cache[CacheKEY] as T;

if (t != null)

return t;

FileInfo fi = new FileInfo(configFileName);

if (fi.Exists)

{

FileStream fs = null;

try

{

// open the stream...

fs = new FileStream(configFileName, FileMode.Open, FileAccess.Read, FileShare.None);

IFormatter formatter = null;

switch (serializeType)

{

case SerializeType.Binary:

formatter = new BinaryFormatter();

t = formatter.Deserialize(fs) as T;

break;

case SerializeType.SoapXml:

formatter = new SoapFormatter();

t = formatter.Deserialize(fs) as T;

break;

case SerializeType.Xml:

XmlSerializer serializer = new XmlSerializer(typeof(T));

t = serializer.Deserialize(fs) as T;

break;

default:

t = default(T);

break;

}

if (fs != null)

fs.Close();

return t;

}

catch (Exception ex)

{

Log.WriteLog(ex);

if (fs != null)

fs.Close();

///读取失败 进行备份 下面将会使用默认配置覆盖当前数据

if (fi.Exists)

{

string BackupFilePath = fi.FullName + ".Read." + DateTime.Now.ToString("yyMMddHHssfff") + ".bak";

fi.CopyTo(BackupFilePath, true);

}

t = Init();

Save(t);

return t;

}

finally

{

if (fi.Exists && t != null)

HttpRuntime.Cache.Add(CacheKEY, t, new CacheDependency(fi.FullName),

System.Web.Caching.Cache.NoAbsoluteExpiration,

TimeSpan.FromDays(7),

CacheItemPriority.NotRemovable, null);

}

}

else

{

if (HttpRuntime.Cache[configFileName + "init"] == null)

{

HttpRuntime.Cache[configFileName + "init"] = true;

}

else

{

HttpRuntime.Cache.Remove(configFileName + "init");

throw new Exception("'" + fi.FullName + "' 文件不存在！");

}

t = Init();

if (t == null || t == default(T))

throw new Exception("初始化配置方法未返回完整的配置实例");

Save(t);

HttpRuntime.Cache.Add(CacheKEY, t, new CacheDependency(fi.FullName),

System.Web.Caching.Cache.NoAbsoluteExpiration,

TimeSpan.FromDays(7),

CacheItemPriority.NotRemovable, null);

return t;

}

}

#endregion

#region 保存

/// <summary>

/// 将当前实例进行保存

/// </summary>

/// <returns></returns>

public bool Save()

{

return Save(Current);

}

/// <summary>

/// 将一个实例对象保存到ConfigFileName指定的配置文件

/// </summary>

/// <param name="obj"></param>

/// <returns></returns>

protected bool Save(T obj)

{

FileStream fs = null;

FileInfo fi = new FileInfo(ConfigFileName);

string BackupFilePath = fi.FullName + ".Save." + DateTime.Now.ToString("yyMMddHHssfff") + ".bak";

///如果存在先备份

if (fi.Exists)

{

fi.CopyTo(BackupFilePath, true);

}

else if (!fi.Directory.Exists)
{
///目录不存在创建目录
fi.Directory.Create();
}

// serialize it...

try

{

fs = new FileStream(fi.FullName, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);

IFormatter formatter = null;

switch (CurrentSerializeType)

{

case SerializeType.Binary:

formatter = new BinaryFormatter();

formatter.Serialize(fs, obj);

break;

case SerializeType.SoapXml:

formatter = new SoapFormatter();

formatter.Serialize(fs, obj);

break;

case SerializeType.Xml:

XmlSerializer serializer = new XmlSerializer(typeof(T));

serializer.Serialize(fs, obj);

break;

default:

break;

}

//成功则删除当前备份

File.Delete(BackupFilePath);

return true;

}

catch (Exception ex)

{

throw ex;

}

finally

{

if (fs != null)

fs.Close();

}

}

#endregion

#region 抽象成员

/// <summary>

/// 返回子类的当前实例

/// </summary>

protected abstract T Current

{

get;

}

/// <summary>

/// 初始化配置类

/// 当持久化化文件第一次创建时,将按该实现创建一个持久化文件

/// </summary>

/// <returns></returns>

protected abstract T Init();

/// <summary>

/// 配置文件名

/// </summary>

[XmlIgnore]

public abstract string ConfigFileName

{

get;

set;

}

#endregion

}