From 09367376b5b1d511a165ecf75553debf21bd663a Mon Sep 17 00:00:00 2001
From: markrendle <mark@markrendle.net>
Date: Tue, 16 Feb 2010 16:14:36 +0000
Subject: [PATCH] Changed XElementExtensions to use (prefix,name) arguments

---
 .../Linq/EnumerableExtensionTests.cs          |   2 +-
 NExtLib.Tests/NExtLib.Tests.csproj            |   7 +-
 .../Properties/Resources.Designer.cs          |  17 +++
 NExtLib.Tests/Properties/Resources.resx       |   6 +-
 .../Resources/XmlWithPrefixedNamespace.txt    |   9 ++
 .../Xml/Linq/XElementExtensionsTests.cs       |  24 +++-
 .../NExtLib.Unit.csproj                       |   2 +-
 .../Properties/AssemblyInfo.cs                |   0
 .../ShouldExtensions.cs                       |   2 +-
 NExtLib.sln                                   |   2 +-
 NExtLib/Async/AsyncException.cs               |  19 +++
 NExtLib/Async/Future.cs                       |  22 ++++
 NExtLib/Async/Future`1.cs                     |  66 ++++++++++
 NExtLib/Func.cs                               |  16 +++
 .../EnumerableOfKeyValuePairExtensions.cs     |  22 ++++
 NExtLib/NExtLib.csproj                        |  23 ++++
 NExtLib/Properties/Resources.Designer.cs      |  72 ++++++++++
 NExtLib/Properties/Resources.resx             | 123 ++++++++++++++++++
 NExtLib/StringExtensions.cs                   |  15 +++
 NExtLib/Xml/Linq/XAttributeExtensions.cs      |  21 +++
 NExtLib/Xml/Linq/XElementExtensions.cs        |  18 ++-
 .../Syndication/SyndicationItemExtensions.cs  |  34 +++++
 22 files changed, 502 insertions(+), 20 deletions(-)
 create mode 100644 NExtLib.Tests/Resources/XmlWithPrefixedNamespace.txt
 rename NExtLib.UnitTest/NExtLib.UnitTest.csproj => NExtLib.Unit/NExtLib.Unit.csproj (97%)
 rename {NExtLib.UnitTest => NExtLib.Unit}/Properties/AssemblyInfo.cs (100%)
 rename {NExtLib.UnitTest => NExtLib.Unit}/ShouldExtensions.cs (91%)
 create mode 100644 NExtLib/Async/AsyncException.cs
 create mode 100644 NExtLib/Async/Future.cs
 create mode 100644 NExtLib/Async/Future`1.cs
 create mode 100644 NExtLib/Func.cs
 create mode 100644 NExtLib/Linq/EnumerableOfKeyValuePairExtensions.cs
 create mode 100644 NExtLib/Properties/Resources.Designer.cs
 create mode 100644 NExtLib/Properties/Resources.resx
 create mode 100644 NExtLib/StringExtensions.cs
 create mode 100644 NExtLib/Xml/Linq/XAttributeExtensions.cs
 create mode 100644 NExtLib/Xml/Syndication/SyndicationItemExtensions.cs

diff --git a/NExtLib.Tests/Linq/EnumerableExtensionTests.cs b/NExtLib.Tests/Linq/EnumerableExtensionTests.cs
index 44a3c59..c239bdd 100644
--- a/NExtLib.Tests/Linq/EnumerableExtensionTests.cs
+++ b/NExtLib.Tests/Linq/EnumerableExtensionTests.cs
@@ -4,7 +4,7 @@
 using System.Text;
 using NUnit.Framework;
 using NExtLib.Linq;
