/Solutions/Main3.5/Framework/Xml/XmlFile.cs

# · C# · 796 lines · 558 code · 67 blank · 171 comment · 99 complexity · 3e9da9915e02381ce051f2017682ef47 MD5 · raw file 

    

  1. //-----------------------------------------------------------------------

    2. 

  2. // <copyright file="XmlFile.cs">(c) http://www.codeplex.com/MSBuildExtensionPack. This source is subject to the Microsoft Permissive License. See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx. All other rights reserved.</copyright>

    3. 

  3. // Portions of this task are based on the http://www.codeplex.com/sdctasks. This source is subject to the Microsoft Permissive License. See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx. All other rights reserved.

    4. 

  4. //-----------------------------------------------------------------------

    5. 

  5. namespace MSBuild.ExtensionPack.Xml

    6. 

  6. {

    7. 

  7.     using System;

    8. 

  8.     using System.Globalization;

    9. 

  9.     using System.Xml;

    10. 

  10.     using Microsoft.Build.Framework;

    11. 

  11.     using Microsoft.Build.Utilities;

    12. 

  12. 

    13. 

  13.     /// <summary>

    14. 

  14.     /// <b>Valid TaskActions are:</b>

    15. 

  15.     /// <para><i>AddAttribute</i> (<b>Required: </b>File, Element or XPath, Key, Value <b>Optional:</b> Namespaces, RetryCount)</para>

    16. 

  16.     /// <para><i>AddElement</i> (<b>Required: </b>File, Element and ParentElement or Element and XPath, <b>Optional:</b> Prefix, Key, Value, Namespaces, RetryCount, InnerText, InnerXml, InsertBeforeXPath / InsertAfterXPath)</para>

    17. 

  17.     /// <para><i>ReadAttribute</i> (<b>Required: </b>File, XPath <b>Optional:</b> Namespaces <b>Output:</b> Value)</para>

    18. 

  18.     /// <para><i>ReadElements</i> (<b>Required: </b>File, XPath <b>Optional:</b> Namespaces <b>Output: </b> Elements). Attributes are added as metadata</para>

    19. 

  19.     /// <para><i>ReadElementText</i> (<b>Required: </b>File, XPath <b>Optional:</b> Namespaces <b>Output:</b> Value)</para>

    20. 

  20.     /// <para><i>ReadElementXml</i> (<b>Required: </b>File, XPath <b>Optional:</b> Namespaces <b>Output:</b> Value)</para>

    21. 

  21.     /// <para><i>RemoveAttribute</i> (<b>Required: </b>File, Key, Element or XPath <b>Optional:</b> Namespaces, RetryCount)</para>

    22. 

  22.     /// <para><i>RemoveElement</i> (<b>Required: </b>File, Element and ParentElement or Element and XPath <b>Optional:</b> Namespaces, RetryCount)</para>

    23. 

  23.     /// <para><i>UpdateAttribute</i> (<b>Required: </b>File, XPath <b>Optional:</b> Namespaces, Key, Value, RetryCount)</para>

    24. 

  24.     /// <para><i>UpdateElement</i> (<b>Required: </b>File, XPath <b>Optional:</b> Namespaces, InnerText, InnerXml, RetryCount)</para>

    25. 

  25.     /// <para><b>Remote Execution Support:</b> NA</para>

    26. 

  26.     /// </summary>

    27. 

  27.     /// <example>

    28. 

  28.     /// <code lang="xml"><![CDATA[

    29. 

  29.     /// <Project ToolsVersion="3.5" DefaultTargets="Default" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

    30. 

  30.     ///     <PropertyGroup>

    31. 

  31.     ///         <TPath>$(MSBuildProjectDirectory)\..\MSBuild.ExtensionPack.tasks</TPath>

    32. 

  32.     ///         <TPath Condition="Exists('$(MSBuildProjectDirectory)\..\..\Common\MSBuild.ExtensionPack.tasks')">$(MSBuildProjectDirectory)\..\..\Common\MSBuild.ExtensionPack.tasks</TPath>

    33. 

  33.     ///     </PropertyGroup>

    34. 

  34.     ///     <Import Project="$(TPath)"/>

    35. 

  35.     ///     <ItemGroup>

    36. 

  36.     ///         <ConfigSettingsToDeploy Include="c:\machine.config">

    37. 

  37.     ///             <Action>RemoveElement</Action>

    38. 

  38.     ///             <Element>processModel</Element>

    39. 

  39.     ///             <ParentElement>/configuration/system.web</ParentElement>

    40. 

  40.     ///         </ConfigSettingsToDeploy>

    41. 

  41.     ///         <ConfigSettingsToDeploy Include="c:\machine.config">

    42. 

  42.     ///             <Action>AddElement</Action>

    43. 

  43.     ///             <Element>processModel</Element>

    44. 

  44.     ///             <ParentElement>/configuration/system.web</ParentElement>

    45. 

  45.     ///         </ConfigSettingsToDeploy>

    46. 

  46.     ///         <ConfigSettingsToDeploy Include="c:\machine.config">

    47. 

  47.     ///             <Action>AddAttribute</Action>

    48. 

  48.     ///             <Key>enable</Key>

    49. 

  49.     ///             <ValueToAdd>true</ValueToAdd>

    50. 

  50.     ///             <Element>/configuration/system.web/processModel</Element>

    51. 

  51.     ///         </ConfigSettingsToDeploy>

    52. 

  52.     ///         <ConfigSettingsToDeploy Include="c:\machine.config">

    53. 

  53.     ///             <Action>AddAttribute</Action>

    54. 

  54.     ///             <Key>timeout</Key>

    55. 

  55.     ///             <ValueToAdd>Infinite</ValueToAdd>

    56. 

  56.     ///             <Element>/configuration/system.web/processModel</Element>

    57. 

  57.     ///         </ConfigSettingsToDeploy>

    58. 

  58.     ///         <ConfigSettingsToDeploy Include="c:\machine.config">

    59. 

  59.     ///             <Action>RemoveAttribute</Action>

    60. 

  60.     ///             <Key>timeout</Key>

    61. 

  61.     ///             <Element>/configuration/system.web/processModel</Element>

    62. 

  62.     ///         </ConfigSettingsToDeploy>

    63. 

  63.     ///         <XMLConfigElementsToAdd Include="c:\machine.config">

    64. 

  64.     ///             <XPath>/configuration/configSections</XPath>

    65. 

  65.     ///             <Name>section</Name>

    66. 

  66.     ///             <KeyAttributeName>name</KeyAttributeName>

    67. 

  67.     ///             <KeyAttributeValue>enterpriseLibrary.ConfigurationSource</KeyAttributeValue>

    68. 

  68.     ///         </XMLConfigElementsToAdd>

    69. 

  69.     ///         <XMLConfigElementsToAdd Include="c:\machine.config">

    70. 

  70.     ///             <XPath>/configuration</XPath>

    71. 

  71.     ///             <Name>enterpriseLibrary.ConfigurationSource</Name>

    72. 

  72.     ///             <KeyAttributeName>selectedSource</KeyAttributeName>

    73. 

  73.     ///             <KeyAttributeValue>MyKeyAttribute</KeyAttributeValue>

    74. 

  74.     ///         </XMLConfigElementsToAdd>

    75. 

  75.     ///         <XMLConfigElementsToAdd Include="c:\machine.config">

    76. 

  76.     ///             <XPath>/configuration/enterpriseLibrary.ConfigurationSource</XPath>

    77. 

  77.     ///             <Name>sources</Name>

    78. 

  78.     ///         </XMLConfigElementsToAdd>

    79. 

  79.     ///         <XMLConfigElementsToAdd Include="c:\machine.config">

    80. 

  80.     ///             <XPath>/configuration/enterpriseLibrary.ConfigurationSource/sources</XPath>

    81. 

  81.     ///             <Name>add</Name>

    82. 

  82.     ///             <KeyAttributeName>name</KeyAttributeName>

    83. 

  83.     ///             <KeyAttributeValue>MyKeyAttribute</KeyAttributeValue>

    84. 

  84.     ///         </XMLConfigElementsToAdd>

    85. 

  85.     ///         <XMLConfigAttributesToAdd Include="c:\machine.config">

    86. 

  86.     ///             <XPath>/configuration/configSections/section[@name='enterpriseLibrary.ConfigurationSource']</XPath>

    87. 

  87.     ///             <Name>type</Name>

    88. 

  88.     ///             <Value>Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ConfigurationSourceSection, Microsoft.Practices.EnterpriseLibrary.Common, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35</Value>

    89. 

  89.     ///         </XMLConfigAttributesToAdd>

    90. 

  90.     ///         <XMLConfigAttributesToAdd Include="c:\machine.config">

    91. 

  91.     ///             <XPath>/configuration/enterpriseLibrary.ConfigurationSource/sources/add[@name='MyKeyAttribute']</XPath>

    92. 

  92.     ///             <Name>type</Name>

    93. 

  93.     ///             <Value>MyKeyAttribute.Common, MyKeyAttribute.Common, Version=1.0.0.0, Culture=neutral, PublicKeyToken=fb2f49125f05d89</Value>

    94. 

  94.     ///         </XMLConfigAttributesToAdd>

    95. 

  95.     ///         <XMLConfigElementsToDelete Include="c:\machine.config">

    96. 

  96.     ///             <XPath>/configuration/configSections/section[@name='enterpriseLibrary.ConfigurationSource']</XPath>

    97. 

  97.     ///         </XMLConfigElementsToDelete>

    98. 

  98.     ///         <XMLConfigElementsToDelete Include="c:\machine.config">

    99. 

  99.     ///             <XPath>/configuration/enterpriseLibrary.ConfigurationSource[@selectedSource='MyKeyAttribute']</XPath>

    100. 

  100.     ///         </XMLConfigElementsToDelete>

    101. 

  101.     ///     </ItemGroup>

    102. 

  102.     ///     <Target Name="Default">

    103. 

  103.     ///         <!-- Work through some manipulations that don't use XPath-->

    104. 

  104.     ///         <MSBuild.ExtensionPack.Xml.XmlFile TaskAction="%(ConfigSettingsToDeploy.Action)" File="%(ConfigSettingsToDeploy.Identity)" Key="%(ConfigSettingsToDeploy.Key)" Value="%(ConfigSettingsToDeploy.ValueToAdd)" Element="%(ConfigSettingsToDeploy.Element)" ParentElement="%(ConfigSettingsToDeploy.ParentElement)" Condition="'%(ConfigSettingsToDeploy.Identity)'!=''"/>

    105. 

  105.     ///         <!-- Work through some manipulations that use XPath-->

    106. 

  106.     ///         <MSBuild.ExtensionPack.Xml.XmlFile TaskAction="RemoveElement" File="%(XMLConfigElementsToDelete.Identity)" XPath="%(XMLConfigElementsToDelete.XPath)" Condition="'%(XMLConfigElementsToDelete.Identity)'!=''"/>

    107. 

  107.     ///         <MSBuild.ExtensionPack.Xml.XmlFile TaskAction="AddElement" File="%(XMLConfigElementsToAdd.Identity)" Key="%(XMLConfigElementsToAdd.KeyAttributeName)" Value="%(XMLConfigElementsToAdd.KeyAttributeValue)" Element="%(XMLConfigElementsToAdd.Name)" XPath="%(XMLConfigElementsToAdd.XPath)" Condition="'%(XMLConfigElementsToAdd.Identity)'!=''"/>

    108. 

  108.     ///         <MSBuild.ExtensionPack.Xml.XmlFile TaskAction="AddAttribute" File="%(XMLConfigAttributesToAdd.Identity)" Key="%(XMLConfigAttributesToAdd.Name)" Value="%(XMLConfigAttributesToAdd.Value)" XPath="%(XMLConfigAttributesToAdd.XPath)" Condition="'%(XMLConfigAttributesToAdd.Identity)'!=''"/>

    109. 

  109.     ///         <MSBuild.ExtensionPack.Xml.XmlFile TaskAction="UpdateElement" File="c:\machine.config" XPath="/configuration/configSections/section[@name='system.data']" InnerText="NewValue"/>

    110. 

  110.     ///         <MSBuild.ExtensionPack.Xml.XmlFile TaskAction="UpdateAttribute" File="c:\machine.config" XPath="/configuration/configSections/section[@name='system.data']" Key="SomeAttribute" Value="NewValue"/>

    111. 

  111.     ///     </Target>

    112. 

  112.     ///     <!-- The following illustrates Namespace usage -->

    113. 

  113.     ///     <ItemGroup>

    114. 

  114.     ///         <Namespaces Include="Mynamespace">

    115. 

  115.     ///             <Prefix>me</Prefix>

    116. 

  116.     ///             <Uri>http://mynamespace</Uri>

    117. 

  117.     ///         </Namespaces>

    118. 

  118.     ///         <XMLConfigElementsToDelete1 Include="c:\test.xml">

    119. 

  119.     ///             <XPath>//me:MyNodes/sources</XPath>

    120. 

  120.     ///         </XMLConfigElementsToDelete1>

    121. 

  121.     ///         <XMLConfigElementsToAdd1 Include="c:\test.xml">

    122. 

  122.     ///             <XPath>//me:MyNodes</XPath>

    123. 

  123.     ///             <Name>sources</Name>

    124. 

  124.     ///         </XMLConfigElementsToAdd1>

    125. 

  125.     ///     </ItemGroup>

    126. 

  126.     ///     <Target Name="DefaultWithNameSpace">

    127. 

  127.     ///         <MSBuild.ExtensionPack.Xml.XmlFile TaskAction="RemoveElement" Namespaces="@(Namespaces)" File="%(XMLConfigElementsToDelete1.Identity)" XPath="%(XMLConfigElementsToDelete1.XPath)" Condition="'%(XMLConfigElementsToDelete1.Identity)'!=''"/>

    128. 

  128.     ///         <MSBuild.ExtensionPack.Xml.XmlFile TaskAction="AddElement" Namespaces="@(Namespaces)" File="%(XMLConfigElementsToAdd1.Identity)" Key="%(XMLConfigElementsToAdd1.KeyAttributeName)" Value="%(XMLConfigElementsToAdd1.KeyAttributeValue)" Element="%(XMLConfigElementsToAdd1.Name)" XPath="%(XMLConfigElementsToAdd1.XPath)" Condition="'%(XMLConfigElementsToAdd1.Identity)'!=''"/>

    129. 

  129.     ///     </Target>

    130. 

  130.     /// </Project>

    131. 

  131.     /// ]]></code>    

    132. 

  132.     /// </example>

    133. 

  133.     [HelpUrl("http://www.msbuildextensionpack.com/help/3.5.10.0/html/4009fe8c-73c1-154f-ee8c-e9fda7f5fd96.htm")]

    134. 

  134.     public class XmlFile : BaseTask

    135. 

  135.     {

    136. 

  136.         private const string AddAttributeTaskAction = "AddAttribute";

    137. 

  137.         private const string AddElementTaskAction = "AddElement";

    138. 

  138.         private const string ReadAttributeTaskAction = "ReadAttribute";

    139. 

  139.         private const string ReadElementsTaskAction = "ReadElements";

    140. 

  140.         private const string ReadElementTextTaskAction = "ReadElementText";

    141. 

  141.         private const string ReadElementXmlTaskAction = "ReadElementXml";

    142. 

  142.         private const string RemoveAttributeTaskAction = "RemoveAttribute";

    143. 

  143.         private const string RemoveElementTaskAction = "RemoveElement";

    144. 

  144.         private const string UpdateAttributeTaskAction = "UpdateAttribute";

    145. 

  145.         private const string UpdateElementTaskAction = "UpdateElement";

    146. 

  146.         private XmlDocument xmlFileDoc;

    147. 

  147.         private XmlNamespaceManager namespaceManager;

    148. 

  148.         private XmlNodeList elements;

    149. 

  149.         private int retryCount = 5;

    150. 

  150. 

    151. 

  151.         [DropdownValue(AddAttributeTaskAction)]

    152. 

  152.         [DropdownValue(AddElementTaskAction)]

    153. 

  153.         [DropdownValue(ReadAttributeTaskAction)]

    154. 

  154.         [DropdownValue(ReadElementTextTaskAction)]

    155. 

  155.         [DropdownValue(ReadElementXmlTaskAction)]

    156. 

  156.         [DropdownValue(RemoveAttributeTaskAction)]

    157. 

  157.         [DropdownValue(RemoveElementTaskAction)]

    158. 

  158.         [DropdownValue(UpdateAttributeTaskAction)]

    159. 

  159.         [DropdownValue(UpdateElementTaskAction)]

    160. 

  160.         [DropdownValue(ReadElementsTaskAction)]

    161. 

  161.         public override string TaskAction

    162. 

  162.         {

    163. 

  163.             get { return base.TaskAction; }

    164. 

  164.             set { base.TaskAction = value; }

    165. 

  165.         }

    166. 

  166. 

    167. 

  167.         /// <summary>

    168. 

  168.         /// Sets the element. For AddElement, if the element exists, it's InnerText / InnerXml will be updated

    169. 

  169.         /// </summary>

    170. 

  170.         [TaskAction(AddAttributeTaskAction, true)]

    171. 

  171.         [TaskAction(AddElementTaskAction, true)]

    172. 

  172.         [TaskAction(RemoveAttributeTaskAction, true)]

    173. 

  173.         [TaskAction(RemoveElementTaskAction, true)]

    174. 

  174.         public string Element { get; set; }

    175. 

  175. 

    176. 

  176.         /// <summary>

    177. 

  177.         /// Sets the InnerText.

    178. 

  178.         /// </summary>

    179. 

  179.         [TaskAction(AddElementTaskAction, false)]

    180. 

  180.         [TaskAction(UpdateElementTaskAction, false)]

    181. 

  181.         public string InnerText { get; set; }

    182. 

  182. 

    183. 

  183.         /// <summary>

    184. 

  184.         /// Sets the InnerXml.

    185. 

  185.         /// </summary>

    186. 

  186.         [TaskAction(AddElementTaskAction, false)]

    187. 

  187.         [TaskAction(UpdateElementTaskAction, false)]

    188. 

  188.         public string InnerXml { get; set; }

    189. 

  189. 

    190. 

  190.         /// <summary>

    191. 

  191.         /// Sets the Prefix used for an added element, prefix must exists in Namespaces.

    192. 

  192.         /// </summary>

    193. 

  193.         [TaskAction(AddElementTaskAction, false)]

    194. 

  194.         public string Prefix { get; set; }

    195. 

  195. 

    196. 

  196.         /// <summary>

    197. 

  197.         /// Sets the parent element.

    198. 

  198.         /// </summary>

    199. 

  199.         [TaskAction(AddElementTaskAction, true)]

    200. 

  200.         [TaskAction(RemoveElementTaskAction, true)]

    201. 

  201.         public string ParentElement { get; set; }

    202. 

  202. 

    203. 

  203.         /// <summary>

    204. 

  204.         /// Sets the Attribute key.

    205. 

  205.         /// </summary>

    206. 

  206.         [TaskAction(AddAttributeTaskAction, false)]

    207. 

  207.         [TaskAction(RemoveAttributeTaskAction, true)]

    208. 

  208.         [TaskAction(UpdateAttributeTaskAction, false)]

    209. 

  209.         public string Key { get; set; }

    210. 

  210. 

    211. 

  211.         /// <summary>

    212. 

  212.         /// Gets or Sets the Attribute key value. Also stores the result of any Read TaskActions

    213. 

  213.         /// </summary>

    214. 

  214.         [TaskAction(AddAttributeTaskAction, true)]

    215. 

  215.         [TaskAction(UpdateAttributeTaskAction, false)]

    216. 

  216.         [Output]

    217. 

  217.         public string Value { get; set; }

    218. 

  218. 

    219. 

  219.         /// <summary>

    220. 

  220.         /// Gets the elements selected using ReadElements

    221. 

  221.         /// </summary>

    222. 

  222.         [TaskAction(ReadElementsTaskAction, true)]

    223. 

  223.         [Output]

    224. 

  224.         public ITaskItem[] Elements { get; set; }

    225. 

  225. 

    226. 

  226.         /// <summary>

    227. 

  227.         /// Sets the file.

    228. 

  228.         /// </summary>

    229. 

  229.         [Required]

    230. 

  230.         [TaskAction(AddAttributeTaskAction, true)]

    231. 

  231.         [TaskAction(AddElementTaskAction, true)]

    232. 

  232.         [TaskAction(ReadAttributeTaskAction, true)]

    233. 

  233.         [TaskAction(ReadElementTextTaskAction, true)]

    234. 

  234.         [TaskAction(ReadElementXmlTaskAction, true)]

    235. 

  235.         [TaskAction(RemoveAttributeTaskAction, true)]

    236. 

  236.         [TaskAction(RemoveElementTaskAction, true)]

    237. 

  237.         [TaskAction(ReadElementsTaskAction, true)]

    238. 

  238.         public ITaskItem File { get; set; }

    239. 

  239. 

    240. 

  240.         /// <summary>

    241. 

  241.         /// Specifies the XPath to be used

    242. 

  242.         /// </summary>

    243. 

  243.         [TaskAction(AddAttributeTaskAction, false)]

    244. 

  244.         [TaskAction(AddElementTaskAction, false)]

    245. 

  245.         [TaskAction(ReadAttributeTaskAction, true)]

    246. 

  246.         [TaskAction(ReadElementTextTaskAction, true)]

    247. 

  247.         [TaskAction(ReadElementXmlTaskAction, true)]

    248. 

  248.         [TaskAction(RemoveAttributeTaskAction, false)]

    249. 

  249.         [TaskAction(RemoveElementTaskAction, false)]

    250. 

  250.         [TaskAction(UpdateElementTaskAction, false)]

    251. 

  251.         [TaskAction(ReadElementsTaskAction, true)]

    252. 

  252.         public string XPath { get; set; }

    253. 

  253. 

    254. 

  254.         /// <summary>

    255. 

  255.         /// Specifies the XPath to be used to control where a new element is added. The Xpath must resolve to single node.

    256. 

  256.         /// </summary>

    257. 

  257.         [TaskAction(AddElementTaskAction, false)]

    258. 

  258.         public string InsertBeforeXPath { get; set; }

    259. 

  259. 

    260. 

  260.         /// <summary>

    261. 

  261.         /// Specifies the XPath to be used to control where a new element is added. The Xpath must resolve to single node.

    262. 

  262.         /// </summary>

    263. 

  263.         [TaskAction(AddElementTaskAction, false)]

    264. 

  264.         public string InsertAfterXPath { get; set; }

    265. 

  265. 

    266. 

  266.         /// <summary>

    267. 

  267.         /// TaskItems specifiying "Prefix" and "Uri" attributes for use with the specified XPath

    268. 

  268.         /// </summary>

    269. 

  269.         [TaskAction(AddAttributeTaskAction, false)]

    270. 

  270.         [TaskAction(AddElementTaskAction, false)]

    271. 

  271.         [TaskAction(ReadAttributeTaskAction, false)]

    272. 

  272.         [TaskAction(ReadElementTextTaskAction, false)]

    273. 

  273.         [TaskAction(ReadElementXmlTaskAction, false)]

    274. 

  274.         [TaskAction(RemoveAttributeTaskAction, false)]

    275. 

  275.         [TaskAction(RemoveElementTaskAction, false)]

    276. 

  276.         [TaskAction(UpdateAttributeTaskAction, false)]

    277. 

  277.         [TaskAction(UpdateElementTaskAction, false)]

    278. 

  278.         [TaskAction(ReadElementsTaskAction, false)]

    279. 

  279.         public ITaskItem[] Namespaces { get; set; }

    280. 

  280. 

    281. 

  281.         /// <summary>

    282. 

  282.         /// Sets a value indicating how many times to retry saving the file, e.g. if files are temporarily locked. Default is 5. The retry occurs every 5 seconds.

    283. 

  283.         /// </summary>

    284. 

  284.         [TaskAction(AddAttributeTaskAction, false)]

    285. 

  285.         [TaskAction(AddElementTaskAction, false)]

    286. 

  286.         [TaskAction(RemoveAttributeTaskAction, false)]

    287. 

  287.         [TaskAction(RemoveElementTaskAction, false)]

    288. 

  288.         [TaskAction(UpdateAttributeTaskAction, false)]

    289. 

  289.         [TaskAction(UpdateElementTaskAction, false)]

    290. 

  290.         public int RetryCount

    291. 

  291.         {

    292. 

  292.             get { return this.retryCount; }

    293. 

  293.             set { this.retryCount = value; }

    294. 

  294.         }

    295. 

  295. 

    296. 

  296.         /// <summary>

    297. 

  297.         /// Performs the action of this task.

    298. 

  298.         /// </summary>

    299. 

  299.         protected override void InternalExecute()

    300. 

  300.         {

    301. 

  301.             if (!System.IO.File.Exists(this.File.ItemSpec))

    302. 

  302.             {

    303. 

  303.                 this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "File not found: {0}", this.File.ItemSpec));

    304. 

  304.                 return;

    305. 

  305.             }

    306. 

  306. 

    307. 

  307.             this.xmlFileDoc = new XmlDocument();

    308. 

  308.             try

    309. 

  309.             {

    310. 

  310.                 this.xmlFileDoc.Load(this.File.ItemSpec);

    311. 

  311.             }

    312. 

  312.             catch (Exception ex)

    313. 

  313.             {

    314. 

  314.                 this.LogTaskWarning(ex.Message);

    315. 

  315.                 bool loaded = false;

    316. 

  316.                 int count = 1;

    317. 

  317.                 while (!loaded && count <= this.RetryCount)

    318. 

  318.                 {

    319. 

  319.                     this.LogTaskMessage(MessageImportance.High, string.Format(CultureInfo.InvariantCulture, "Load failed, trying again in 5 seconds. Attempt {0} of {1}", count, this.RetryCount));

    320. 

  320.                     System.Threading.Thread.Sleep(5000);

    321. 

  321.                     count++;

    322. 

  322.                     try

    323. 

  323.                     {

    324. 

  324.                         this.xmlFileDoc.Load(this.File.ItemSpec);

    325. 

  325.                         loaded = true;

    326. 

  326.                     }

    327. 

  327.                     catch

    328. 

  328.                     {

    329. 

  329.                         this.LogTaskWarning(ex.Message);

    330. 

  330.                     }

    331. 

  331.                 }

    332. 

  332. 

    333. 

  333.                 if (loaded != true)

    334. 

  334.                 {

    335. 

  335.                     throw;

    336. 

  336.                 }

    337. 

  337.             }

    338. 

  338. 

    339. 

  339.             if (!string.IsNullOrEmpty(this.XPath))

    340. 

  340.             {

    341. 

  341.                 this.namespaceManager = this.GetNamespaceManagerForDoc();

    342. 

  342.                 this.elements = this.xmlFileDoc.SelectNodes(this.XPath, this.namespaceManager);

    343. 

  343.             }

    344. 

  344. 

    345. 

  345.             this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "XmlFile: {0}", this.File.ItemSpec));

    346. 

  346.             switch (this.TaskAction)

    347. 

  347.             {

    348. 

  348.                 case AddElementTaskAction:

    349. 

  349.                     this.AddElement();

    350. 

  350.                     break;

    351. 

  351.                 case AddAttributeTaskAction:

    352. 

  352.                     this.AddAttribute();

    353. 

  353.                     break;

    354. 

  354.                 case ReadAttributeTaskAction:

    355. 

  355.                     this.ReadAttribute();

    356. 

  356.                     break;

    357. 

  357.                 case ReadElementsTaskAction:

    358. 

  358.                     this.ReadElements();

    359. 

  359.                     break;

    360. 

  360.                 case ReadElementTextTaskAction:

    361. 

  361.                 case ReadElementXmlTaskAction:

    362. 

  362.                     this.ReadElement();

    363. 

  363.                     break;

    364. 

  364.                 case RemoveAttributeTaskAction:

    365. 

  365.                     this.RemoveAttribute();

    366. 

  366.                     break;

    367. 

  367.                 case RemoveElementTaskAction:

    368. 

  368.                     this.RemoveElement();

    369. 

  369.                     break;

    370. 

  370.                 case UpdateElementTaskAction:

    371. 

  371.                     this.UpdateElement();

    372. 

  372.                     break;

    373. 

  373.                 case UpdateAttributeTaskAction:

    374. 

  374.                     this.UpdateAttribute();

    375. 

  375.                     break;

    376. 

  376.                 default:

    377. 

  377.                     this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Invalid TaskAction passed: {0}", this.TaskAction));

    378. 

  378.                     return;

    379. 

  379.             }

    380. 

  380.         }

    381. 

  381. 

    382. 

  382.         private void ReadElements()

    383. 

  383.         {

    384. 

  384.             if (string.IsNullOrEmpty(this.XPath))

    385. 

  385.             {

    386. 

  386.                 this.Log.LogError("XPath is Required");

    387. 

  387.                 return;

    388. 

  388.             }

    389. 

  389. 

    390. 

  390.             this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Read Elements: {0}", this.XPath));

    391. 

  391.             XmlNodeList nodelist = this.xmlFileDoc.SelectNodes(this.XPath, this.namespaceManager);

    392. 

  392.             if (nodelist != null)

    393. 

  393.             {

    394. 

  394.                 this.Elements = new ITaskItem[nodelist.Count];

    395. 

  395.                 int i = 0;

    396. 

  396.                 foreach (XmlNode node in nodelist)

    397. 

  397.                 {

    398. 

  398.                     ITaskItem newItem = new TaskItem(node.Name);

    399. 

  399.                     if (node.Attributes != null)

    400. 

  400.                     {

    401. 

  401.                         foreach (XmlAttribute a in node.Attributes)

    402. 

  402.                         {

    403. 

  403.                             newItem.SetMetadata(a.Name, a.Value);

    404. 

  404.                         }

    405. 

  405.                     }

    406. 

  406. 

    407. 

  407.                     this.Elements[i] = newItem;

    408. 

  408.                     i++;

    409. 

  409.                 }

    410. 

  410.             }

    411. 

  411.         }

    412. 

  412. 

    413. 

  413.         private void ReadElement()

    414. 

  414.         {

    415. 

  415.             if (string.IsNullOrEmpty(this.XPath))

    416. 

  416.             {

    417. 

  417.                 this.Log.LogError("XPath is Required");

    418. 

  418.                 return;

    419. 

  419.             }

    420. 

  420. 

    421. 

  421.             this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Read Element: {0}", this.XPath));

    422. 

  422.             XmlNode node = this.xmlFileDoc.SelectSingleNode(this.XPath, this.namespaceManager);

    423. 

  423.             if (node != null && node.NodeType == XmlNodeType.Element)

    424. 

  424.             {

    425. 

  425.                 this.Value = this.TaskAction == ReadElementTextTaskAction ? node.InnerText : node.InnerXml;

    426. 

  426.             }

    427. 

  427.         }

    428. 

  428. 

    429. 

  429.         private void ReadAttribute()

    430. 

  430.         {

    431. 

  431.             if (string.IsNullOrEmpty(this.XPath))

    432. 

  432.             {

    433. 

  433.                 this.Log.LogError("XPath is Required");

    434. 

  434.                 return;

    435. 

  435.             }

    436. 

  436. 

    437. 

  437.             this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Read Attribute: {0}", this.XPath));

    438. 

  438.             XmlNode node = this.xmlFileDoc.SelectSingleNode(this.XPath, this.namespaceManager);

    439. 

  439.             if (node != null && node.NodeType == XmlNodeType.Attribute)

    440. 

  440.             {

    441. 

  441.                 this.Value = node.Value;

    442. 

  442.             }

    443. 

  443.         }

    444. 

  444. 

    445. 

  445.         private void UpdateElement()

    446. 

  446.         {

    447. 

  447.             if (string.IsNullOrEmpty(this.XPath))

    448. 

  448.             {

    449. 

  449.                 this.Log.LogError("XPath is Required");

    450. 

  450.                 return;

    451. 

  451.             }

    452. 

  452. 

    453. 

  453.             if (string.IsNullOrEmpty(this.InnerXml))

    454. 

  454.             {

    455. 

  455.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Update Element: {0}. InnerText: {1}", this.XPath, this.InnerText));

    456. 

  456.                 if (this.elements != null && this.elements.Count > 0)

    457. 

  457.                 {

    458. 

  458.                     foreach (XmlNode element in this.elements)

    459. 

  459.                     {

    460. 

  460.                         element.InnerText = this.InnerText;

    461. 

  461.                     }

    462. 

  462. 

    463. 

  463.                     this.TrySave();

    464. 

  464.                 }

    465. 

  465. 

    466. 

  466.                 return;

    467. 

  467.             }

    468. 

  468. 

    469. 

  469.             this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Update Element: {0}. InnerXml: {1}", this.XPath, this.InnerXml));

    470. 

  470.             if (this.elements != null && this.elements.Count > 0)

    471. 

  471.             {

    472. 

  472.                 foreach (XmlNode element in this.elements)

    473. 

  473.                 {

    474. 

  474.                     element.InnerXml = this.InnerXml;

    475. 

  475.                 }

    476. 

  476. 

    477. 

  477.                 this.TrySave();

    478. 

  478.             }

    479. 

  479.         }

    480. 

  480. 

    481. 

  481.         private void UpdateAttribute()

    482. 

  482.         {

    483. 

  483.             if (string.IsNullOrEmpty(this.XPath))

    484. 

  484.             {

    485. 

  485.                 this.Log.LogError("XPath is Required");

    486. 

  486.                 return;

    487. 

  487.             }

    488. 

  488. 

    489. 

  489.             if (string.IsNullOrEmpty(this.Key))

    490. 

  490.             {

    491. 

  491.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Update Attribute: {0}. Value: {1}", this.XPath, this.Value));

    492. 

  492.                 XmlNode node = this.xmlFileDoc.SelectSingleNode(this.XPath, this.namespaceManager);

    493. 

  493.                 if (node != null && node.NodeType == XmlNodeType.Attribute)

    494. 

  494.                 {

    495. 

  495.                     node.Value = this.Value;

    496. 

  496.                 }

    497. 

  497.             }

    498. 

  498.             else

    499. 

  499.             {

    500. 

  500.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Update Attribute: {0} @ {1}. Value: {2}", this.Key, this.XPath, this.Value));

    501. 

  501.                 if (this.elements != null && this.elements.Count > 0)

    502. 

  502.                 {

    503. 

  503.                     foreach (XmlNode element in this.elements)

    504. 

  504.                     {

    505. 

  505.                         XmlAttribute attNode = element.Attributes.GetNamedItem(this.Key) as XmlAttribute;

    506. 

  506.                         if (attNode != null)

    507. 

  507.                         {

    508. 

  508.                             attNode.Value = this.Value;

    509. 

  509.                         }

    510. 

  510.                     }

    511. 

  511.                 }

    512. 

  512.             }

    513. 

  513. 

    514. 

  514.             this.TrySave();

    515. 

  515.         }

    516. 

  516. 

    517. 

  517.         private void RemoveAttribute()

    518. 

  518.         {

    519. 

  519.             if (string.IsNullOrEmpty(this.XPath))

    520. 

  520.             {

    521. 

  521.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Remove Attribute: {0}", this.Key));

    522. 

  522.                 XmlNode elementNode = this.xmlFileDoc.SelectSingleNode(this.Element);

    523. 

  523.                 if (elementNode == null)

    524. 

  524.                 {

    525. 

  525.                     Log.LogError(string.Format(CultureInfo.CurrentUICulture, "Element not found: {0}", this.Element));

    526. 

  526.                     return;

    527. 

  527.                 }

    528. 

  528. 

    529. 

  529.                 XmlAttribute attNode = elementNode.Attributes.GetNamedItem(this.Key) as XmlAttribute;

    530. 

  530.                 if (attNode != null)

    531. 

  531.                 {

    532. 

  532.                     elementNode.Attributes.Remove(attNode);

    533. 

  533.                     this.TrySave();

    534. 

  534.                 }

    535. 

  535.             }

    536. 

  536.             else

    537. 

  537.             {

    538. 

  538.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Remove Attribute: {0}", this.Key));

    539. 

  539.                 if (this.elements != null && this.elements.Count > 0)

    540. 

  540.                 {

    541. 

  541.                     foreach (XmlNode element in this.elements)

    542. 

  542.                     {

    543. 

  543.                         XmlAttribute attNode = element.Attributes.GetNamedItem(this.Key) as XmlAttribute;

    544. 

  544.                         if (attNode != null)

    545. 

  545.                         {

    546. 

  546.                             element.Attributes.Remove(attNode);

    547. 

  547.                             this.TrySave();

    548. 

  548.                         }

    549. 

  549.                     }

    550. 

  550.                 }

    551. 

  551.             }

    552. 

  552.         }

    553. 

  553. 

    554. 

  554.         private void AddAttribute()

    555. 

  555.         {

    556. 

  556.             if (string.IsNullOrEmpty(this.XPath))

    557. 

  557.             {

    558. 

  558.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Set Attribute: {0}={1}", this.Key, this.Value));

    559. 

  559.                 XmlNode elementNode = this.xmlFileDoc.SelectSingleNode(this.Element);

    560. 

  560.                 if (elementNode == null)

    561. 

  561.                 {

    562. 

  562.                     Log.LogError(string.Format(CultureInfo.CurrentUICulture, "Element not found: {0}", this.Element));

    563. 

  563.                     return;

    564. 

  564.                 }

    565. 

  565. 

    566. 

  566.                 XmlAttribute attNode = elementNode.Attributes.GetNamedItem(this.Key) as XmlAttribute;

    567. 

  567.                 if (attNode == null)

    568. 

  568.                 {

    569. 

  569.                     attNode = this.xmlFileDoc.CreateAttribute(this.Key);

    570. 

  570.                     attNode.Value = this.Value;

    571. 

  571.                     elementNode.Attributes.Append(attNode);

    572. 

  572.                 }

    573. 

  573.                 else

    574. 

  574.                 {

    575. 

  575.                     attNode.Value = this.Value;

    576. 

  576.                 }

    577. 

  577. 

    578. 

  578.                 this.TrySave();

    579. 

  579.             }

    580. 

  580.             else

    581. 

  581.             {

    582. 

  582.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Set Attribute: {0}={1}", this.Key, this.Value));

    583. 

  583.                 if (this.elements != null && this.elements.Count > 0)

    584. 

  584.                 {

    585. 

  585.                     foreach (XmlNode element in this.elements)

    586. 

  586.                     {

    587. 

  587.                         XmlNode attrib = element.Attributes[this.Key] ?? element.Attributes.Append(this.xmlFileDoc.CreateAttribute(this.Key));

    588. 

  588.                         attrib.Value = this.Value;

    589. 

  589.                     }

    590. 

  590. 

    591. 

  591.                     this.TrySave();

    592. 

  592.                 }

    593. 

  593.             }

    594. 

  594.         }

    595. 

  595. 

    596. 

  596.         private XmlNamespaceManager GetNamespaceManagerForDoc()

    597. 

  597.         {

    598. 

  598.             XmlNamespaceManager localnamespaceManager = new XmlNamespaceManager(this.xmlFileDoc.NameTable);

    599. 

  599. 

    600. 

  600.             // If we have had namespace declarations specified add them to the Namespace Mgr for the XML Document.

    601. 

  601.             if (this.Namespaces != null && this.Namespaces.Length > 0)

    602. 

  602.             {

    603. 

  603.                 foreach (ITaskItem item in this.Namespaces)

    604. 

  604.                 {

    605. 

  605.                     string prefix = item.GetMetadata("Prefix");

    606. 

  606.                     string uri = item.GetMetadata("Uri");

    607. 

  607. 

    608. 

  608.                     localnamespaceManager.AddNamespace(prefix, uri);

    609. 

  609.                 }

    610. 

  610.             }

    611. 

  611. 

    612. 

  612.             return localnamespaceManager;

    613. 

  613.         }

    614. 

  614. 

    615. 

  615.         private void AddElement()

    616. 

  616.         {

    617. 

  617.             if (string.IsNullOrEmpty(this.XPath))

    618. 

  618.             {

    619. 

  619.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Add Element: {0}", this.Element));

    620. 

  620.                 XmlNode parentNode = this.xmlFileDoc.SelectSingleNode(this.ParentElement);

    621. 

  621.                 if (parentNode == null)

    622. 

  622.                 {

    623. 

  623.                     Log.LogError("ParentElement not found: " + this.ParentElement);

    624. 

  624.                     return;

    625. 

  625.                 }

    626. 

  626. 

    627. 

  627.                 // Ensure node does not already exist

    628. 

  628.                 XmlNode newNode = this.xmlFileDoc.SelectSingleNode(this.ParentElement + "/" + this.Element);

    629. 

  629.                 if (newNode == null)

    630. 

  630.                 {

    631. 

  631.                     newNode = this.CreateElement();

    632. 

  632. 

    633. 

  633.                     if (!string.IsNullOrEmpty(this.Key))

    634. 

  634.                     {

    635. 

  635.                         this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Add Attribute: {0} to: {1}", this.Key, this.Element));

    636. 

  636. 

    637. 

  637.                         XmlAttribute attNode = this.xmlFileDoc.CreateAttribute(this.Key);

    638. 

  638.                         attNode.Value = this.Value;

    639. 

  639.                         newNode.Attributes.Append(attNode);

    640. 

  640.                     }

    641. 

  641. 

    642. 

  642.                     if (string.IsNullOrEmpty(this.InsertAfterXPath) && string.IsNullOrEmpty(this.InsertBeforeXPath))

    643. 

  643.                     {

    644. 

  644.                         parentNode.AppendChild(newNode);

    645. 

  645.                     }

    646. 

  646.                     else if (!string.IsNullOrEmpty(this.InsertAfterXPath))

    647. 

  647.                     {

    648. 

  648.                         parentNode.InsertAfter(newNode, parentNode.SelectSingleNode(this.InsertAfterXPath));

    649. 

  649.                     }

    650. 

  650.                     else if (!string.IsNullOrEmpty(this.InsertBeforeXPath))

    651. 

  651.                     {

    652. 

  652.                         parentNode.InsertBefore(newNode, parentNode.SelectSingleNode(this.InsertBeforeXPath));

    653. 

  653.                     }

    654. 

  654. 

    655. 

  655.                     this.TrySave();

    656. 

  656.                 }

    657. 

  657.                 else

    658. 

  658.                 {

    659. 

  659.                     if (!string.IsNullOrEmpty(this.InnerText))

    660. 

  660.                     {

    661. 

  661.                         newNode.InnerText = this.InnerText;

    662. 

  662.                     }

    663. 

  663.                     else if (!string.IsNullOrEmpty(this.InnerXml))

    664. 

  664.                     {

    665. 

  665.                         newNode.InnerXml = this.InnerXml;

    666. 

  666.                     }

    667. 

  667. 

    668. 

  668.                     this.TrySave();

    669. 

  669.                 }

    670. 

  670.             }

    671. 

  671.             else

    672. 

  672.             {

    673. 

  673.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Add Element: {0}", this.XPath));

    674. 

  674.                 if (this.elements != null && this.elements.Count > 0)

    675. 

  675.                 {

    676. 

  676.                     foreach (XmlNode element in this.elements)

    677. 

  677.                     {

    678. 

  678.                         XmlNode newNode = this.CreateElement();

    679. 

  679. 

    680. 

  680.                         if (!string.IsNullOrEmpty(this.Key))

    681. 

  681.                         {

    682. 

  682.                             this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Add Attribute: {0} to: {1}", this.Key, this.Element));

    683. 

  683. 

    684. 

  684.                             XmlAttribute attNode = this.xmlFileDoc.CreateAttribute(this.Key);

    685. 

  685.                             attNode.Value = this.Value;

    686. 

  686.                             newNode.Attributes.Append(attNode);

    687. 

  687.                         }

    688. 

  688. 

    689. 

  689.                         element.AppendChild(newNode);

    690. 

  690.                     }

    691. 

  691. 

    692. 

  692.                     this.TrySave();

    693. 

  693.                 }

    694. 

  694.             }

    695. 

  695.         }

    696. 

  696. 

    697. 

  697.         private XmlNode CreateElement()

    698. 

  698.         {

    699. 

  699.             XmlNode newNode;

    700. 

  700.             if (string.IsNullOrEmpty(this.Prefix))

    701. 

  701.             {

    702. 

  702.                 newNode = this.xmlFileDoc.CreateElement(this.Element, this.xmlFileDoc.DocumentElement.NamespaceURI);

    703. 

  703.             }

    704. 

  704.             else

    705. 

  705.             {

    706. 

  706.                 string prefixNamespace = this.namespaceManager.LookupNamespace(this.Prefix);

    707. 

  707.                 if (string.IsNullOrEmpty(prefixNamespace))

    708. 

  708.                 {

    709. 

  709.                     Log.LogError("Prefix not defined in Namespaces in parameters: " + this.Prefix);

    710. 

  710.                     return null;

    711. 

  711.                 }

    712. 

  712. 

    713. 

  713.                 newNode = this.xmlFileDoc.CreateElement(this.Prefix, this.Element, prefixNamespace);

    714. 

  714.             }

    715. 

  715. 

    716. 

  716.             if (!string.IsNullOrEmpty(this.InnerText))

    717. 

  717.             {

    718. 

  718.                 newNode.InnerText = this.InnerText;    

    719. 

  719.             }

    720. 

  720.             else if (!string.IsNullOrEmpty(this.InnerXml))

    721. 

  721.             {

    722. 

  722.                 newNode.InnerXml = this.InnerXml;

    723. 

  723.             }

    724. 

  724. 

    725. 

  725.             return newNode;

    726. 

  726.         }

    727. 

  727. 

    728. 

  728.         private void RemoveElement()

    729. 

  729.         {

    730. 

  730.             if (string.IsNullOrEmpty(this.XPath))

    731. 

  731.             {

    732. 

  732.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Remove Element: {0}", this.Element));

    733. 

  733.                 XmlNode parentNode = this.xmlFileDoc.SelectSingleNode(this.ParentElement);

    734. 

  734.                 if (parentNode == null)

    735. 

  735.                 {

    736. 

  736.                     Log.LogError("ParentElement not found: " + this.ParentElement);

    737. 

  737.                     return;

    738. 

  738.                 }

    739. 

  739. 

    740. 

  740.                 XmlNode nodeToRemove = this.xmlFileDoc.SelectSingleNode(this.ParentElement + "/" + this.Element);

    741. 

  741.                 if (nodeToRemove != null)

    742. 

  742.                 {

    743. 

  743.                     parentNode.RemoveChild(nodeToRemove);

    744. 

  744.                     this.TrySave();

    745. 

  745.                 }

    746. 

  746.             }

    747. 

  747.             else

    748. 

  748.             {

    749. 

  749.                 this.LogTaskMessage(string.Format(CultureInfo.CurrentUICulture, "Remove Element: {0}", this.XPath));

    750. 

  750.                 if (this.elements != null && this.elements.Count > 0)

    751. 

  751.                 {

    752. 

  752.                     foreach (XmlNode element in this.elements)

    753. 

  753.                     {

    754. 

  754.                         element.ParentNode.RemoveChild(element);

    755. 

  755.                     }

    756. 

  756. 

    757. 

  757.                     this.TrySave();

    758. 

  758.                 }

    759. 

  759.             }

    760. 

  760.         }

    761. 

  761. 

    762. 

  762.         private void TrySave()

    763. 

  763.         {

    764. 

  764.             try

    765. 

  765.             {

    766. 

  766.                 this.xmlFileDoc.Save(this.File.ItemSpec);

    767. 

  767.             }

    768. 

  768.             catch (Exception ex)

    769. 

  769.             {

    770. 

  770.                 this.LogTaskWarning(ex.Message);

    771. 

  771.                 bool saved = false;

    772. 

  772.                 int count = 1;

    773. 

  773.                 while (!saved && count <= this.RetryCount)

    774. 

  774.                 {

    775. 

  775.                     this.LogTaskMessage(MessageImportance.High, string.Format(CultureInfo.InvariantCulture, "Save failed, trying again in 5 seconds. Attempt {0} of {1}", count, this.RetryCount));

    776. 

  776.                     System.Threading.Thread.Sleep(5000);

    777. 

  777.                     count++;

    778. 

  778.                     try

    779. 

  779.                     {

    780. 

  780.                         this.xmlFileDoc.Save(this.File.ItemSpec);

    781. 

  781.                         saved = true;

    782. 

  782.                     }

    783. 

  783.                     catch

    784. 

  784.                     {

    785. 

  785.                         this.LogTaskWarning(ex.Message);

    786. 

  786.                     }

    787. 

  787.                 }

    788. 

  788. 

    789. 

  789.                 if (saved != true)

    790. 

  790.                 {

    791. 

  791.                     throw;

    792. 

  792.                 }

    793. 

  793.             }

    794. 

  794.         }

    795. 

  795.     }

    796. 

  796. }
    797.