XmlBase.cs
上传用户:husern
上传日期:2022-03-24
资源大小:534k
文件大小:17k
源码类别:

编辑器/阅读器

开发平台:

C#

  1. // -- FILE ------------------------------------------------------------------
  2. // name       : XmlBase.cs
  3. // project    : Itenso Web User Forms
  4. // created    : Jani Giannoudis - 2008.10.30
  5. // language   : c#
  6. // environment: .NET 2.0
  7. // copyright  : (c) 2008 by Itenso GmbH, Switzerland
  8. // --------------------------------------------------------------------------
  9. using System;
  10. using System.IO;
  11. using System.Xml;
  12. using System.Xml.Schema;
  13. using System.Text;
  14. using System.Globalization;
  15. namespace Itenso.WebUserForms.Data
  16. {
  17. // ------------------------------------------------------------------------
  18. // TC must be a referential type which implements T and which provides a public no-arg c'tor
  19. public abstract class XmlBase<T, TC> where TC : class, T, new()
  20. {
  21. // ----------------------------------------------------------------------
  22. public const string NoPrefix = "";
  23. public const string WufPrefix = "wuf";
  24. public const string WufNamespace = "http://www.itenso.com/xml/schema/webuserforms";
  25. public const string XmlDateFormat = "yyyy'-'MM'-'dd";
  26. public const string XmlTimeFormat = "HH':'mm':'ss";
  27. public const string XmlDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss";
  28. // ----------------------------------------------------------------------
  29. protected XmlBase( string docTag, XmlReaderSettings xmlReadSettings )
  30. {
  31. if ( string.IsNullOrEmpty( docTag ) )
  32. {
  33. throw new ArgumentNullException( "docTag" );
  34. }
  35. if ( xmlReadSettings == null )
  36. {
  37. throw new ArgumentNullException( "xmlReadSettings" );
  38. }
  39. this.docTag = docTag;
  40. this.xmlReadSettings = xmlReadSettings;
  41. } // XmlBase
  42. // ----------------------------------------------------------------------
  43. public string ToXmlString( T content )
  44. {
  45. string formatted = null;
  46. if ( content != null )
  47. {
  48. using ( StringWriter stringWriter = new StringWriter( CultureInfo.InvariantCulture ) )
  49. {
  50. Save( content, stringWriter );
  51. stringWriter.Flush();
  52. formatted = stringWriter.ToString();
  53. }
  54. }
  55. return formatted;
  56. } // ToXmlString
  57. // ----------------------------------------------------------------------
  58. public TC FromXmlString( string contentXml )
  59. {
  60. TC loaded = null;
  61. if ( !string.IsNullOrEmpty( contentXml ) )
  62. {
  63. using ( StringReader stringReader = new StringReader( contentXml ) )
  64. {
  65. loaded = Load( stringReader );
  66. }
  67. }
  68. return loaded;
  69. } // FromXmlString
  70. // ----------------------------------------------------------------------
  71. public void Save( T content, Stream stream )
  72. {
  73. XmlDocument saved = Save( content );
  74. Write( saved, stream );
  75. } // Save
  76. // ----------------------------------------------------------------------
  77. public TC Load( Stream contentXml )
  78. {
  79. TC loaded = null;
  80. if ( contentXml != null )
  81. {
  82. using ( XmlReader xmlReader = XmlReader.Create( contentXml, xmlReadSettings ) )
  83. {
  84. loaded = Load( xmlReader );
  85. }
  86. }
  87. return loaded;
  88. } // Load
  89. // ----------------------------------------------------------------------
  90. public void Save( T content, TextWriter writer )
  91. {
  92. XmlDocument saved = Save( content );
  93. Write( saved, writer );
  94. } // Save
  95. // ----------------------------------------------------------------------
  96. public TC Load( TextReader contentXml )
  97. {
  98. TC loaded = null;
  99. if ( contentXml != null )
  100. {
  101. using ( XmlReader xmlReader = XmlReader.Create( contentXml, xmlReadSettings ) )
  102. {
  103. loaded = Load( xmlReader );
  104. }
  105. }
  106. return loaded;
  107. } // Load
  108. // ----------------------------------------------------------------------
  109. private TC Load( XmlReader contentXml )
  110. {
  111. TC loaded = null;
  112. try
  113. {
  114. XmlDocument doc = new XmlDocument();
  115. doc.Load( contentXml );
  116. XmlElement docElement = doc.DocumentElement;
  117. if ( docTag.Equals( docElement.LocalName ) )
  118. {
  119. loaded = Load( docElement );
  120. }
  121. else
  122. {
  123. throw new XmlException( string.Format(
  124. "invalid document tag {1}, was expecting {0}", docTag, docElement.LocalName ) );
  125. }
  126. }
  127. catch ( XmlSchemaException e )
  128. {
  129. throw new XmlException( e.Message, e );
  130. }
  131. return loaded;
  132. } // Load
  133. // ----------------------------------------------------------------------
  134. public XmlDocument Save( T content )
  135. {
  136. if ( content == null )
  137. {
  138. throw new ArgumentNullException( "content" );
  139. }
  140. XmlDocument doc = new XmlDocument();
  141. XmlElement docElement = AppendTag( doc, docTag );
  142. Save( content, docElement );
  143. return doc;
  144. } // Save
  145. // ----------------------------------------------------------------------
  146. public TC Load( XmlElement contentXml )
  147. {
  148. TC loaded = null;
  149. try
  150. {
  151. loaded = new TC();
  152. Load( loaded, contentXml );
  153. }
  154. catch ( XmlSchemaException e )
  155. {
  156. throw new XmlException( e.Message, e );
  157. }
  158. return loaded;
  159. } // Load
  160. // ----------------------------------------------------------------------
  161. public void Load( T content, XmlElement contentXml )
  162. {
  163. if ( content == null )
  164. {
  165. throw new ArgumentNullException( "content" );
  166. }
  167. if ( contentXml == null )
  168. {
  169. throw new ArgumentNullException( "contentXml" );
  170. }
  171. DoLoad( content, contentXml );
  172. } // Load
  173. // ----------------------------------------------------------------------
  174. protected abstract void DoLoad( T content, XmlElement contentXml );
  175. // ----------------------------------------------------------------------
  176. public void Save( T content, XmlElement element )
  177. {
  178. if ( content == null )
  179. {
  180. throw new ArgumentNullException( "content" );
  181. }
  182. if ( element == null )
  183. {
  184. throw new ArgumentNullException( "element" );
  185. }
  186. DoSave( content, element );
  187. } // Save
  188. // ----------------------------------------------------------------------
  189. protected abstract void DoSave( T content, XmlElement element );
  190. // ----------------------------------------------------------------------
  191. protected static XmlElement AppendTag( XmlDocument doc, string childTagName )
  192. {
  193. if ( doc == null )
  194. {
  195. throw new ArgumentNullException( "doc" );
  196. }
  197. XmlElement childElement = doc.CreateElement( NoPrefix, childTagName, WufNamespace );
  198. doc.AppendChild( childElement );
  199. return childElement;
  200. } // AppendTag
  201. // ----------------------------------------------------------------------
  202. protected static XmlElement AppendTag( XmlElement parent, string childTagName )
  203. {
  204. if ( parent == null )
  205. {
  206. throw new ArgumentNullException( "parent" );
  207. }
  208. XmlElement childElement = parent.OwnerDocument.CreateElement(
  209. NoPrefix, childTagName, WufNamespace );
  210. parent.AppendChild( childElement );
  211. return childElement;
  212. } // AppendTag
  213. // ----------------------------------------------------------------------
  214. protected static XmlElement AppendTextContentTag( XmlElement parent, string childTagName,
  215. string textContent )
  216. {
  217. XmlElement childElement = AppendTag( parent, childTagName );
  218. childElement.InnerText = textContent;
  219. return childElement;
  220. } // AppendTag
  221. // ----------------------------------------------------------------------
  222. protected static string GetAttribute( XmlElement node, string attrName )
  223. {
  224. if ( node == null )
  225. {
  226. throw new ArgumentNullException( "node" );
  227. }
  228. string attrValue = null;
  229. if ( node.HasAttribute( attrName ) )
  230. {
  231. attrValue = node.GetAttribute( attrName );
  232. }
  233. return attrValue;
  234. } // GetAttribute
  235. // ----------------------------------------------------------------------
  236. protected static void SetAttribute( XmlElement node, string attrName, string attrValue )
  237. {
  238. if ( node == null )
  239. {
  240. throw new ArgumentNullException( "node" );
  241. }
  242. if ( attrValue != null )
  243. {
  244. node.SetAttribute( attrName, attrValue );
  245. }
  246. else if ( node.HasAttribute( attrName ) )
  247. {
  248. node.RemoveAttribute( attrName );
  249. }
  250. } // SetAttribute
  251. // ----------------------------------------------------------------------
  252. protected static DateTime? GetDateAttribute( XmlElement node, string attrName )
  253. {
  254. return GetDateTimeAttribute( node, attrName, XmlDateFormat );
  255. } // GetDateAttribute
  256. // ----------------------------------------------------------------------
  257. protected static void SetDateAttribute( XmlElement node, string attrName, DateTime? attrValue )
  258. {
  259. SetDateTimeAttribute( node, attrName, XmlDateFormat, attrValue );
  260. } // SetDateAttribute
  261. // ----------------------------------------------------------------------
  262. protected static DateTime? GetTimeAttribute( XmlElement node, string attrName )
  263. {
  264. return GetDateTimeAttribute( node, attrName, XmlTimeFormat );
  265. } // GetTimeAttribute
  266. // ----------------------------------------------------------------------
  267. protected static void SetTimeAttribute( XmlElement node, string attrName, DateTime? attrValue )
  268. {
  269. SetDateTimeAttribute( node, attrName, XmlTimeFormat, attrValue );
  270. } // SetTimeAttribute
  271. // ----------------------------------------------------------------------
  272. protected static DateTime? GetDateTimeAttribute( XmlElement node, string attrName )
  273. {
  274. return GetDateTimeAttribute( node, attrName, XmlDateTimeFormat );
  275. } // GetDateTimeAttribute
  276. // ----------------------------------------------------------------------
  277. protected static void SetDateTimeAttribute( XmlElement node, string attrName, DateTime? attrValue )
  278. {
  279. SetDateTimeAttribute( node, attrName, XmlDateTimeFormat, attrValue );
  280. } // SetDateTimeAttribute
  281. // ----------------------------------------------------------------------
  282. private static DateTime? GetDateTimeAttribute( XmlElement node, string attrName, string format )
  283. {
  284. DateTime? attrValue = null;
  285. if ( node.HasAttribute( attrName ) )
  286. {
  287. attrValue = DateTime.ParseExact( node.GetAttribute( attrName ),
  288. format, DateTimeFormatInfo.InvariantInfo );
  289. }
  290. return attrValue;
  291. } // GetDateTimeAttribute
  292. // ----------------------------------------------------------------------
  293. private static void SetDateTimeAttribute( XmlElement node, string attrName, string format, DateTime? attrValue )
  294. {
  295. string attribute = null;
  296. if ( attrValue != null )
  297. {
  298. attribute = attrValue.Value.ToString( format, DateTimeFormatInfo.InvariantInfo );
  299. }
  300. SetAttribute( node, attrName, attribute );
  301. } // SetDateTimeAttribute
  302. // ----------------------------------------------------------------------
  303. protected static double GetDoubleAttribute( XmlElement node, string attrName )
  304. {
  305. return Double.Parse( GetAttribute( node, attrName ), NumberFormatInfo.InvariantInfo );
  306. } // GetDoubleAttribute
  307. // ----------------------------------------------------------------------
  308. protected static void SetDoubleAttribute( XmlElement node, string attrName, double attrValue )
  309. {
  310. SetAttribute( node, attrName, attrValue.ToString( NumberFormatInfo.InvariantInfo ) );
  311. } // SetDoubleAttribute
  312. // ----------------------------------------------------------------------
  313. protected static string GetTextContentFromTag( XmlElement parent, string childTagName )
  314. {
  315. string textContent = null;
  316. XmlElement childElement = GetFirstChildElement( parent, childTagName );
  317. if ( childElement != null )
  318. {
  319. textContent = childElement.InnerText;
  320. }
  321. return textContent;
  322. } // GetTextContentFromTag
  323. // ----------------------------------------------------------------------
  324. protected static XmlElement GetFirstChildElement( XmlNode node )
  325. {
  326. return GetFirstChildElement( node, null );
  327. } // GetFirstChildElement
  328. // ----------------------------------------------------------------------
  329. protected static XmlElement GetFirstChildElement( XmlNode node, string elementLocalName )
  330. {
  331. XmlElement firstChild = null;
  332. if ( node != null )
  333. {
  334. XmlNode firstChildNode = node.FirstChild;
  335. if ( firstChildNode != null )
  336. {
  337. firstChild = firstChildNode as XmlElement;
  338. if ( firstChild == null ||
  339. ( elementLocalName != null && !elementLocalName.Equals( firstChild.LocalName ) ) )
  340. {
  341. firstChild = GetNextSiblingElement( firstChildNode, elementLocalName );
  342. }
  343. }
  344. }
  345. return firstChild;
  346. } // GetFirstChildElement
  347. // ----------------------------------------------------------------------
  348. protected static XmlElement GetNextSiblingElement( XmlNode node )
  349. {
  350. return GetNextSiblingElement( node, null );
  351. } // GetNextSiblingElement
  352. // ----------------------------------------------------------------------
  353. protected static XmlElement GetNextSiblingElement( XmlNode node, string elementLocalName )
  354. {
  355. XmlElement nextSibling = null;
  356. if ( node != null )
  357. {
  358. XmlNode nextNode = node.NextSibling;
  359. while ( nextNode != null && nextSibling == null )
  360. {
  361. nextSibling = nextNode as XmlElement;
  362. if ( nextSibling == null ||
  363. ( elementLocalName != null && !elementLocalName.Equals( nextSibling.LocalName ) ) )
  364. {
  365. nextSibling = null;
  366. nextNode = nextNode.NextSibling;
  367. }
  368. }
  369. }
  370. return nextSibling;
  371. } // GetNextSiblingElement
  372. // ----------------------------------------------------------------------
  373. public static XmlDocument Read( XmlReader reader )
  374. {
  375. if ( reader == null )
  376. {
  377. throw new ArgumentNullException( "reader" );
  378. }
  379. XmlDocument doc = new XmlDocument();
  380. using ( reader )
  381. {
  382. doc.Load( reader );
  383. }
  384. return doc;
  385. } // Read
  386. // ----------------------------------------------------------------------
  387. public static void Write( XmlDocument doc, Stream output )
  388. {
  389. Write( doc, output, true );
  390. } // Write
  391. // ----------------------------------------------------------------------
  392. public static void Write( XmlDocument doc, Stream output, bool disposeOutput )
  393. {
  394. if ( output == null )
  395. {
  396. throw new ArgumentNullException( "output" );
  397. }
  398. try
  399. {
  400. using ( StreamWriter writer = new StreamWriter( output ) )
  401. {
  402. Write( doc, writer, disposeOutput );
  403. if ( !disposeOutput )
  404. {
  405. writer.Flush();
  406. }
  407. }
  408. }
  409. finally
  410. {
  411. if ( disposeOutput )
  412. {
  413. ( (IDisposable)output ).Dispose();
  414. }
  415. else
  416. {
  417. output.Flush();
  418. }
  419. }
  420. } // Write
  421. // ----------------------------------------------------------------------
  422. public static void Write( XmlDocument doc, TextWriter output )
  423. {
  424. Write( doc, output, true );
  425. } // Write
  426. // ----------------------------------------------------------------------
  427. public static void Write( XmlDocument doc, TextWriter output, bool disposeOutput )
  428. {
  429. if ( output == null )
  430. {
  431. throw new ArgumentNullException( "output" );
  432. }
  433. Write( doc, XmlWriter.Create( output, CreateSerializationSettings() ), disposeOutput );
  434. } // Write
  435. // ----------------------------------------------------------------------
  436. public static void Write( XmlDocument doc, XmlWriter output )
  437. {
  438. Write( doc, output, true );
  439. } // Write
  440. // ----------------------------------------------------------------------
  441. public static void Write( XmlDocument doc, XmlWriter writer, bool disposeOutput )
  442. {
  443. if ( doc == null )
  444. {
  445. throw new ArgumentNullException( "doc" );
  446. }
  447. if ( writer == null )
  448. {
  449. throw new ArgumentNullException( "writer" );
  450. }
  451. try
  452. {
  453. XmlWriterSettings settings = writer.Settings;
  454. if ( settings != null && !settings.OmitXmlDeclaration )
  455. {
  456. string encoding = settings.Encoding != null ? settings.Encoding.WebName : "utf-8";
  457. XmlDeclaration declaration = doc.FirstChild as XmlDeclaration;
  458. if ( declaration == null )
  459. {
  460. declaration = doc.CreateXmlDeclaration( "1.0", encoding, null );
  461. declaration.WriteTo( writer );
  462. }
  463. else if ( declaration.Encoding == null )
  464. {
  465. declaration.Encoding = encoding;
  466. }
  467. }
  468. doc.WriteTo( writer );
  469. }
  470. finally
  471. {
  472. writer.Flush();
  473. if ( disposeOutput )
  474. {
  475. ( (IDisposable)writer ).Dispose();
  476. }
  477. }
  478. } // Write
  479. // ----------------------------------------------------------------------
  480. public static XmlWriterSettings CreateSerializationSettings()
  481. {
  482. return CreateSerializationSettings( true );
  483. } // CreateSerializationSettings
  484. // ----------------------------------------------------------------------
  485. public static XmlWriterSettings CreateSerializationSettings( bool closeOutput )
  486. {
  487. XmlWriterSettings settings = new XmlWriterSettings();
  488. settings.OmitXmlDeclaration = false;
  489. settings.CloseOutput = closeOutput;
  490. settings.NewLineHandling = NewLineHandling.None;
  491. settings.IndentChars = "  ";
  492. settings.Indent = true;
  493. settings.ConformanceLevel = ConformanceLevel.Fragment;
  494. settings.Encoding = new UTF8Encoding( false );
  495. return settings;
  496. } // CreateSerializationSettings
  497. // ----------------------------------------------------------------------
  498. // members
  499. private readonly XmlReaderSettings xmlReadSettings;
  500. private readonly string docTag;
  501. } // class XmlBase
  502. } // namespace Itenso.WebUserForms.Data
  503. // -- EOF -------------------------------------------------------------------