-using NExtLib.UnitTest;
+using NExtLib.Unit;
 
 namespace NExtLib.Tests.Linq
 {
diff --git a/NExtLib.Tests/NExtLib.Tests.csproj b/NExtLib.Tests/NExtLib.Tests.csproj
index 223220a..0b06231 100644
--- a/NExtLib.Tests/NExtLib.Tests.csproj
+++ b/NExtLib.Tests/NExtLib.Tests.csproj
@@ -59,9 +59,9 @@
     <None Include="Resources\XmlWithDefaultNamespace.txt" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\NExtLib.UnitTest\NExtLib.UnitTest.csproj">
+    <ProjectReference Include="..\NExtLib.Unit\NExtLib.Unit.csproj">
       <Project>{072F8BE4-81C1-4276-A9A5-1AEC87A84265}</Project>
-      <Name>NExtLib.UnitTest</Name>
+      <Name>NExtLib.Unit</Name>
     </ProjectReference>
     <ProjectReference Include="..\NExtLib\NExtLib.csproj">
       <Project>{4A191FAD-DC1D-46FC-A941-7DEB2C8C4C15}</Project>
@@ -71,6 +71,9 @@
   <ItemGroup>
     <None Include="Resources\XmlWithNoNamespace.txt" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\XmlWithPrefixedNamespace.txt" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/NExtLib.Tests/Properties/Resources.Designer.cs b/NExtLib.Tests/Properties/Resources.Designer.cs
index 6658f37..b717eed 100644
--- a/NExtLib.Tests/Properties/Resources.Designer.cs
+++ b/NExtLib.Tests/Properties/Resources.Designer.cs
@@ -93,5 +93,22 @@ internal class Resources {
                 return ResourceManager.GetString("XmlWithNoNamespace", resourceCulture);
             }
         }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
+        ///&lt;root xmlns:c=&quot;http://schemas.next.lib/tests&quot;&gt;
+        ///  &lt;c:child&gt;
+        ///    &lt;c:sub&gt;Foo&lt;/sub&gt;
+        ///  &lt;/c:child&gt;  
+        ///  &lt;c:child&gt;
+        ///    &lt;c:sub&gt;Bar&lt;/sub&gt;
+        ///  &lt;/c:child&gt;  
+        ///&lt;/root&gt;.
+        /// </summary>
+        internal static string XmlWithPrefixedNamespace {
+            get {
+                return ResourceManager.GetString("XmlWithPrefixedNamespace", resourceCulture);
+            }
+        }
     }
 }
diff --git a/NExtLib.Tests/Properties/Resources.resx b/NExtLib.Tests/Properties/Resources.resx
index 0f6b421..206a5e5 100644
--- a/NExtLib.Tests/Properties/Resources.resx
+++ b/NExtLib.Tests/Properties/Resources.resx
@@ -117,11 +117,15 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
   <data name="XmlWithDefaultNamespace" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\XmlWithDefaultNamespace.txt;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
   </data>
   <data name="XmlWithNoNamespace" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\XmlWithNoNamespace.txt;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
   </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="XmlWithPrefixedNamespace" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\XmlWithPrefixedNamespace.txt;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/NExtLib.Tests/Resources/XmlWithPrefixedNamespace.txt b/NExtLib.Tests/Resources/XmlWithPrefixedNamespace.txt
new file mode 100644
index 0000000..9ace024
--- /dev/null
+++ b/NExtLib.Tests/Resources/XmlWithPrefixedNamespace.txt
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root xmlns:c="http://schemas.next.lib/tests">
+  <c:child>
+    <c:sub>Foo</c:sub>
+  </c:child>  
+  <c:child>
+    <c:sub>Bar</c:sub>
+  </c:child>  
+</root>
\ No newline at end of file
diff --git a/NExtLib.Tests/Xml/Linq/XElementExtensionsTests.cs b/NExtLib.Tests/Xml/Linq/XElementExtensionsTests.cs
index 48dc103..7af9e3c 100644
--- a/NExtLib.Tests/Xml/Linq/XElementExtensionsTests.cs
+++ b/NExtLib.Tests/Xml/Linq/XElementExtensionsTests.cs
@@ -4,7 +4,7 @@
 using System.Text;
 using NUnit.Framework;
 using System.Xml.Linq;
-using NExtLib.UnitTest;
+using NExtLib.Unit;
 
 namespace NExtLib.Tests.Xml.Linq
 {
@@ -15,20 +15,30 @@ public class XElementExtensionsTests
         public void TestXElementWithDefaultNamespace()
         {
             var element = XElement.Parse(Properties.Resources.XmlWithDefaultNamespace);
-            var list = element.XElements("child").ToList();
+            var list = element.Elements(null, "child").ToList();
             list.Count.ShouldEqual(2);
-            list[0].XElement("sub").Value.ShouldEqual("Foo");
-            list[1].XElement("sub").Value.ShouldEqual("Bar");
+            list[0].Element(null, "sub").Value.ShouldEqual("Foo");
+            list[1].Element(null, "sub").Value.ShouldEqual("Bar");
         }
 
         [Test]
         public void TestXElementWithNoNamespace()
         {
             var element = XElement.Parse(Properties.Resources.XmlWithNoNamespace);
-            var list = element.XElements("child").ToList();
+            var list = element.Elements(null, "child").ToList();
             list.Count.ShouldEqual(2);
-            list[0].XElement("sub").Value.ShouldEqual("Foo");
-            list[1].XElement("sub").Value.ShouldEqual("Bar");
+            list[0].Element(null, "sub").Value.ShouldEqual("Foo");
+            list[1].Element(null, "sub").Value.ShouldEqual("Bar");
+        }
+
+        [Test]
+        public void TestXElementWithPrefixedNamespace()
+        {
+            var element = XElement.Parse(Properties.Resources.XmlWithPrefixedNamespace);
+            var list = element.Elements("c", "child").ToList();
+            list.Count.ShouldEqual(2);
+            list[0].Element("c", "sub").Value.ShouldEqual("Foo");
+            list[1].Element("c", "sub").Value.ShouldEqual("Bar");
         }
     }
 }
