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

 

 

3.     #region  文件序列化的类型
4.     /// <summary>
5.     /// 序列化文件的类型
6.     /// </summary>
7.     public enum SerializeType
8.     {
9.         /// <summary>
10.         /// 字节
11.         /// </summary>
12.         Binary,
13.         /// <summary>
14.         /// xml
15.         /// </summary>
16.         Xml,
17.         /// <summary>
18.         /// soap协议的xml
19.         /// </summary>
20.         SoapXml
21.     }
22.     #endregion
24.     /// <summary>
25.     /// 序列化基类  by TangJingbo 2007/06
26.     /// 进行了修改 优化 ，读取或保存失败时对原有配置文件进行备份，以防丢失配置    
27.     /// </summary>
28.     /// <typeparam name="T">必须有无参数的构造函数</typeparam>
29.     [Serializable]
30.     public abstract class ConfigBase<T> where T : ConfigBase<T>, new()
31.     {
33.         #region 序列化类型  可重写
35.         protected SerializeType _CurrentSerializeType = SerializeType.Xml;
36.         /// <summary>
37.         /// 序列化的方式
38.         /// </summary>      
39.         [XmlIgnore]
40.         protected virtual SerializeType CurrentSerializeType
41.         {
42.             get
43.             {
44.                 return _CurrentSerializeType;
45.             }
46.             set
47.             {
48.                 _CurrentSerializeType = value;
49.             }
50.         }
52.         #endregion
54.         #region 获取
55.         /// <summary>
56.         /// 读取缓存中的实例如果不存在则
57.         /// 从ConfigFileName指定文件以CurrentSerializeType读取实例
58.         /// 如果不存在则以InitConfig初始化类,创建并保存文件
59.         /// </summary>
60.         /// <returns></returns>
61.         protected T Read()
62.         {
63.             return Read(ConfigFileName, CurrentSerializeType);
64.         }
65.         /// <summary>
66.         /// 从ConfigFileName指定文件以CurrentSerializeType读取实例，如果存在缓存则移除并重新进行缓存
67.         /// 如果不存在则以InitConfig初始化类,创建并保存文件
68.         /// </summary>
69.         /// <returns></returns>
70.         protected T ResetCacheAndRead()
71.         {
72.             ResetCache();
73.             return Read();
74.         }
75.         /// <summary>
76.         /// 移除CacheKEY 缓存
77.         /// </summary>
78.         public void ResetCache()
79.         {
80.             HttpRuntime.Cache.Remove(CacheKEY);
81.         }
82.         /// <summary>
83.         /// 获取当前类的实例
84.         /// </summary>
85.         public static T Instance
86.         {
87.             get
88.             {
89.                 T c = HttpRuntime.Cache[CacheKEY] as T;
90.                 if (c == null)
91.                 {
92.                     c = new T().Read();
93.                 }
94.                 return c;
95.             }
96.         }
97.         /// <summary>
98.         /// 获取Cache缓存的key
99.         /// </summary>
100.         public static string CacheKEY
101.         {
102.             get
103.             {
104.                 return typeof(T).FullName;
105.             }
106.         }
108.         /// <summary>
109.         ///  从ConfigFileName指定文件以CurrentSerializeType读取实例
110.         ///  如果不存在则以InitConfig初始化类,创建并保存文件
111.         /// </summary>
112.         /// <param name="configFileName"></param>
113.         /// <param name="serializeType"></param>
114.         /// <returns></returns>
115.         protected T Read(string configFileName, SerializeType serializeType)
116.         {
117.             T t = HttpRuntime.Cache[CacheKEY] as T;
118.             if (t != null)
119.                 return t;
120.             FileInfo fi = new FileInfo(configFileName);
121.             if (fi.Exists)
122.             {
123.                 FileStream fs = null;
124.                 try
125.                 {
126.                     // open the stream...
127.                     fs = new FileStream(configFileName, FileMode.Open, FileAccess.Read, FileShare.None);
128.                     IFormatter formatter = null;
129.                     switch (serializeType)
130.                     {
131.                         case SerializeType.Binary:
132.                             formatter = new BinaryFormatter();
133.                             t = formatter.Deserialize(fs) as T;
134.                             break;
135.                         case SerializeType.SoapXml:
136.                             formatter = new SoapFormatter();
137.                             t = formatter.Deserialize(fs) as T;
138.                             break;
139.                         case SerializeType.Xml:
140.                             XmlSerializer serializer = new XmlSerializer(typeof(T));
141.                             t = serializer.Deserialize(fs) as T;
142.                             break;
143.                         default:
144.                             t = default(T);
145.                             break;
146.                     }
147.                     if (fs != null)
148.                         fs.Close();
149.                     return t;
150.                 }
151.                 catch (Exception ex)
152.                 {
153.                     Log.WriteLog(ex);
154.                     if (fs != null)
155.                         fs.Close();
157.                     ///读取失败 进行备份 下面将会使用默认配置覆盖当前数据
158.                     if (fi.Exists)
159.                     {
160.                         string BackupFilePath = fi.FullName + ".Read." + DateTime.Now.ToString("yyMMddHHssfff") + ".bak";
161.                         fi.CopyTo(BackupFilePath, true);
162.                     }
163.                     t = Init();
164.                     Save(t);
165.                     return t;
166.                 }
167.                 finally
168.                 {
169.                     if (fi.Exists && t != null)
170.                         HttpRuntime.Cache.Add(CacheKEY, t, new CacheDependency(fi.FullName),
171.                            System.Web.Caching.Cache.NoAbsoluteExpiration,
172.                            TimeSpan.FromDays(7),
173.                             CacheItemPriority.NotRemovable, null);
174.                 }
175.             }
176.             else
177.             {
178.                 if (HttpRuntime.Cache[configFileName + "init"] == null)
179.                 {
180.                     HttpRuntime.Cache[configFileName + "init"] = true;
181.                 }
182.                 else
183.                 {
184.                     HttpRuntime.Cache.Remove(configFileName + "init");
185.                     throw new Exception("'" + fi.FullName + "' 文件不存在！");
186.                 }
187.                 t = Init();
188.                 if (t == null || t == default(T))
189.                     throw new Exception("初始化配置方法未返回完整的配置实例");
190.                 Save(t);
191.                 HttpRuntime.Cache.Add(CacheKEY, t, new CacheDependency(fi.FullName),
192.                           System.Web.Caching.Cache.NoAbsoluteExpiration,
193.                           TimeSpan.FromDays(7),
194.                            CacheItemPriority.NotRemovable, null);
195.                 return t;
196.             }
197.         }
198.         #endregion
200.         #region 保存
201.         /// <summary>
202.         /// 将当前实例进行保存
203.         /// </summary>
204.         /// <returns></returns>
205.         public bool Save()
206.         {
207.             return Save(Current);
208.         }
210.         /// <summary>
211.         /// 将一个实例对象保存到ConfigFileName指定的配置文件
212.         /// </summary>
213.         /// <param name="obj"></param>
214.         /// <returns></returns>
215.         protected bool Save(T obj)
216.         {
217.             FileStream fs = null;
218.             FileInfo fi = new FileInfo(ConfigFileName);
219.             string BackupFilePath = fi.FullName + ".Save." + DateTime.Now.ToString("yyMMddHHssfff") + ".bak";
220.             ///如果存在先备份
221.             if (fi.Exists)
222.             {
223.                 fi.CopyTo(BackupFilePath, true);
224.             }
225.              else if (!fi.Directory.Exists)
                 {
                     ///目录不存在创建目录
                     fi.Directory.Create();
                 }
226.             // serialize it...
227.             try
228.             {
229.                 fs = new FileStream(fi.FullName, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
230.                 IFormatter formatter = null;
231.                 switch (CurrentSerializeType)
232.                 {
233.                     case SerializeType.Binary:
234.                         formatter = new BinaryFormatter();
235.                         formatter.Serialize(fs, obj);
236.                         break;
237.                     case SerializeType.SoapXml:
238.                         formatter = new SoapFormatter();
239.                         formatter.Serialize(fs, obj);
240.                         break;
241.                     case SerializeType.Xml:
242.                         XmlSerializer serializer = new XmlSerializer(typeof(T));
243.                         serializer.Serialize(fs, obj);
244.                         break;
245.                     default:
246.                         break;
247.                 }
248.                 //成功则删除当前备份
249.                 File.Delete(BackupFilePath);
250.                 return true;
251.             }
252.             catch (Exception ex)
253.             {
254.                 throw ex;
255.             }
256.             finally
257.             {
258.                 if (fs != null)
259.                     fs.Close();
260.             }
261.         }
262.         #endregion
264.         #region  抽象成员
266.         /// <summary>
267.         /// 返回子类的当前实例
268.         /// </summary>
269.         protected abstract T Current
270.         {
271.             get;
272.         }
273.         /// <summary>
274.         /// 初始化配置类
275.         /// 当持久化化文件第一次创建时,将按该实现创建一个持久化文件
276.         /// </summary>
277.         /// <returns></returns>
278.         protected abstract T Init();
279.         /// <summary>
280.         /// 配置文件名
281.         /// </summary>
282.         [XmlIgnore]
283.         public abstract string ConfigFileName
284.         {
285.             get;
286.             set;
287.         }
288.         #endregion
289.     }