diff --git a/NExtLib.UnitTest/NExtLib.UnitTest.csproj b/NExtLib.Unit/NExtLib.Unit.csproj
similarity index 97%
rename from NExtLib.UnitTest/NExtLib.UnitTest.csproj
rename to NExtLib.Unit/NExtLib.Unit.csproj
index 8f2a9f6..c911968 100644
--- a/NExtLib.UnitTest/NExtLib.UnitTest.csproj
+++ b/NExtLib.Unit/NExtLib.Unit.csproj
@@ -8,7 +8,7 @@
     <ProjectGuid>{072F8BE4-81C1-4276-A9A5-1AEC87A84265}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>NExtLib.UnitTest</RootNamespace>
+    <RootNamespace>NExtLib.Unit</RootNamespace>
     <AssemblyName>NExtLib.UnitTest</AssemblyName>
     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
diff --git a/NExtLib.UnitTest/Properties/AssemblyInfo.cs b/NExtLib.Unit/Properties/AssemblyInfo.cs
similarity index 100%
rename from NExtLib.UnitTest/Properties/AssemblyInfo.cs
rename to NExtLib.Unit/Properties/AssemblyInfo.cs
diff --git a/NExtLib.UnitTest/ShouldExtensions.cs b/NExtLib.Unit/ShouldExtensions.cs
similarity index 91%
rename from NExtLib.UnitTest/ShouldExtensions.cs
rename to NExtLib.Unit/ShouldExtensions.cs
index de1b8a0..9d58ae8 100644
--- a/NExtLib.UnitTest/ShouldExtensions.cs
+++ b/NExtLib.Unit/ShouldExtensions.cs
@@ -4,7 +4,7 @@
 using System.Text;
 using NUnit.Framework;
 
-namespace NExtLib.UnitTest
+namespace NExtLib.Unit
 {
     public static class ShouldExtensions
     {
diff --git a/NExtLib.sln b/NExtLib.sln
index 7da7d1a..2ff5fcb 100644
--- a/NExtLib.sln
+++ b/NExtLib.sln
@@ -5,7 +5,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NExtLib", "NExtLib\NExtLib.
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NExtLib.Tests", "NExtLib.Tests\NExtLib.Tests.csproj", "{8DF17038-537D-45BE-B229-C99EECBB4EDC}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NExtLib.UnitTest", "NExtLib.UnitTest\NExtLib.UnitTest.csproj", "{072F8BE4-81C1-4276-A9A5-1AEC87A84265}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NExtLib.Unit", "NExtLib.Unit\NExtLib.Unit.csproj", "{072F8BE4-81C1-4276-A9A5-1AEC87A84265}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/NExtLib/Async/AsyncException.cs b/NExtLib/Async/AsyncException.cs
new file mode 100644
index 0000000..7f6cbbc
--- /dev/null
+++ b/NExtLib/Async/AsyncException.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NExtLib.Async
+{
+    [Serializable]
+    public class AsyncException : Exception
+    {
+        public AsyncException() { }
+        public AsyncException(string message) : base(message) { }
+        public AsyncException(string message, Exception inner) : base(message, inner) { }
+        protected AsyncException(
+          System.Runtime.Serialization.SerializationInfo info,
+          System.Runtime.Serialization.StreamingContext context)
+            : base(info, context) { }
+    }
+}
diff --git a/NExtLib/Async/Future.cs b/NExtLib/Async/Future.cs
new file mode 100644
index 0000000..8a2e0c2
--- /dev/null
+++ b/NExtLib/Async/Future.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NExtLib.Async
+{
+    public static class Future
+    {
+        /// <summary>
+        /// Creates an instance of <see cref="Future`1"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of value represented by the Future.</typeparam>
+        /// <param name="func">The <see cref="Func`1"/> delegate that will return the value.</param>
+        /// <returns>A new instance of <see cref="Future`1"/>.</returns>
+        /// <remarks>This method exists only to provide type-inference convenience.</remarks>
+        public static Future<T> Create<T>(Func<T> func)
+        {
+            return new Future<T>(func);
+        }
+    }
+}
diff --git a/NExtLib/Async/Future`1.cs b/NExtLib/Async/Future`1.cs
new file mode 100644
index 0000000..0263b59
--- /dev/null
+++ b/NExtLib/Async/Future`1.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NExtLib.Async
+{
+    public class Future<T>
+    {
+        private readonly Action _action;
+        private readonly IAsyncResult _asyncResult;
+        private readonly object _lock = new object();
+        private bool _ended;
+        private T _value;
+        private Exception _error;
+
+        public Future(Func<T> func)
+        {
+            if (func == null) throw new ArgumentNullException("func");
+
+            _action = () => Run(func);
+            _asyncResult = _action.BeginInvoke(null, null);
+        }
+
+        public T Value
+        {
+            get
+            {
+                JoinAction();
+
+                if (_error != null) throw new AsyncException(Properties.Resources.Async_AsyncExceptionMessage, _error);
+                return _value;
+            }
+        }
+
+        private void Run(Func<T> func)
+        {
+            try
+            {
+                _value = func();
+            }
+            catch (Exception ex)
+            {
+                if (ex is SystemException) throw;
+
+                _error = ex;
+                _value = default(T);
+            }
+        }
+
+        private void JoinAction()
+        {
+            if (!_ended)
+            {
+                lock (_lock)
+                {
+                    if (!_ended)
+                    {
+                        _action.EndInvoke(_asyncResult);
+                        _ended = true;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/NExtLib/Func.cs b/NExtLib/Func.cs
new file mode 100644
index 0000000..f9d744b
--- /dev/null
+++ b/NExtLib/Func.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NExtLib
+{
+    public static class Func
+    {
+        public static Func<TIn, TOut> NoOp<TIn, TOut>()
+            where TIn : TOut
+        {
+            return (x) => x;
+        }
+    }
+}
diff --git a/NExtLib/Linq/EnumerableOfKeyValuePairExtensions.cs b/NExtLib/Linq/EnumerableOfKeyValuePairExtensions.cs
new file mode 100644
index 0000000..c8f528a
--- /dev/null
+++ b/NExtLib/Linq/EnumerableOfKeyValuePairExtensions.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace System.Linq
+{
+    public static class EnumerableOfKeyValuePairExtensions
+    {
+        public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source)
+        {
+            Dictionary<TKey, TValue> dictionary;
+
+            if ((dictionary = source as Dictionary<TKey, TValue>) == null)
+            {
+                dictionary = source.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+            }
+
+            return dictionary;
+        }
+    }
+}
diff --git a/NExtLib/NExtLib.csproj b/NExtLib/NExtLib.csproj
index 95f64db..9ed4291 100644
--- a/NExtLib/NExtLib.csproj
+++ b/NExtLib/NExtLib.csproj
@@ -33,20 +33,43 @@
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Runtime.Serialization" />
+    <Reference Include="System.ServiceModel" />
+    <Reference Include="System.ServiceModel.Web" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Async\AsyncException.cs" />
+    <Compile Include="Async\Future.cs" />
+    <Compile Include="Async\Future`1.cs" />
+    <Compile Include="Func.cs" />
+    <Compile Include="Linq\EnumerableOfKeyValuePairExtensions.cs" />
     <Compile Include="Linq\EnumerableExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="StringExtensions.cs" />
     <Compile Include="Tuple.cs" />
     <Compile Include="Linq\TupleEnumerableExtensions.cs" />
     <Compile Include="TupleExtensions.cs" />
     <Compile Include="Tuple`2.cs" />
+    <Compile Include="Xml\Linq\XAttributeExtensions.cs" />
     <Compile Include="Xml\Linq\XElementExtensions.cs" />
+    <Compile Include="Xml\Syndication\SyndicationItemExtensions.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/NExtLib/Properties/Resources.Designer.cs b/NExtLib/Properties/Resources.Designer.cs
new file mode 100644
index 0000000..c46b9ce
--- /dev/null
+++ b/NExtLib/Properties/Resources.Designer.cs
@@ -0,0 +1,72 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30128.1
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace NExtLib.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("NExtLib.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to An error occurred during execution..
+        /// </summary>
+        internal static string Async_AsyncExceptionMessage {
+            get {
+                return ResourceManager.GetString("Async_AsyncExceptionMessage", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/NExtLib/Properties/Resources.resx b/NExtLib/Properties/Resources.resx
new file mode 100644
index 0000000..413141d
--- /dev/null
+++ b/NExtLib/Properties/Resources.resx
@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="Async_AsyncExceptionMessage" xml:space="preserve">
+    <value>An error occurred during execution.</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/NExtLib/StringExtensions.cs b/NExtLib/StringExtensions.cs
new file mode 100644
index 0000000..af748f0
--- /dev/null
+++ b/NExtLib/StringExtensions.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NExtLib
+{
+    public static class StringExtensions
+    {
+        public static string EnsureStartsWith(this string source, string value)
+        {
+            return (source == null || source.StartsWith(value)) ? source : value + source;
+        }
+    }
+}
diff --git a/NExtLib/Xml/Linq/XAttributeExtensions.cs b/NExtLib/Xml/Linq/XAttributeExtensions.cs
new file mode 100644
index 0000000..7b6af89
--- /dev/null
+++ b/NExtLib/Xml/Linq/XAttributeExtensions.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace System.Xml.Linq
+{
+    public static class XAttributeExtensions
+    {
+        /// <summary>
+        /// Returns the string value of the Attribute or <c>null</c> if the attribute is null.
+        /// Null-safe, eliminates need for null-checking.
+        /// </summary>
+        /// <param name="attribute">The attribute.</param>
+        /// <returns></returns>
+        public static string ValueOrDefault(this XAttribute attribute)
+        {
+            return attribute != null ? attribute.Value : null;
+        }
+    }
+}
diff --git a/NExtLib/Xml/Linq/XElementExtensions.cs b/NExtLib/Xml/Linq/XElementExtensions.cs
index 45a4e4e..bb30dfa 100644
--- a/NExtLib/Xml/Linq/XElementExtensions.cs
+++ b/NExtLib/Xml/Linq/XElementExtensions.cs
@@ -7,16 +7,22 @@ namespace System.Xml.Linq
 {
     public static class XElementExtensions
     {
-        public static XElement XElement(this XElement element, string name)
+        public static XElement Element(this XElement element, string prefix, string name)
         {
-            var xname = element.GetDefaultNamespace() + name;
-            return element.Element(xname);
+            var ns = string.IsNullOrEmpty(prefix) ? element.GetDefaultNamespace() : element.GetNamespaceOfPrefix(prefix);
+            return element.Element(ns + name);
         }
 
-        public static IEnumerable<XElement> XElements(this XElement element, string name)
+        public static IEnumerable<XElement> Elements(this XElement element, string prefix, string name)
         {
-            var xname = element.GetDefaultNamespace() + name;
-            return element.Elements(xname);
+            var ns = string.IsNullOrEmpty(prefix) ? element.GetDefaultNamespace() : element.GetNamespaceOfPrefix(prefix);
+            return element.Elements(ns + name);
+        }
+
+        public static XAttribute Attribute(this XElement element, string prefix, string name)
+        {
+            var ns = string.IsNullOrEmpty(prefix) ? element.GetDefaultNamespace() : element.GetNamespaceOfPrefix(prefix);
+            return element.Attribute(ns + name);
         }
     }
 }
diff --git a/NExtLib/Xml/Syndication/SyndicationItemExtensions.cs b/NExtLib/Xml/Syndication/SyndicationItemExtensions.cs
new file mode 100644
index 0000000..53f9c0d
--- /dev/null
+++ b/NExtLib/Xml/Syndication/SyndicationItemExtensions.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+using System.ServiceModel.Syndication;
+
+namespace NExtLib.Xml.Syndication
+{
+    public static class SyndicationItemExtensions
+    {
+        public static XElement ContentAsXElement(this SyndicationItem item)
+        {
+            var content = item.Content as XmlSyndicationContent;
+
+            if (content == null) return null;
+
+            return XElement.ReadFrom(content.GetReaderAtContent()) as XElement;
+        }
+
+        public static IEnumerable<XElement> ContentsAsXElements(this SyndicationFeed feed)
+        {
+            XElement content;
+
+            foreach (var item in feed.Items)
+            {
+                if ((content = item.ContentAsXElement()) != null)
+                {
+                    yield return content;
+                }
+            }
+        }
+    }
+}