diff --git a/CodeAnalysisDictionary.xml b/CustomDictionary.xml
similarity index 94%
rename from CodeAnalysisDictionary.xml
rename to CustomDictionary.xml
index 1b5c280..ee8f231 100644
--- a/CodeAnalysisDictionary.xml
+++ b/CustomDictionary.xml
@@ -15,6 +15,7 @@
       <Word>iraimbilanja</Word>
       <Word>cinquième</Word>
       <Word>ariary</Word>
+      <Word>Ldml</Word>
     </Recognized>
     <Deprecated>
       <Term PreferredAlternate="EnterpriseServices">ComPlus</Term>
@@ -23,6 +24,7 @@
   <Acronyms>      
     <CasingExceptions>
       <Acronym>USDollar</Acronym>
+      <Acronym>ISO</Acronym>
     </CasingExceptions>
   </Acronyms>
  </Dictionary>
\ No newline at end of file
diff --git a/NextVersion.txt b/NextVersion.txt
deleted file mode 100644
index 341cf11..0000000
--- a/NextVersion.txt
+++ /dev/null
@@ -1 +0,0 @@
-0.2.0
\ No newline at end of file
diff --git a/NodaMoney.Serialization.AspNet/MoneyJavaScriptConverter.cs b/NodaMoney.Serialization.AspNet/MoneyJavaScriptConverter.cs
index c2c4c85..429f1a6 100644
--- a/NodaMoney.Serialization.AspNet/MoneyJavaScriptConverter.cs
+++ b/NodaMoney.Serialization.AspNet/MoneyJavaScriptConverter.cs
@@ -15,10 +15,7 @@ namespace NodaMoney.Serialization.AspNet
     public class MoneyJavaScriptConverter : JavaScriptConverter
     {
         /// <summary>When overridden in a derived class, gets a collection of the supported types.</summary>
-        public override IEnumerable<Type> SupportedTypes
-        {
-            get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { typeof(Money) })); }
-        }
+        public override IEnumerable<Type> SupportedTypes => new ReadOnlyCollection<Type>(new List<Type>(new[] { typeof(Money) }));
 
         /// <summary>When overridden in a derived class, converts the provided dictionary into an object of the specified type.</summary>
         /// <param name="dictionary">An <see cref="T:System.Collections.Generic.IDictionary`2" /> instance of property data stored as name/value pairs.</param>
@@ -30,9 +27,9 @@ public override IEnumerable<Type> SupportedTypes
         public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
         {
             if (dictionary == null)
-                throw new ArgumentNullException("dictionary");
+                throw new ArgumentNullException(nameof(dictionary));
             if (type != typeof(Money))
-                throw new ArgumentException("object should be of type Money to deserialize!", "type");
+                throw new ArgumentException("object should be of type Money to deserialize!", nameof(type));
 
             decimal amount = decimal.Parse((string)dictionary["amount"], CultureInfo.InvariantCulture);
             string code = (string)dictionary["currency"];
diff --git a/NodaMoney.Serialization.AspNet/NodaMoney.Serialization.AspNet.csproj b/NodaMoney.Serialization.AspNet/NodaMoney.Serialization.AspNet.csproj
index 49c9b4f..646db6c 100644
--- a/NodaMoney.Serialization.AspNet/NodaMoney.Serialization.AspNet.csproj
+++ b/NodaMoney.Serialization.AspNet/NodaMoney.Serialization.AspNet.csproj
@@ -9,8 +9,9 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>NodaMoney.Serialization.AspNet</RootNamespace>
     <AssemblyName>NodaMoney.Serialization.AspNet</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -46,17 +47,17 @@
     <Compile Include="MoneyJavaScriptConverter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml">
-      <Link>Properties\CodeAnalysisDictionary.xml</Link>
-    </CodeAnalysisDictionary>
-  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\NodaMoney\NodaMoney.csproj">
       <Project>{1814E8DE-0E75-4E23-9F70-E039AC816B42}</Project>
       <Name>NodaMoney</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <CodeAnalysisDictionary Include="..\CustomDictionary.xml">
+      <Link>Properties\CustomDictionary.xml</Link>
+    </CodeAnalysisDictionary>
+  </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/NodaMoney.UnitTests/CurrencyBuilderTests.cs b/NodaMoney.UnitTests/CurrencyBuilderTests.cs
new file mode 100644
index 0000000..a12a4d9
--- /dev/null
+++ b/NodaMoney.UnitTests/CurrencyBuilderTests.cs
@@ -0,0 +1,152 @@
+using System;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace NodaMoney.UnitTests
+{
+    public class CurrencyBuilderTests
+    {
+        [TestClass]
+        public class GivenIWantToCreateCustomCurrency
+        {
+            [TestMethod]
+            public void WhenRegisterBitCoinInIsoNamespace_ThenShouldBeAvailable()
+            {
+                var builder = new CurrencyBuilder("BTC", "ISO-4217");
+                builder.EnglishName = "Bitcoin";
+                builder.Symbol = "฿";
+                builder.ISONumber = "123"; // iso number
+                builder.DecimalDigits = 8;
+                builder.IsObsolete = false;
+
+                Currency result = builder.Register();
+
+                Currency bitcoin = Currency.FromCode("BTC");
+                bitcoin.Symbol.Should().Be("฿");
+                bitcoin.ShouldBeEquivalentTo(result);
+            }
+
+            [TestMethod]
+            public void WhenRegisterBitCoin_ThenShouldBeAvailableByExplicitNamespace()
+            {
+                var builder = new CurrencyBuilder("BTC1", "virtual");
+                builder.EnglishName = "Bitcoin";
+                builder.Symbol = "฿";
+                builder.ISONumber = "123"; // iso number
+                builder.DecimalDigits = 8;
+                builder.IsObsolete = false;
+
+                Currency result = builder.Register();
+
+                Currency bitcoin = Currency.FromCode("BTC1", "virtual");
+                bitcoin.Symbol.Should().Be("฿");
+                bitcoin.ShouldBeEquivalentTo(result);
+            }
+
+            [TestMethod]
+            public void WhenBuildBitCoin_ThenItShouldSuccedButNotBeRegistered()
+            {
+                var builder = new CurrencyBuilder("BTC2", "virtual");
+                builder.EnglishName = "Bitcoin";
+                builder.Symbol = "฿";
+                builder.ISONumber = "123"; // iso number
+                builder.DecimalDigits = 8;
+                builder.IsObsolete = false;
+
+                Currency result = builder.Build();
+                result.Symbol.Should().Be("฿");
+
+                Action action = () => Currency.FromCode("BTC2", "virtual");
+                action.ShouldThrow<ArgumentException>().WithMessage("BTC2 is an unknown virtual currency code!");
+            }
+
+            [TestMethod]
+            public void WhenFromExistingCurrency_ThenThisShouldSucceed()
+            {
+                var builder = new CurrencyBuilder("BTC3", "virtual");
+
+                var euro = Currency.FromCode("EUR");
+                builder.LoadDataFromCurrency(euro);
+
+                builder.Code.Should().Be("BTC3");
+                builder.Namespace.Should().Be("virtual");
+                builder.EnglishName.Should().Be(euro.EnglishName);
+                builder.Symbol.Should().Be(euro.Symbol);
+                builder.ISONumber.Should().Be(euro.Number);
+                builder.DecimalDigits.Should().Be(euro.DecimalDigits);
+                builder.IsObsolete.Should().Be(euro.IsObsolete);
+                builder.ValidFrom.Should().Be(euro.ValidFrom);
+                builder.ValidTo.Should().Be(euro.ValidTo);
+            }
+        }
+
+        [TestClass]
+        public class GivenIWantToUnregisterCurrency
+        {
+            [TestMethod]
+            public void WhenUnregisterIsoCurrency_ThenThisMustSucceed()
+            {
+                var euro = Currency.FromCode("EUR"); // should work
+
+                CurrencyBuilder.Unregister("EUR", "ISO-4217");
+                Action action = () => Currency.FromCode("EUR");
+
+                action.ShouldThrow<ArgumentException>().WithMessage("*unknown*currency*");
+
+                // register again for other unit-tests
+                var builder = new CurrencyBuilder("EUR", "ISO-4217");
+                builder.LoadDataFromCurrency(euro);
+                builder.Register();
+            }
+
+            [TestMethod]
+            public void WhenUnregisterCustomCurrency_ThenThisMustSucceed()
+            {
+                var builder = new CurrencyBuilder("XYZ", "virtual");
+                builder.EnglishName = "Xyz";
+                builder.Symbol = "฿";
+                builder.ISONumber = "123"; // iso number
+                builder.DecimalDigits = 4;
+                builder.IsObsolete = false;
+
+                builder.Register();
+                Currency xyz = Currency.FromCode("XYZ", "virtual"); // should work
+
+                CurrencyBuilder.Unregister("XYZ", "virtual");
+                Action action = () => Currency.FromCode("XYZ", "virtual");
+
+                action.ShouldThrow<ArgumentException>().WithMessage("*unknown*currency*");
+            }
+
+            [TestMethod]
+            public void WhenCurrencyDoesntExist_ThenThisShouldThrow()
+            {
+                Action action = () => CurrencyBuilder.Unregister("ABC", "virtual");
+
+                action.ShouldThrow<ArgumentException>().WithMessage("*specifies a currency that is not found*");
+            }
+        }
+
+        [TestClass]
+        public class GivenIWantToReplaceIsoCurrencyWithOwnVersion
+        {
+            [TestMethod]
+            public void WhenReplacingEuroWithCustom_ThenThisShouldSucceed()
+            {
+                Currency oldEuro = CurrencyBuilder.Unregister("EUR", "ISO-4217");
+
+                var builder = new CurrencyBuilder("EUR", "ISO-4217");
+                builder.LoadDataFromCurrency(oldEuro);
+                builder.EnglishName = "New Euro";
+                builder.DecimalDigits = 1;
+
+                builder.Register();
+
+                Currency newEuro = Currency.FromCode("EUR");
+                newEuro.Symbol.Should().Be("€");
+                newEuro.EnglishName.Should().Be("New Euro");
+                newEuro.DecimalDigits.Should().Be(1);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/NodaMoney.UnitTests/CurrencyTests.cs b/NodaMoney.UnitTests/CurrencyTests.cs
index bf6771a..471f8b2 100644
--- a/NodaMoney.UnitTests/CurrencyTests.cs
+++ b/NodaMoney.UnitTests/CurrencyTests.cs
@@ -20,7 +20,7 @@ public void WhenAskingForIt_ThenAllCurrenciesShouldBeReturned()
                 var currencies = Currency.GetAllCurrencies();
 
                 currencies.Should().NotBeEmpty();
-                currencies.Length.Should().BeGreaterThan(100);
+                currencies.Count().Should().BeGreaterThan(100);
             }
 
             [TestMethod][Ignore]
@@ -56,7 +56,7 @@ public void WriteAllCurrenciesToFile()
                     foreach (var currency in Currency.GetAllCurrencies())
                     {
                         writer.WriteLine("EnglishName: {0}", currency.EnglishName);
-                        writer.WriteLine("Code: {0}, Number: {1}, Sign: {2}", currency.Code, currency.Number, currency.Sign);
+                        writer.WriteLine("Code: {0}, Number: {1}, Sign: {2}", currency.Code, currency.Number, currency.Symbol);
                         writer.WriteLine("MajorUnit: {0}, MinorUnit: {1}, DecimalDigits: {2}", currency.MajorUnit, currency.MinorUnit, currency.DecimalDigits);
                         writer.WriteLine(string.Empty);
                     }
@@ -96,9 +96,10 @@ public void WhenIsoCodeIsExisting_ThenCreatingShouldSucceed()
                 var currency = Currency.FromCode("EUR");
 
                 currency.Should().NotBeNull();
-                currency.Sign.Should().Be("€");
+                currency.Symbol.Should().Be("€");
                 currency.Code.Should().Be("EUR");
                 currency.EnglishName.Should().Be("Euro");
+                currency.IsObsolete.Should().BeFalse();
             }
 
             [TestMethod]
@@ -116,6 +117,17 @@ public void WhenIsoCodeIsNull_ThenCreatingShouldThrow()
 
                 action.ShouldThrow<ArgumentNullException>();
             }
+
+            [TestMethod]
+            public void WhenEstionianKrone_ThenItShouldBeObsolete()
+            {
+                var currency = Currency.FromCode("EEK");
+
+                currency.Should().NotBeNull();
+                currency.Symbol.Should().Be("kr");
+                currency.IsObsolete.Should().BeTrue();
+            }
+
         }
 
         [TestClass]
@@ -127,7 +139,7 @@ public void WhenUsingRegionInfo_ThenCreatingShouldSucceed()
                 var currency = Currency.FromRegion(new RegionInfo("NL"));
 
                 currency.Should().NotBeNull();
-                currency.Sign.Should().Be("€");
+                currency.Symbol.Should().Be("€");
                 currency.Code.Should().Be("EUR");
                 currency.EnglishName.Should().Be("Euro");
             }
@@ -146,7 +158,7 @@ public void WhenUsingRegionName_ThenCreatingShouldSucceed()
                 var currency = Currency.FromRegion("NL");
 
                 currency.Should().NotBeNull();
-                currency.Sign.Should().Be("€");
+                currency.Symbol.Should().Be("€");
                 currency.Code.Should().Be("EUR");
                 currency.EnglishName.Should().Be("Euro");
             }
@@ -165,7 +177,7 @@ public void WhenUsingCultureInfo_ThenCreatingShouldSucceed()
                 var currency = Currency.FromCulture(CultureInfo.CreateSpecificCulture("nl-NL"));
 
                 currency.Should().NotBeNull();
-                currency.Sign.Should().Be("€");
+                currency.Symbol.Should().Be("€");
                 currency.Code.Should().Be("EUR");
                 currency.EnglishName.Should().Be("Euro");
             }
@@ -192,7 +204,7 @@ public void WhenUsingCultureName_ThenCreatingShouldSucceed()
                 var currency = Currency.FromRegion("nl-NL");
 
                 currency.Should().NotBeNull();
-                currency.Sign.Should().Be("€");
+                currency.Symbol.Should().Be("€");
                 currency.Code.Should().Be("EUR");
                 currency.EnglishName.Should().Be("Euro");
             }
@@ -313,7 +325,7 @@ public void WhenParamsAreCorrect_ThenCreatingShouldSucceed()
                 eur.Number.Should().Be("978");
                 eur.DecimalDigits.Should().Be(2);
                 eur.EnglishName.Should().Be("Euro");
-                eur.Sign.Should().Be("€");
+                eur.Symbol.Should().Be("€");
             }
 
             [TestMethod]
@@ -355,13 +367,36 @@ public void WhenDecimalDigitIsLowerThenMinusOne_ThenCreatingShouldThrow()
 
                 action.ShouldThrow<ArgumentOutOfRangeException>();
             }
+        }
 
+        [TestClass]
+        public class GiveIWantToUseALotOfCurrencies
+        {
             [TestMethod]
-            public void WhenDecimalDigitIsHigherThenFour_ThenCreatingShouldThrow()
+            public void WhenCreatingOneMillion_ThenItShouldBeWithinTwoSeconds()
             {
-                Action action = () => { var eur = new Currency("EUR", "978", 5, "Euro", "€"); };
+                var sw = Stopwatch.StartNew();
+                var c = Currency.FromCode("EUR");
+                Console.WriteLine("{0} ms for first call.", sw.ElapsedMilliseconds);
 
-                action.ShouldThrow<ArgumentOutOfRangeException>();
+                double max = 1000000;
+                Action action = () =>
+                    {
+                        sw.Restart();
+                        for (int i = 0; i < max; i++)
+                        {
+                            if (i % 3 == 0)
+                                c = Currency.FromCode("EUR");
+                            else if (i % 2 == 0)
+                                c = Currency.FromCode("USD");
+                            else
+                                c = Currency.FromCode("JPY");
+                        }
+                        sw.Stop();
+                    };
+
+                action.ExecutionTime().ShouldNotExceed(2.Seconds());
+                Console.WriteLine("{0} ms for creating {1:N0} currencies (avg {2:F5} ms).", sw.ElapsedMilliseconds, max, sw.ElapsedMilliseconds / (max));
             }
         }
     }
diff --git a/NodaMoney.UnitTests/Extensions/MoneyExtensionsSafeDivideTests.cs b/NodaMoney.UnitTests/Extensions/MoneyExtensionsSafeDivideTests.cs
index b478952..00f33f1 100644
--- a/NodaMoney.UnitTests/Extensions/MoneyExtensionsSafeDivideTests.cs
+++ b/NodaMoney.UnitTests/Extensions/MoneyExtensionsSafeDivideTests.cs
@@ -2,8 +2,9 @@
 using System.Linq;
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NodaMoney.Extensions;
 
-namespace NodaMoney.Extensions.UnitTests
+namespace NodaMoney.UnitTests.Extensions
 {
     public class MoneyExtensionsSafeDivideTests
     {
diff --git a/NodaMoney.UnitTests/MoneyParsableTests.cs b/NodaMoney.UnitTests/MoneyParsableTests.cs
index 861ae0d..88ed3e7 100644
--- a/NodaMoney.UnitTests/MoneyParsableTests.cs
+++ b/NodaMoney.UnitTests/MoneyParsableTests.cs
@@ -9,15 +9,49 @@ namespace NodaMoney.UnitTests
     static internal class MoneyParsableTests
     {
         [TestClass]
-        public class GivenIWantToParseImplicitCurrencySymbolUsedInMultipleCurrencies
+        public class GivenIWantToParseImplicitCurrency
         {
+            [TestMethod]
+            public void WhenInBelgiumDutchSpeaking_ThenThisShouldSucceed()
+            {
+                using (new SwitchCulture("nl-BE"))
+                {
+                    var euro = Money.Parse("� 765,43");
+
+                    euro.Should().Be(new Money(765.43m, "EUR"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenInBelgiumFrenchSpeaking_ThenThisShouldSucceed()
+            {
+                using (new SwitchCulture("fr-BE"))
+                {
+                    var euro = Money.Parse("765,43 �");
+
+                    euro.Should().Be(new Money(765.43, "EUR"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingNumberWithoutCurrency_ThenThisUseCurrencyOfCurrentCulture()
+            {
+                using (new SwitchCulture("nl-NL"))
+                {
+                    var euro = Money.Parse("765,43");
+
+
+                    euro.Should().Be(new Money(765.43, "EUR"));
+                }
+            }
+
             [TestMethod]
             public void WhenParsingYenYuanSymbolInJapan_ThenThisShouldReturnJapaneseYen()
             {
                 using (new SwitchCulture("ja-JP"))
                 {
                     var yen = Money.Parse("� 765");
-                    
+
                     yen.Should().Be(new Money(765m, "JPY"));
                 }
             }
@@ -80,43 +114,6 @@ public void WhenParsingDollarSymbolInNetherlands_ThenThisShouldFail()
             }
         }
 
-        [TestClass]
-        public class GivenIWantToParseImplicitCurrency
-        {
-            [TestMethod]
-            public void WhenInBelgiumDutchSpeaking_ThenThisShouldSucceed()
-            {
-                using (new SwitchCulture("nl-BE"))
-                {
-                    var euro = Money.Parse("� 765,43");
-
-                    euro.Should().Be(new Money(765.43m, "EUR"));
-                }
-            }
-
-            [TestMethod]
-            public void WhenInBelgiumFrenchSpeaking_ThenThisShouldSucceed()
-            {
-                using (new SwitchCulture("fr-BE"))
-                {
-                    var euro = Money.Parse("765,43 �");
-
-                    euro.Should().Be(new Money(765.43, "EUR"));
-                }
-            }
-
-            [TestMethod]
-            public void WhenParsingNumberWithoutCurrency_ThenThisUseCurrencyOfCurrentCulture()
-            {
-                using (new SwitchCulture("nl-NL"))
-                {
-                    var euro = Money.Parse("765,43");
-
-                    euro.Should().Be(new Money(765.43, "EUR"));
-                }
-            }
-        }
-
         [TestClass]
         public class GivenIWantToParseExplicitCurrency
         {
@@ -311,5 +308,204 @@ public void WhenParsingJapaneseYen_ThenThisShouldBeRoundedUp()
                 }
             }
         }
+
+        [TestClass]
+        public class GivenIWantToTryParseImplicitCurrency
+        {
+            [TestMethod]
+            public void WhenInBelgiumDutchSpeaking_ThenThisShouldSucceed()
+            {
+                using (new SwitchCulture("nl-BE"))
+                {
+                    Money euro;
+                    Money.TryParse("� 765,43", out euro).Should().BeTrue();
+                    euro.Should().Be(new Money(765.43m, "EUR"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenInBelgiumFrenchSpeaking_ThenThisShouldSucceed()
+            {
+                using (new SwitchCulture("fr-BE"))
+                {
+                    Money euro;
+                    Money.TryParse("765,43 �", out euro).Should().BeTrue();
+                    euro.Should().Be(new Money(765.43, "EUR"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingNumberWithoutCurrency_ThenThisUseCurrencyOfCurrentCulture()
+            {
+                using (new SwitchCulture("nl-NL"))
+                {
+                    Money euro;
+                    Money.TryParse("765,43", out euro).Should().BeTrue();
+                    euro.Should().Be(new Money(765.43, "EUR"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingYenYuanSymbolInJapan_ThenThisShouldReturnJapaneseYen()
+            {
+                using (new SwitchCulture("ja-JP"))
+                {
+                    Money yen;
+                    Money.TryParse("� 765", out yen).Should().BeTrue();
+                    yen.Should().Be(new Money(765m, "JPY"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingYenYuanSymbolInChina_ThenThisShouldReturnChineseYuan()
+            {
+                using (new SwitchCulture("zh-CN"))
+                {
+                    Money yuan;
+                    Money.TryParse("� 765", out yuan).Should().BeTrue();
+                    yuan.Should().Be(new Money(765m, "CNY"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingYenYuanInNetherlands_ThenThisShouldReturnFalse()
+            {
+                // � symbol is used for Japanese yen and Chinese yuan
+                using (new SwitchCulture("nl-NL"))
+                {
+                    Money money;
+                    Money.TryParse("� 765", out money).Should().BeFalse();
+                    money.Should().Be(new Money(0m, Currency.FromCode("XXX")));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingDollarSymbolInUSA_ThenThisShouldReturnUSDollar()
+            {
+                using (new SwitchCulture("en-US"))
+                {
+                    Money dollar;
+                    Money.TryParse("$765.43", out dollar).Should().BeTrue();
+                    dollar.Should().Be(new Money(765.43m, "USD"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingDollarSymbolInArgentina_ThenThisShouldReturnArgentinePeso()
+            {
+                using (new SwitchCulture("es-AR"))
+                {
+                    Money peso;
+                    Money.TryParse("$765,43", out peso).Should().BeTrue();
+                    peso.Should().Be(new Money(765.43m, "ARS"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingDollarSymbolInNetherlands_ThenThisShouldReturnFalse()
+            {
+                // $ symbol is used for multiple currencies
+                using (new SwitchCulture("nl-NL"))
+                {
+                    Money money;
+                    Money.TryParse("$ 765,43", out money).Should().BeFalse();
+                    money.Should().Be(new Money(0m, Currency.FromCode("XXX")));
+                }
+            }
+        }
+
+        [TestClass]
+        public class GivenIWantToTryParseExplicitCurrency
+        {
+            [TestMethod]
+            public void WhenParsingYenInNetherlands_ThenThisShouldSucceed()
+            {
+                using (new SwitchCulture("nl-NL"))
+                {
+                    Money yen;
+                    Money.TryParse("� 765", Currency.FromCode("JPY"), out yen).Should().BeTrue();
+                    yen.Should().Be(new Money(765, "JPY"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingArgentinePesoInUSA_ThenThisShouldReturnArgentinePeso()
+            {
+                using (new SwitchCulture("en-US"))
+                {
+                    Money peso;
+                    Money.TryParse("$765.43", Currency.FromCode("ARS"), out peso).Should().BeTrue();
+                    peso.Should().Be(new Money(765.43m, "ARS"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingUSDollarSymbolInArgentina_ThenThisShouldReturnUSDollar()
+            {
+                using (new SwitchCulture("es-AR"))
+                {
+                    Money dollar;
+                    Money.TryParse("$765,43", Currency.FromCode("USD"), out dollar).Should().BeTrue();
+                    dollar.Should().Be(new Money(765.43m, "USD"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingUSDollarInNetherlands_ThenThisShouldSucceed()
+            {
+                // $ symbol is used for multiple currencies
+                using (new SwitchCulture("nl-NL"))
+                {
+                    Money dollar;
+                    Money.TryParse("$765,43", Currency.FromCode("USD"), out dollar).Should().BeTrue();
+                    dollar.Should().Be(new Money(765.43m, "USD"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenInBelgiumDutchSpeaking_ThenThisShouldSucceed()
+            {
+                using (new SwitchCulture("nl-BE"))
+                {
+                    Money euro;
+                    Money.TryParse("� 765,43", Currency.FromCode("EUR"), out euro).Should().BeTrue();
+
+                    euro.Should().Be(new Money(765.43m, "EUR"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenInBelgiumFrenchSpeaking_ThenThisShouldSucceed()
+            {
+                using (new SwitchCulture("fr-BE"))
+                {
+                    Money euro;
+                    Money.TryParse("765,43 �", Currency.FromCode("EUR"), out euro).Should().BeTrue();
+                    euro.Should().Be(new Money(765.43, "EUR"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingNumberWithoutCurrency_ThenThisShouldSucceed()
+            {
+                using (new SwitchCulture("nl-NL"))
+                {
+                    Money euro;
+                    Money.TryParse("765,43", Currency.FromCode("USD"), out euro).Should().BeTrue();
+                    euro.Should().Be(new Money(765.43, "USD"));
+                }
+            }
+
+            [TestMethod]
+            public void WhenParsingUSDollarWithEuroCurrency_ThenThisShouldReturnFalse()
+            {
+                using (new SwitchCulture("nl-NL"))
+                {
+                    Money money;
+                    Money.TryParse("� 765,43", Currency.FromCode("USD"), out money).Should().BeFalse();
+                    money.Should().Be(new Money(0m, Currency.FromCode("XXX")));
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/NodaMoney.UnitTests/NodaMoney.UnitTests.csproj b/NodaMoney.UnitTests/NodaMoney.UnitTests.csproj
index b6a17dd..7f2f77b 100644
--- a/NodaMoney.UnitTests/NodaMoney.UnitTests.csproj
+++ b/NodaMoney.UnitTests/NodaMoney.UnitTests.csproj
@@ -8,7 +8,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>NodaMoney.UnitTests</RootNamespace>
     <AssemblyName>NodaMoney.UnitTests</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
@@ -18,6 +18,7 @@
     <TestProjectType>UnitTest</TestProjectType>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -37,17 +38,17 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="FluentAssertions, Version=3.3.0.0, Culture=neutral, PublicKeyToken=33f2691a05b67b6a, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\FluentAssertions.3.3.0\lib\net45\FluentAssertions.dll</HintPath>
+    <Reference Include="FluentAssertions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=33f2691a05b67b6a, processorArchitecture=MSIL">
+      <HintPath>..\packages\FluentAssertions.4.0.0\lib\net45\FluentAssertions.dll</HintPath>
+      <Private>True</Private>
     </Reference>
-    <Reference Include="FluentAssertions.Core, Version=3.3.0.0, Culture=neutral, PublicKeyToken=33f2691a05b67b6a, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\FluentAssertions.3.3.0\lib\net45\FluentAssertions.Core.dll</HintPath>
+    <Reference Include="FluentAssertions.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=33f2691a05b67b6a, processorArchitecture=MSIL">
+      <HintPath>..\packages\FluentAssertions.4.0.0\lib\net45\FluentAssertions.Core.dll</HintPath>
+      <Private>True</Private>
     </Reference>
-    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Runtime.Serialization" />
@@ -86,6 +87,7 @@
     <Compile Include="Helpers\SwitchCulture.cs" />
     <Compile Include="ExchangeRateTests.cs" />
     <Compile Include="CurrencyTests.cs" />
+    <Compile Include="CurrencyBuilderTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\NodaMoney.Serialization.AspNet\NodaMoney.Serialization.AspNet.csproj">
@@ -98,7 +100,9 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <None Include="packages.config" />
+    <None Include="packages.config">
+      <SubType>Designer</SubType>
+    </None>
   </ItemGroup>
   <Choose>
     <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
diff --git a/NodaMoney.UnitTests/packages.config b/NodaMoney.UnitTests/packages.config
index 0e903e5..be07c5d 100644
--- a/NodaMoney.UnitTests/packages.config
+++ b/NodaMoney.UnitTests/packages.config
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="FluentAssertions" version="3.3.0" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="6.0.8" targetFramework="net45" />
+  <package id="FluentAssertions" version="4.0.0" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net46" />
 </packages>
\ No newline at end of file
diff --git a/NodaMoney.sln b/NodaMoney.sln
index 2aba772..fd325b4 100644
--- a/NodaMoney.sln
+++ b/NodaMoney.sln
@@ -1,16 +1,16 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.31101.0
+# Visual Studio 14
+VisualStudioVersion = 14.0.23107.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NodaMoney", "NodaMoney\NodaMoney.csproj", "{1814E8DE-0E75-4E23-9F70-E039AC816B42}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{96BD7E4A-8487-47D7-8459-814BA8288701}"
 	ProjectSection(SolutionItems) = preProject
 		appveyor.yml = appveyor.yml
-		CodeAnalysisDictionary.xml = CodeAnalysisDictionary.xml
 		Coding Guidelines.docx = Coding Guidelines.docx
 		CONTRIBUTING.md = CONTRIBUTING.md
+		CustomDictionary.xml = CustomDictionary.xml
 		NodaMoney\NodaMoney.nuspec = NodaMoney\NodaMoney.nuspec
 		NodaMoney.Serialization.AspNet\NodaMoney.Serialization.AspNet.nuspec = NodaMoney.Serialization.AspNet\NodaMoney.Serialization.AspNet.nuspec
 		NodaMoney.sln.DotSettings = NodaMoney.sln.DotSettings
diff --git a/NodaMoney.sln.DotSettings b/NodaMoney.sln.DotSettings
index 00ae606..a9e3904 100644
--- a/NodaMoney.sln.DotSettings
+++ b/NodaMoney.sln.DotSettings
@@ -1,4 +1,6 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/Highlighting/AnalysisEnabled/@EntryValue">SOLUTION</s:String>
+	<s:Boolean x:Key="/Default/CodeInspection/ImplicitNullability/Enabled/@EntryValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=Full_0020Cleanup_0020_0028no_0020file_0020header_0029/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="Full Cleanup (no file header)"&gt;&lt;CSArrangeQualifiers&gt;True&lt;/CSArrangeQualifiers&gt;&lt;CSOptimizeUsings&gt;&lt;OptimizeUsings&gt;True&lt;/OptimizeUsings&gt;&lt;EmbraceInRegion&gt;False&lt;/EmbraceInRegion&gt;&lt;RegionName&gt;&lt;/RegionName&gt;&lt;/CSOptimizeUsings&gt;&lt;CSReformatCode&gt;True&lt;/CSReformatCode&gt;&lt;CSReorderTypeMembers&gt;True&lt;/CSReorderTypeMembers&gt;&lt;StyleCop.Documentation&gt;&lt;SA1600ElementsMustBeDocumented&gt;False&lt;/SA1600ElementsMustBeDocumented&gt;&lt;SA1604ElementDocumentationMustHaveSummary&gt;True&lt;/SA1604ElementDocumentationMustHaveSummary&gt;&lt;SA1609PropertyDocumentationMustHaveValueDocumented&gt;True&lt;/SA1609PropertyDocumentationMustHaveValueDocumented&gt;&lt;SA1611ElementParametersMustBeDocumented&gt;True&lt;/SA1611ElementParametersMustBeDocumented&gt;&lt;SA1615ElementReturnValueMustBeDocumented&gt;True&lt;/SA1615ElementReturnValueMustBeDocumented&gt;&lt;SA1617VoidReturnValueMustNotBeDocumented&gt;True&lt;/SA1617VoidReturnValueMustNotBeDocumented&gt;&lt;SA1618GenericTypeParametersMustBeDocumented&gt;True&lt;/SA1618GenericTypeParametersMustBeDocumented&gt;&lt;SA1626SingleLineCommentsMustNotUseDocumentationStyleSlashes&gt;True&lt;/SA1626SingleLineCommentsMustNotUseDocumentationStyleSlashes&gt;&lt;SA1628DocumentationTextMustBeginWithACapitalLetter&gt;True&lt;/SA1628DocumentationTextMustBeginWithACapitalLetter&gt;&lt;SA1629DocumentationTextMustEndWithAPeriod&gt;True&lt;/SA1629DocumentationTextMustEndWithAPeriod&gt;&lt;SA1633SA1641UpdateFileHeader&gt;False&lt;/SA1633SA1641UpdateFileHeader&gt;&lt;SA1639FileHeaderMustHaveSummary&gt;False&lt;/SA1639FileHeaderMustHaveSummary&gt;&lt;SA1642ConstructorSummaryDocumentationMustBeginWithStandardText&gt;True&lt;/SA1642ConstructorSummaryDocumentationMustBeginWithStandardText&gt;&lt;SA1643DestructorSummaryDocumentationMustBeginWithStandardText&gt;True&lt;/SA1643DestructorSummaryDocumentationMustBeginWithStandardText&gt;&lt;SA1644DocumentationHeadersMustNotContainBlankLines&gt;True&lt;/SA1644DocumentationHeadersMustNotContainBlankLines&gt;&lt;/StyleCop.Documentation&gt;&lt;CssReformatCode&gt;True&lt;/CssReformatCode&gt;&lt;XMLReformatCode&gt;True&lt;/XMLReformatCode&gt;&lt;VBOptimizeImports&gt;True&lt;/VBOptimizeImports&gt;&lt;VBShortenReferences&gt;True&lt;/VBShortenReferences&gt;&lt;VBReformatCode&gt;True&lt;/VBReformatCode&gt;&lt;VBFormatDocComments&gt;True&lt;/VBFormatDocComments&gt;&lt;RemoveCodeRedundancies&gt;True&lt;/RemoveCodeRedundancies&gt;&lt;CSUseAutoProperty&gt;True&lt;/CSUseAutoProperty&gt;&lt;CSMakeFieldReadonly&gt;True&lt;/CSMakeFieldReadonly&gt;&lt;CSShortenReferences&gt;True&lt;/CSShortenReferences&gt;&lt;CSharpFormatDocComments&gt;True&lt;/CSharpFormatDocComments&gt;&lt;AspOptimizeRegisterDirectives&gt;True&lt;/AspOptimizeRegisterDirectives&gt;&lt;HtmlReformatCode&gt;True&lt;/HtmlReformatCode&gt;&lt;FormatAttributeQuoteDescriptor&gt;True&lt;/FormatAttributeQuoteDescriptor&gt;&lt;JsReformatCode&gt;True&lt;/JsReformatCode&gt;&lt;JsFormatDocComments&gt;True&lt;/JsFormatDocComments&gt;&lt;JsInsertSemicolon&gt;True&lt;/JsInsertSemicolon&gt;&lt;RemoveRedundantQualifiersTs&gt;True&lt;/RemoveRedundantQualifiersTs&gt;&lt;OptimizeImportsTs&gt;True&lt;/OptimizeImportsTs&gt;&lt;OptimizeReferenceCommentsTs&gt;True&lt;/OptimizeReferenceCommentsTs&gt;&lt;PublicModifierStyleTs&gt;True&lt;/PublicModifierStyleTs&gt;&lt;RelativePathStyleTs&gt;True&lt;/RelativePathStyleTs&gt;&lt;TypeAnnotationStyleTs&gt;True&lt;/TypeAnnotationStyleTs&gt;&lt;ExplicitAnyTs&gt;True&lt;/ExplicitAnyTs&gt;&lt;CssAlphabetizeProperties&gt;True&lt;/CssAlphabetizeProperties&gt;&lt;/Profile&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=StyleCop/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="StyleCop"&gt;&lt;CSArrangeQualifiers&gt;True&lt;/CSArrangeQualifiers&gt;&lt;CSOptimizeUsings&gt;&lt;OptimizeUsings&gt;True&lt;/OptimizeUsings&gt;&lt;EmbraceInRegion&gt;False&lt;/EmbraceInRegion&gt;&lt;RegionName&gt;&lt;/RegionName&gt;&lt;/CSOptimizeUsings&gt;&lt;CSReformatCode&gt;True&lt;/CSReformatCode&gt;&lt;CSReorderTypeMembers&gt;True&lt;/CSReorderTypeMembers&gt;&lt;StyleCop.Documentation&gt;&lt;SA1600ElementsMustBeDocumented&gt;False&lt;/SA1600ElementsMustBeDocumented&gt;&lt;SA1604ElementDocumentationMustHaveSummary&gt;True&lt;/SA1604ElementDocumentationMustHaveSummary&gt;&lt;SA1609PropertyDocumentationMustHaveValueDocumented&gt;True&lt;/SA1609PropertyDocumentationMustHaveValueDocumented&gt;&lt;SA1611ElementParametersMustBeDocumented&gt;True&lt;/SA1611ElementParametersMustBeDocumented&gt;&lt;SA1615ElementReturnValueMustBeDocumented&gt;True&lt;/SA1615ElementReturnValueMustBeDocumented&gt;&lt;SA1617VoidReturnValueMustNotBeDocumented&gt;True&lt;/SA1617VoidReturnValueMustNotBeDocumented&gt;&lt;SA1618GenericTypeParametersMustBeDocumented&gt;True&lt;/SA1618GenericTypeParametersMustBeDocumented&gt;&lt;SA1626SingleLineCommentsMustNotUseDocumentationStyleSlashes&gt;True&lt;/SA1626SingleLineCommentsMustNotUseDocumentationStyleSlashes&gt;&lt;SA1628DocumentationTextMustBeginWithACapitalLetter&gt;True&lt;/SA1628DocumentationTextMustBeginWithACapitalLetter&gt;&lt;SA1629DocumentationTextMustEndWithAPeriod&gt;True&lt;/SA1629DocumentationTextMustEndWithAPeriod&gt;&lt;SA1633SA1641UpdateFileHeader&gt;False&lt;/SA1633SA1641UpdateFileHeader&gt;&lt;SA1639FileHeaderMustHaveSummary&gt;False&lt;/SA1639FileHeaderMustHaveSummary&gt;&lt;SA1642ConstructorSummaryDocumentationMustBeginWithStandardText&gt;True&lt;/SA1642ConstructorSummaryDocumentationMustBeginWithStandardText&gt;&lt;SA1643DestructorSummaryDocumentationMustBeginWithStandardText&gt;True&lt;/SA1643DestructorSummaryDocumentationMustBeginWithStandardText&gt;&lt;SA1644DocumentationHeadersMustNotContainBlankLines&gt;True&lt;/SA1644DocumentationHeadersMustNotContainBlankLines&gt;&lt;/StyleCop.Documentation&gt;&lt;StyleCop.Layout&gt;&lt;SA1500CurlyBracketsForMultiLineStatementsMustNotShareLine&gt;True&lt;/SA1500CurlyBracketsForMultiLineStatementsMustNotShareLine&gt;&lt;SA1509OpeningCurlyBracketsMustNotBePrecededByBlankLine&gt;True&lt;/SA1509OpeningCurlyBracketsMustNotBePrecededByBlankLine&gt;&lt;SA1510ChainedStatementBlocksMustNotBePrecededByBlankLine&gt;True&lt;/SA1510ChainedStatementBlocksMustNotBePrecededByBlankLine&gt;&lt;SA1511WhileDoFooterMustNotBePrecededByBlankLine&gt;True&lt;/SA1511WhileDoFooterMustNotBePrecededByBlankLine&gt;&lt;SA1512SingleLineCommentsMustNotBeFollowedByBlankLine&gt;True&lt;/SA1512SingleLineCommentsMustNotBeFollowedByBlankLine&gt;&lt;SA1513ClosingCurlyBracketMustBeFollowedByBlankLine&gt;True&lt;/SA1513ClosingCurlyBracketMustBeFollowedByBlankLine&gt;&lt;SA1514ElementDocumentationHeaderMustBePrecededByBlankLine&gt;True&lt;/SA1514ElementDocumentationHeaderMustBePrecededByBlankLine&gt;&lt;SA1515SingleLineCommentMustBeProceededByBlankLine&gt;True&lt;/SA1515SingleLineCommentMustBeProceededByBlankLine&gt;&lt;/StyleCop.Layout&gt;&lt;StyleCop.Maintainability&gt;&lt;SA1119StatementMustNotUseUnnecessaryParenthesis&gt;True&lt;/SA1119StatementMustNotUseUnnecessaryParenthesis&gt;&lt;/StyleCop.Maintainability&gt;&lt;StyleCop.Ordering&gt;&lt;ExpandUsingDirectives&gt;True&lt;/ExpandUsingDirectives&gt;&lt;SA1212PropertyAccessorsMustFollowOrder&gt;True&lt;/SA1212PropertyAccessorsMustFollowOrder&gt;&lt;SA1213EventAccessorsMustFollowOrder&gt;True&lt;/SA1213EventAccessorsMustFollowOrder&gt;&lt;/StyleCop.Ordering&gt;&lt;StyleCop.Readability&gt;&lt;SA1100DoNotPrefixCallsWithBaseUnlessLocalImplementationExists&gt;True&lt;/SA1100DoNotPrefixCallsWithBaseUnlessLocalImplementationExists&gt;&lt;SA1106CodeMustNotContainEmptyStatements&gt;True&lt;/SA1106CodeMustNotContainEmptyStatements&gt;&lt;SA1108BlockStatementsMustNotContainEmbeddedComments&gt;True&lt;/SA1108BlockStatementsMustNotContainEmbeddedComments&gt;&lt;SA1109BlockStatementsMustNotContainEmbeddedRegions&gt;True&lt;/SA1109BlockStatementsMustNotContainEmbeddedRegions&gt;&lt;SA1120CommentsMustContainText&gt;True&lt;/SA1120CommentsMustContainText&gt;&lt;SA1121UseBuiltInTypeAlias&gt;True&lt;/SA1121UseBuiltInTypeAlias&gt;&lt;SA1122UseStringEmptyForEmptyStrings&gt;True&lt;/SA1122UseStringEmptyForEmptyStrings&gt;&lt;SA1123DoNotPlaceRegionsWithinElements&gt;True&lt;/SA1123DoNotPlaceRegionsWithinElements&gt;&lt;SA1124CodeMustNotContainEmptyRegions&gt;True&lt;/SA1124CodeMustNotContainEmptyRegions&gt;&lt;/StyleCop.Readability&gt;&lt;StyleCop.Spacing&gt;&lt;SA1001CommasMustBeSpacedCorrectly&gt;True&lt;/SA1001CommasMustBeSpacedCorrectly&gt;&lt;SA1005SingleLineCommentsMustBeginWithSingleSpace&gt;True&lt;/SA1005SingleLineCommentsMustBeginWithSingleSpace&gt;&lt;SA1006PreprocessorKeywordsMustNotBePrecededBySpace&gt;True&lt;/SA1006PreprocessorKeywordsMustNotBePrecededBySpace&gt;&lt;SA1021NegativeSignsMustBeSpacedCorrectly&gt;True&lt;/SA1021NegativeSignsMustBeSpacedCorrectly&gt;&lt;SA1022PositiveSignsMustBeSpacedCorrectly&gt;True&lt;/SA1022PositiveSignsMustBeSpacedCorrectly&gt;&lt;SA1025CodeMustNotContainMultipleWhitespaceInARow&gt;True&lt;/SA1025CodeMustNotContainMultipleWhitespaceInARow&gt;&lt;/StyleCop.Spacing&gt;&lt;/Profile&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/SilentCleanupProfile/@EntryValue">StyleCop</s:String>
diff --git a/NodaMoney/Currency.cs b/NodaMoney/Currency.cs
index 2a033a7..1f1718d 100644
--- a/NodaMoney/Currency.cs
+++ b/NodaMoney/Currency.cs
@@ -3,7 +3,6 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
-using System.Linq;
 using System.Runtime.Serialization;
 using System.Xml;
 using System.Xml.Schema;
@@ -17,64 +16,61 @@ namespace NodaMoney
     [DebuggerDisplay("{Code}")]
     public struct Currency : IEquatable<Currency>, IXmlSerializable
     {
-        // The Malagasy ariary and the Mauritanian ouguiya are technically divided into five subunits (the iraimbilanja and
-        // khoum respectively), rather than by a power of ten. The coins display "1/5" on their face and are referred to as
-        // a "fifth" (Khoum/cinquième). These are not used in practice, but when written out, a single significant digit is
-        // used. E.g. 1.2 UM.
-        // To represent this in decimal we do the following steps: 5 is 10 to the power of log(5) = 0.69897... ~ 0.7
-        internal const double Z07 = 0.69897000433601880478626110527551; // Math.Log10(5);
-        internal const double DOT = -1;
-        private static readonly Dictionary<string, Currency> Currencies = InitializeIsoCurrencies();
+        internal static readonly CurrencyRegistry Registry = new CurrencyRegistry();
 
         /// <summary>Initializes a new instance of the <see cref="Currency"/> struct.</summary>
         /// <param name="code">The code.</param>
         /// <param name="number">The number.</param>
         /// <param name="decimalDigits">The decimal digits.</param>
         /// <param name="englishName">Name of the english.</param>
-        /// <param name="sign">The sign.</param>
-        /// <exception cref="System.ArgumentNullException">code or number or englishName or sign is null</exception>
-        /// <exception cref="System.ArgumentOutOfRangeException">DecimalDigits of code must be between -1 and 3!</exception>
-        internal Currency(string code, string number, double decimalDigits, string englishName, string sign)
+        /// <param name="symbol">The currency symbol.</param>
+        /// <param name="namespace">The namespace of the currency.</param>
+        /// <param name="isObsolete">Value indicating whether currency is obsolete.</param>
+        /// <exception cref="System.ArgumentNullException">code or number or englishName or symbol is null</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">DecimalDigits of code must be between -1 and 4!</exception>
+        internal Currency(string code, string number, double decimalDigits, string englishName, string symbol, string @namespace = "ISO-4217", bool isObsolete = false)
             : this()
         {
             if (string.IsNullOrWhiteSpace(code))
-                throw new ArgumentNullException("code");
+                throw new ArgumentNullException(nameof(code));
             if (string.IsNullOrWhiteSpace(number))
-                throw new ArgumentNullException("number");
+                throw new ArgumentNullException(nameof(number));
             if (string.IsNullOrWhiteSpace(englishName)) 
-                throw new ArgumentNullException("englishName");
-            if (string.IsNullOrWhiteSpace(sign)) 
-                throw new ArgumentNullException("sign");
-            if (decimalDigits < -1 || decimalDigits > 4)
-                throw new ArgumentOutOfRangeException("code", "DecimalDigits must be between -1 and 4!");
+                throw new ArgumentNullException(nameof(englishName));
+            if (string.IsNullOrWhiteSpace(symbol)) 
+                throw new ArgumentNullException(nameof(symbol));
+            if (decimalDigits < 0 && decimalDigits != CurrencyRegistry.NotApplicable)
+                throw new ArgumentOutOfRangeException(nameof(code), "DecimalDigits must greater or equal to 0!");
 
             Code = code;
             Number = number;
             DecimalDigits = decimalDigits;
             EnglishName = englishName;
-            Sign = sign;
+            Symbol = symbol;
+            IsObsolete = isObsolete;
+            Namespace = @namespace;
         }
 
         /// <summary>Gets the Currency that represents the country/region used by the current thread.</summary>
         /// <value>The Currency that represents the country/region used by the current thread.</value>
-        public static Currency CurrentCurrency
-        {
-            get { return Currency.FromRegion(RegionInfo.CurrentRegion); }
-        }   
+        public static Currency CurrentCurrency => FromRegion(RegionInfo.CurrentRegion);
 
-        /// <summary>Gets the currency sign.</summary>
-        public string Sign { get; private set; }
+        /// <summary>Gets the currency symbol.</summary>
+        public string Symbol { get; private set; }
 
         /// <summary>Gets the english name of the currency.</summary>
         public string EnglishName { get; private set; }
 
-        /// <summary>Gets the three-character ISO 4217 currency code.</summary>
+        /// <summary>Gets the three-character ISO-4217 currency code.</summary>
         [DataMember]
         public string Code { get; private set; }
 
-        /// <summary>Gets the numeric ISO 4217 currency code.</summary>
+        /// <summary>Gets the numeric ISO-4217 currency code.</summary>
         public string Number { get; private set; }
 
+        /// <summary>Gets the namespace of the currency.</summary>
+        public string Namespace { get; private set; }
+
         /// <summary>Gets the number of digits after the decimal separator.</summary>
         /// <remarks>
         /// <para>
@@ -93,25 +89,34 @@ public static Currency CurrentCurrency
         /// </remarks>
         public double DecimalDigits { get; private set; }
 
+        /// <summary>Gets or sets the date when the currency is valid from.</summary>
+        /// <value>The from date when the currency is valid.</value>
+        public DateTime? ValidFrom { get; internal set; }
+
+        /// <summary>Gets or sets the date when the currency is valid to.</summary>
+        /// <value>The to date when the currency is valid.</value>
+        public DateTime? ValidTo { get; internal set; }
+
         /// <summary>Gets the major currency unit.</summary>
         [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Member of Currency type!")]
-        public decimal MajorUnit
-        {
-            get { return 1; }
-        }
+        public decimal MajorUnit => 1;
 
         /// <summary>Gets the minor currency unit.</summary>
         public decimal MinorUnit
         {
             get 
             {
-                if (DecimalDigits == DOT)
+                if (DecimalDigits == CurrencyRegistry.NotApplicable)
                     return MajorUnit;
 
                 return new decimal(1 / Math.Pow(10, DecimalDigits));
             }
         }
 
+        /// <summary>Gets a value indicating whether currency is obsolete.</summary>
+        /// <value><c>true</c> if this instance is obsolete; otherwise, <c>false</c>.</value>
+        public bool IsObsolete { get; private set; }
+
         /// <summary>Create an instance of the <see cref="Currency"/>, based on a ISO 4217 currency code.</summary>
         /// <param name="code">A ISO 4217 currency code, like EUR or USD.</param>
         /// <returns>An instance of the type <see cref="Currency"/>.</returns>
@@ -119,35 +124,55 @@ public decimal MinorUnit
         /// <exception cref="ArgumentException">The 'code' is an unknown ISO 4217 currency code!</exception>
         public static Currency FromCode(string code)
         {
-            if (string.IsNullOrWhiteSpace(code)) 
-                throw new ArgumentNullException("code");
-            if (!Currencies.ContainsKey(code.ToUpperInvariant())) 
-                throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "{0} is an unknown ISO 4217 currency code!", code));
+            Currency currency;
+            if (!Registry.TryGet(code, out currency))
+                throw new ArgumentException($"{code} is an unknown currency code!");
 
-            return Currencies[code.ToUpperInvariant()];
+            return currency;
+
+            // return FromCode(code, "ISO-4217");            
+        }
+
+        /// <summary>Create an instance of the <see cref="Currency"/> of the given code and namespace.</summary>
+        /// <param name="code">A currency code, like EUR or USD.</param>
+        /// <param name="namespace">A namespace, like ISO-4217.</param>
+        /// <returns>An instance of the type <see cref="Currency"/>.</returns>
+        /// <exception cref="ArgumentNullException">The value of 'code' or 'namespace' cannot be null or empty.</exception>
+        /// <exception cref="ArgumentException">The 'code' in the given namespace is an unknown!</exception>
+        public static Currency FromCode(string code, string @namespace)
+        {
+            Currency currency;
+            if (!Registry.TryGet(code, @namespace, out currency))           
+                throw new ArgumentException($"{code} is an unknown {@namespace} currency code!");
+
+            return currency;
         }
 
         /// <summary>Creates an instance of the <see cref="Currency"/> used within the specified <see cref="RegionInfo"/>.</summary>
         /// <param name="region"><see cref="RegionInfo"/> to get a <see cref="Currency"/> for.</param>
         /// <returns>The <see cref="Currency"/> instance used within the specified <see cref="RegionInfo"/>.</returns>
         /// <exception cref="ArgumentNullException">The value of 'region' cannot be null.</exception>
+        /// <exception cref="ArgumentException">The 'code' is an unknown ISO 4217 currency code!</exception>
         public static Currency FromRegion(RegionInfo region)
         {
             if (region == null) 
-                throw new ArgumentNullException("region");
+                throw new ArgumentNullException(nameof(region));
 
-            return FromCode(region.ISOCurrencySymbol);
+            return FromCode(region.ISOCurrencySymbol, "ISO-4217");
         }
 
         /// <summary>Creates an instance of the <see cref="Currency"/> used within the specified <see cref="CultureInfo"/>.</summary>
         /// <param name="culture"><see cref="CultureInfo"/> to get a <see cref="Currency"/> for.</param>
         /// <returns>The <see cref="Currency"/> instance used within the specified <see cref="CultureInfo"/>.</returns>
         /// <exception cref="ArgumentNullException">The value of 'culture' cannot be null.</exception>
-        /// <exception cref="ArgumentException">Culture is a neutral culture, from which no region information can be extracted!</exception>
+        /// <exception cref="ArgumentException">
+        /// Culture is a neutral culture, from which no region information can be extracted -or-
+        /// The 'code' is an unknown ISO 4217 currency code!
+        /// </exception>
         public static Currency FromCulture(CultureInfo culture)
         {
             if (culture == null) 
-                throw new ArgumentNullException("culture");
+                throw new ArgumentNullException(nameof(culture));
             if (culture.IsNeutralCulture) 
                 throw new ArgumentException("Culture {0} is a neutral culture, from which no region information can be extracted!", culture.Name);
             
@@ -167,17 +192,16 @@ public static Currency FromCulture(CultureInfo culture)
         public static Currency FromRegion(string name)
         {
             if (string.IsNullOrWhiteSpace(name)) 
-                throw new ArgumentNullException("name");            
+                throw new ArgumentNullException(nameof(name));            
 
             return FromRegion(new RegionInfo(name));
         }
 
         /// <summary>Get all currencies.</summary>
-        /// <returns>An array that contains all the ISO 4217 currencies. The array of currencies is unsorted.</returns>
-        public static Currency[] GetAllCurrencies()
+        /// <returns>An <see cref="IEnumerable{Currency}"/> of all registered currencies.</returns>
+        public static IEnumerable<Currency> GetAllCurrencies()
         {
-            // TODO: IQueryable?
-            return Currencies.Values.ToArray();
+            return Registry.GetAllCurrencies();
         }
 
         /// <summary>Implements the operator ==.</summary>
@@ -264,9 +288,9 @@ public XmlSchema GetSchema()
         public void ReadXml(XmlReader reader)
         {
             if (reader == null)
-                throw new ArgumentNullException("reader");
+                throw new ArgumentNullException(nameof(reader));
 
-            this = Currency.FromCode(reader["Currency"]);
+            this = FromCode(reader["Currency"]);
         }
 
         /// <summary>
@@ -277,200 +301,9 @@ public void ReadXml(XmlReader reader)
         public void WriteXml(XmlWriter writer)
         {
             if (writer == null)
-                throw new ArgumentNullException("writer");
+                throw new ArgumentNullException(nameof(writer));
 
             writer.WriteAttributeString("Currency", Code);
         }
-
-        private static Dictionary<string, Currency> InitializeIsoCurrencies()
-        {
-            var currencies = new Dictionary<string, Currency>
-                                 {
-                                     { "AED", new Currency("AED", "784", 2, "United Arab Emirates dirham", "د.إ") },
-                                     { "AFN", new Currency("AFN", "971", 2, "Afghan afghani", "؋") },
-                                     { "ALL", new Currency("ALL", "008", 2, "Albanian lek", "Lek") },
-                                     { "AMD", new Currency("AMD", "051", 2, "Armenian dram", "֏") },
-                                     { "ANG", new Currency("ANG", "532", 2, "Netherlands Antillean guilder", "ƒ") },
-                                     { "AOA", new Currency("AOA", "973", 2, "Angolan kwanza", "Kz") },
-                                     { "ARS", new Currency("ARS", "032", 2, "Argentine peso", "$") },
-                                     { "AUD", new Currency("AUD", "036", 2, "Australian dollar", "$") },
-                                     { "AWG", new Currency("AWG", "533", 2, "Aruban florin", "ƒ") },
-                                     { "AZN", new Currency("AZN", "944", 2, "Azerbaijani manat", "ман") },
-                                     { "BAM", new Currency("BAM", "977", 2, "Bosnia and Herzegovina convertible mark", "KM") },
-                                     { "BBD", new Currency("BBD", "052", 2, "Barbados dollar", "$") },
-                                     { "BDT", new Currency("BDT", "050", 2, "Bangladeshi taka", "৳") }, // or Tk
-                                     { "BGN", new Currency("BGN", "975", 2, "Bulgarian lev", "лв") },
-                                     { "BHD", new Currency("BHD", "048", 3, "Bahraini dinar", "BD") }, // or د.ب. (switched for unit tests to work)
-                                     { "BIF", new Currency("BIF", "108", 0, "Burundian franc", "FBu") },
-                                     { "BMD", new Currency("BMD", "060", 2, "Bermudian dollar", "$") },
-                                     { "BND", new Currency("BND", "096", 2, "Brunei dollar", "$") }, // or B$
-                                     { "BOB", new Currency("BOB", "068", 2, "Boliviano", "Bs.") }, // or BS or $b
-                                     { "BOV", new Currency("BOV", "984", 2, "Bolivian Mvdol (funds code)", "¤") }, // <==== not found
-                                     { "BRL", new Currency("BRL", "986", 2, "Brazilian real", "R$") },
-                                     { "BSD", new Currency("BSD", "044", 2, "Bahamian dollar", "$") },
-                                     { "BTN", new Currency("BTN", "064", 2, "Bhutanese ngultrum", "Nu.") },
-                                     { "BWP", new Currency("BWP", "072", 2, "Botswana pula", "P") },
-                                     { "BYR", new Currency("BYR", "974", 0, "Belarusian ruble", "Br") }, // or p.? wiki controdicts with xe.com
-                                     { "BZD", new Currency("BZD", "084", 2, "Belize dollar", "BZ$") },
-                                     { "CAD", new Currency("CAD", "124", 2, "Canadian dollar", "$") },
-                                     { "CDF", new Currency("CDF", "976", 2, "Congolese franc", "FC") },
-                                     { "CHE", new Currency("CHE", "947", 2, "WIR Euro (complementary currency)", "CHE") },
-                                     { "CHF", new Currency("CHF", "756", 2, "Swiss franc", "fr.") }, // or CHF
-                                     { "CHW", new Currency("CHW", "948", 2, "WIR Franc (complementary currency)", "CHW") },
-                                     { "CLF", new Currency("CLF", "990", 4, "Unidad de Fomento (funds code)", "CLF") },
-                                     { "CLP", new Currency("CLP", "152", 0, "Chilean peso", "$") },
-                                     { "CNY", new Currency("CNY", "156", 2, "Chinese yuan", "¥") },
-                                     { "COP", new Currency("COP", "170", 2, "Colombian peso", "$") },
-                                     { "COU", new Currency("COU", "970", 2, "Unidad de Valor Real", "¤") }, // ???
-                                     { "CRC", new Currency("CRC", "188", 2, "Costa Rican colon", "₡") },
-                                     { "CUC", new Currency("CUC", "931", 2, "Cuban convertible peso", "CUC$") }, // $ or CUC
-                                     { "CUP", new Currency("CUP", "192", 2, "Cuban peso", "$") }, // or ₱ (obsolete?)
-                                     { "CVE", new Currency("CVE", "132", 0, "Cape Verde escudo", "$") },
-                                     { "CZK", new Currency("CZK", "203", 2, "Czech koruna", "Kč") },
-                                     { "DJF", new Currency("DJF", "262", 0, "Djiboutian franc", "Fdj") },
-                                     { "DKK", new Currency("DKK", "208", 2, "Danish krone", "kr") },
-                                     { "DOP", new Currency("DOP", "214", 2, "Dominican peso", "RD$") }, // or $
-                                     { "DZD", new Currency("DZD", "012", 2, "Algerian dinar", "DA") }, // (Latin) or د.ج (Arabic)
-                                     { "EGP", new Currency("EGP", "818", 2, "Egyptian pound", "LE") }, // or E£ or ج.م (Arabic)
-                                     { "ERN", new Currency("ERN", "232", 2, "Eritrean nakfa", "ERN") },
-                                     { "ETB", new Currency("ETB", "230", 2, "Ethiopian birr", "Br") }, // (Latin) or ብር (Ethiopic)
-                                     { "EUR", new Currency("EUR", "978", 2, "Euro", "€") },
-                                     { "FJD", new Currency("FJD", "242", 2, "Fiji dollar", "$") }, // or FJ$
-                                     { "FKP", new Currency("FKP", "238", 2, "Falkland Islands pound", "£") },
-                                     { "GBP", new Currency("GBP", "826", 2, "Pound sterling", "£") },
-                                     { "GEL", new Currency("GEL", "981", 2, "Georgian lari", "ლ.") }, // TODO: new sign since July 18, 2014 => see http://en.wikipedia.org/wiki/Georgian_lari
-                                     { "GHS", new Currency("GHS", "936", 2, "Ghanaian cedi", "GH¢") }, // or GH₵
-                                     { "GIP", new Currency("GIP", "292", 2, "Gibraltar pound", "£") },
-                                     { "GMD", new Currency("GMD", "270", 2, "Gambian dalasi", "D") },
-                                     { "GNF", new Currency("GNF", "324", 0, "Guinean franc", "FG") }, // (possibly also Fr or GFr)
-                                     { "GTQ", new Currency("GTQ", "320", 2, "Guatemalan quetzal", "Q") },
-                                     { "GYD", new Currency("GYD", "328", 2, "Guyanese dollar", "$") }, // or G$
-                                     { "HKD", new Currency("HKD", "344", 2, "Hong Kong dollar", "HK$") }, // or $
-                                     { "HNL", new Currency("HNL", "340", 2, "Honduran lempira", "L") },
-                                     { "HRK", new Currency("HRK", "191", 2, "Croatian kuna", "kn") },
-                                     { "HTG", new Currency("HTG", "332", 2, "Haitian gourde", "G") },
-                                     { "HUF", new Currency("HUF", "348", 2, "Hungarian forint", "Ft") },
-                                     { "IDR", new Currency("IDR", "360", 2, "Indonesian rupiah", "Rp") },
-                                     { "ILS", new Currency("ILS", "376", 2, "Israeli new shekel", "₪") },
-                                     { "INR", new Currency("INR", "356", 2, "Indian rupee", "₹") },
-                                     { "IQD", new Currency("IQD", "368", 3, "Iraqi dinar", "د.ع") },
-                                     { "IRR", new Currency("IRR", "364", 0, "Iranian rial", "ريال") },
-                                     { "ISK", new Currency("ISK", "352", 0, "Icelandic króna", "kr") },
-                                     { "JMD", new Currency("JMD", "388", 2, "Jamaican dollar", "J$") }, // or $
-                                     { "JOD", new Currency("JOD", "400", 3, "Jordanian dinar", "د.ا.‏") },
-                                     { "JPY", new Currency("JPY", "392", 0, "Japanese yen", "¥") },
-                                     { "KES", new Currency("KES", "404", 2, "Kenyan shilling", "KSh") },
-                                     { "KGS", new Currency("KGS", "417", 2, "Kyrgyzstani som", "сом") },
-                                     { "KHR", new Currency("KHR", "116", 2, "Cambodian riel", "៛") },
-                                     { "KMF", new Currency("KMF", "174", 0, "Comoro franc", "CF") },
-                                     { "KPW", new Currency("KPW", "408", 0, "North Korean won", "₩") },
-                                     { "KRW", new Currency("KRW", "410", 0, "South Korean won", "₩") },
-                                     { "KWD", new Currency("KWD", "414", 3, "Kuwaiti dinar", "د.ك") }, // or K.D.
-                                     { "KYD", new Currency("KYD", "136", 2, "Cayman Islands dollar", "$") },
-                                     { "KZT", new Currency("KZT", "398", 2, "Kazakhstani tenge", "₸") },
-                                     { "LAK", new Currency("LAK", "418", 0, "Lao kip", "₭") }, // or ₭N
-                                     { "LBP", new Currency("LBP", "422", 0, "Lebanese pound", "ل.ل") },
-                                     { "LKR", new Currency("LKR", "144", 2, "Sri Lankan rupee", "Rs") }, // or රු
-                                     { "LRD", new Currency("LRD", "430", 2, "Liberian dollar", "$") }, // or L$, LD$
-                                     { "LSL", new Currency("LSL", "426", 2, "Lesotho loti", "L") }, // L or M (pl.)
-                                     // { "LTL", new Currency("LTL", "440", 2, "Lithuanian litas", "Lt") }, // Until 2014-12-31, replaced by EUR
-                                     // { "LVL", new Currency("LVL", "428", 2, "Latvian lats", "Ls") }, // Until 2014-01-15, replaced by EUR
-                                     { "LYD", new Currency("LYD", "434", 3, "Libyan dinar", "ل.د") }, // or LD
-                                     { "MAD", new Currency("MAD", "504", 2, "Moroccan dirham", "د.م.") },
-                                     { "MDL", new Currency("MDL", "498", 2, "Moldovan leu", "L") },
-                                     { "MGA", new Currency("MGA", "969", Z07, "Malagasy ariary", "Ar") },  // divided into five subunits rather than by a power of ten. 5 is 10 to the power of 0.69897...
-                                     { "MKD", new Currency("MKD", "807", 0, "Macedonian denar", "ден") },
-                                     { "MMK", new Currency("MMK", "104", 0, "Myanma kyat", "K") },
-                                     { "MNT", new Currency("MNT", "496", 2, "Mongolian tugrik", "₮") },
-                                     { "MOP", new Currency("MOP", "446", 2, "Macanese pataca", "MOP$") },
-                                     { "MRO", new Currency("MRO", "478", Z07, "Mauritanian ouguiya", "UM") }, // divided into five subunits rather than by a power of ten. 5 is 10 to the power of 0.69897...
-                                     { "MUR", new Currency("MUR", "480", 2, "Mauritian rupee", "Rs") },
-                                     { "MVR", new Currency("MVR", "462", 2, "Maldivian rufiyaa", "Rf") }, // or , MRf, MVR, .ރ or /-
-                                     { "MWK", new Currency("MWK", "454", 2, "Malawian kwacha", "MK") },
-                                     { "MXN", new Currency("MXN", "484", 2, "Mexican peso", "$") },
-                                     { "MXV", new Currency("MXV", "979", 2, "Mexican Unidad de Inversion (UDI) (funds code)", "¤") },  // <==== not found
-                                     { "MYR", new Currency("MYR", "458", 2, "Malaysian ringgit", "RM") },
-                                     { "MZN", new Currency("MZN", "943", 2, "Mozambican metical", "MTn") }, // or MTN
-                                     { "NAD", new Currency("NAD", "516", 2, "Namibian dollar", "N$") }, // or $
-                                     { "NGN", new Currency("NGN", "566", 2, "Nigerian naira", "₦") },
-                                     { "NIO", new Currency("NIO", "558", 2, "Nicaraguan córdoba", "C$") },
-                                     { "NOK", new Currency("NOK", "578", 2, "Norwegian krone", "kr") },
-                                     { "NPR", new Currency("NPR", "524", 2, "Nepalese rupee", "Rs") }, // or ₨ or रू
-                                     { "NZD", new Currency("NZD", "554", 2, "New Zealand dollar", "$") },
-                                     { "OMR", new Currency("OMR", "512", 3, "Omani rial", "ر.ع.") },
-                                     { "PAB", new Currency("PAB", "590", 2, "Panamanian balboa", "B/.") },
-                                     { "PEN", new Currency("PEN", "604", 2, "Peruvian nuevo sol", "S/.") },
-                                     { "PGK", new Currency("PGK", "598", 2, "Papua New Guinean kina", "K") },
-                                     { "PHP", new Currency("PHP", "608", 2, "Philippine peso", "₱") }, // or P or PHP or PhP
-                                     { "PKR", new Currency("PKR", "586", 2, "Pakistani rupee", "Rs") }, 
-                                     { "PLN", new Currency("PLN", "985", 2, "Polish złoty", "zł") },
-                                     { "PYG", new Currency("PYG", "600", 0, "Paraguayan guaraní", "₲") },
-                                     { "QAR", new Currency("QAR", "634", 2, "Qatari riyal", "ر.ق") }, // or QR
-                                     { "RON", new Currency("RON", "946", 2, "Romanian new leu", "lei") },
-                                     { "RSD", new Currency("RSD", "941", 2, "Serbian dinar", "РСД") }, // or RSD (or дин. or din. ?)
-                                     { "RUB", new Currency("RUB", "643", 2, "Russian rouble", "₽") }, // or R or руб (both onofficial)
-                                     { "RWF", new Currency("RWF", "646", 0, "Rwandan franc", "RFw") }, // or RF, R₣
-                                     { "SAR", new Currency("SAR", "682", 2, "Saudi riyal", "ر.س") }, // or SR (Latin) or ﷼‎ (Unicode)
-                                     { "SBD", new Currency("SBD", "090", 2, "Solomon Islands dollar", "SI$") },
-                                     { "SCR", new Currency("SCR", "690", 2, "Seychelles rupee", "SR") }, // or SRe
-                                     { "SDG", new Currency("SDG", "938", 2, "Sudanese pound", "ج.س.") },
-                                     { "SEK", new Currency("SEK", "752", 2, "Swedish krona/kronor", "kr") },
-                                     { "SGD", new Currency("SGD", "702", 2, "Singapore dollar", "S$") }, // or $
-                                     { "SHP", new Currency("SHP", "654", 2, "Saint Helena pound", "£") },
-                                     { "SLL", new Currency("SLL", "694", 0, "Sierra Leonean leone", "Le") },
-                                     { "SOS", new Currency("SOS", "706", 2, "Somali shilling", "S") }, // or Sh.So.
-                                     { "SRD", new Currency("SRD", "968", 2, "Surinamese dollar", "$") },
-                                     { "SSP", new Currency("SSP", "728", 2, "South Sudanese pound", "£") }, // not sure about sign...
-                                     { "STD", new Currency("STD", "678", 0, "São Tomé and Príncipe dobra", "Db") },
-                                     { "SYP", new Currency("SYP", "760", 2, "Syrian pound", "ܠ.ܣ.‏") }, // or LS or £S (or £)
-                                     { "SZL", new Currency("SZL", "748", 2, "Swazi lilangeni", "L") }, // or E (plural)
-                                     { "THB", new Currency("THB", "764", 2, "Thai baht", "฿") },
-                                     { "TJS", new Currency("TJS", "972", 2, "Tajikistani somoni", "смн") },
-                                     { "TMT", new Currency("TMT", "934", 2, "Turkmenistani manat", "m") }, // or T?
-                                     { "TND", new Currency("TND", "788", 3, "Tunisian dinar", "د.ت") }, // or DT (Latin)
-                                     { "TOP", new Currency("TOP", "776", 2, "Tongan paʻanga", "T$") }, // (sometimes PT)
-                                     { "TRY", new Currency("TRY", "949", 2, "Turkish lira", "₺") },
-                                     { "TTD", new Currency("TTD", "780", 2, "Trinidad and Tobago dollar", "$") }, // or TT$
-                                     { "TWD", new Currency("TWD", "901", 2, "New Taiwan dollar", "NT$") }, // or $
-                                     { "TZS", new Currency("TZS", "834", 2, "Tanzanian shilling", "x/y") }, // or TSh
-                                     { "UAH", new Currency("UAH", "980", 2, "Ukrainian hryvnia", "₴") },
-                                     { "UGX", new Currency("UGX", "800", 2, "Ugandan shilling", "USh") },
-                                     { "USD", new Currency("USD", "840", 2, "United States dollar", "$") }, // or US$
-                                     { "USN", new Currency("USN", "997", 2, "United States dollar (next day) (funds code)", "$") },
-                                     { "USS", new Currency("USS", "998", 2, "United States dollar (same day) (funds code)", "$") },
-                                     { "UYI", new Currency("UYI", "940", 0, "Uruguay Peso en Unidades Indexadas (URUIURUI) (funds code)", "¤") },
-                                     { "UYU", new Currency("UYU", "858", 2, "Uruguayan peso", "$") }, // or $U
-                                     { "UZS", new Currency("UZS", "860", 2, "Uzbekistan som", "лв") }, // or сўм ?
-                                     { "VEF", new Currency("VEF", "937", 2, "Venezuelan bolívar fuerte", "Bs.F.") }, // or Bs.
-                                     { "VND", new Currency("VND", "704", 0, "Vietnamese dong", "₫") },
-                                     { "VUV", new Currency("VUV", "548", 0, "Vanuatu vatu", "VT") },
-                                     { "WST", new Currency("WST", "882", 2, "Samoan tala", "WS$") }, // sometimes SAT, ST or T
-                                     { "XAF", new Currency("XAF", "950", 0, "CFA franc BEAC", "FCFA") },
-                                     { "XAG", new Currency("XAG", "961", DOT, "Silver (one troy ounce)", "¤") },
-                                     { "XAU", new Currency("XAU", "959", DOT, "Gold (one troy ounce)", "¤") },
-                                     { "XBA", new Currency("XBA", "955", DOT, "European Composite Unit (EURCO) (bond market unit)", "¤") },
-                                     { "XBB", new Currency("XBB", "956", DOT, "European Monetary Unit (E.M.U.-6) (bond market unit)", "¤") },
-                                     { "XBC", new Currency("XBC", "957", DOT, "European Unit of Account 9 (E.U.A.-9) (bond market unit)", "¤") },
-                                     { "XBD", new Currency("XBD", "958", DOT, "European Unit of Account 17 (E.U.A.-17) (bond market unit)", "¤") },
-                                     { "XCD", new Currency("XCD", "951", 2, "East Caribbean dollar", "$") }, // or EC$
-                                     { "XDR", new Currency("XDR", "960", DOT, "Special drawing rights", "¤") },
-                                     { "XFU", new Currency("XFU", "Nil", DOT, "UIC franc (special settlement currency)", "¤") },
-                                     { "XOF", new Currency("XOF", "952", 0, "CFA franc BCEAO", "CFA") },
-                                     { "XPD", new Currency("XPD", "964", DOT, "Palladium (one troy ounce)", "¤") },
-                                     { "XPF", new Currency("XPF", "953", 0, "CFP franc", "F") },
-                                     { "XPT", new Currency("XPT", "962", DOT, "Platinum (one troy ounce)", "¤") },
-                                     { "XSU", new Currency("XSU", "994", DOT, "SUCRE", "¤") },
-                                     { "XTS", new Currency("XTS", "963", DOT, "Code reserved for testing purposes", "¤") },
-                                     { "XUA", new Currency("XUA", "965", DOT, "ADB Unit of Account", "¤") },
-                                     { "XXX", new Currency("XXX", "999", DOT, "No currency", "¤") },
-                                     { "YER", new Currency("YER", "886", 2, "Yemeni rial", "﷼") }, // or ر.ي.‏‏ ?
-                                     { "ZAR", new Currency("ZAR", "710", 2, "South African rand", "R") },
-                                     { "ZMW", new Currency("ZMW", "967", 2, "Zambian kwacha", "ZK") }, // or ZMW
-                                     // { "ZMK", new Currency("ZMK", "894", 2, "Zambian kwacha", "ZK") }  // Until 2013-01-01, replaced by ZWM
-                                     { "ZWL", new Currency("ZWL", "932", 2, "Zimbabwean dollar", "$") } // or Z$ (official currency of Zimbabwe from 1980 to 12 April 2009, not used anymore)
-                                 }; 
-
-            return currencies;
-        }
     }
 }
\ No newline at end of file
diff --git a/NodaMoney/CurrencyBuilder.cs b/NodaMoney/CurrencyBuilder.cs
new file mode 100644
index 0000000..0ec6b8b
--- /dev/null
+++ b/NodaMoney/CurrencyBuilder.cs
@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace NodaMoney
+{
+    /// <summary>Defines a custom currency that is new or based on another currency.</summary>
+    public class CurrencyBuilder
+    {
+        /// <summary>Initializes a new instance of the <see cref="CurrencyBuilder"/> class.</summary>
+        /// <param name="code">The code of the currency, normally the three-character ISO 4217 currency code.</param>
+        /// <param name="namespace">The namespace for the currency.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="code"/> or <paramref name="namespace"/> is <see langword="null" /> or empty.</exception>
+        public CurrencyBuilder(string code, string @namespace)
+        {            
+            if (string.IsNullOrWhiteSpace(code))
+                throw new ArgumentNullException(nameof(code));
+            if (string.IsNullOrWhiteSpace(@namespace))
+                throw new ArgumentNullException(nameof(@namespace));
+
+            Code = code;
+            Namespace = @namespace;
+        }
+
+        /// <summary>Gets or sets the english name of the currency.</summary>
+        public string EnglishName { get; set; }
+
+        /// <summary>Gets or sets the currency sign.</summary>
+        public string Symbol { get; set; }
+
+        /// <summary>Gets or sets the numeric ISO 4217 currency code.</summary>
+        // ReSharper disable once InconsistentNaming
+        public string ISONumber { get; set; }
+
+        /// <summary>Gets or sets the number of digits after the decimal separator.</summary>
+        public double DecimalDigits { get; set; }
+
+        /// <summary>Gets the namespace of the currency.</summary>
+        public string Namespace { get; }
+
+        /// <summary>Gets the code of the currency, normally a three-character ISO 4217 currency code.</summary>
+        public string Code { get; }
+
+        /// <summary>Gets or sets a value indicating whether currency is obsolete.</summary>
+        /// <value><c>true</c> if this instance is obsolete; otherwise, <c>false</c>.</value>
+        public bool IsObsolete { get; set; }
+
+        /// <summary>Gets or sets the date when the currency is valid from.</summary>
+        /// <value>The from date when the currency is valid.</value>
+        public DateTime? ValidFrom { get; set; }
+
+        /// <summary>Gets or sets the date when the currency is valid to.</summary>
+        /// <value>The to date when the currency is valid.</value>
+        public DateTime? ValidTo { get; set; }
+
+        /// <summary>Reconstitutes a <see cref="CurrencyBuilder"/> object from a specified XML file that contains a
+        /// representation of the object.</summary>
+        /// <param name="xmlFileName">A file name that contains the XML representation of a <see cref="CurrencyBuilder"/> object.</param>
+        /// <returns>A new object that is equivalent to the information stored in the <i>xmlFileName</i> parameter.</returns>
+        public static CurrencyBuilder CreateFromLdml(string xmlFileName)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>Unregisters the specified currency code from the current AppDomain and returns it.</summary>
+        /// <param name="code">The name of the currency to unregister.</param>
+        /// <param name="namespace">The namespace of the currency to unregister from.</param>
+        /// <returns>An instance of the type <see cref="Currency"/>.</returns>
+        /// <exception cref="ArgumentException">code specifies a currency that is not found in the given namespace.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="code" /> or <paramref name="namespace" /> is <see langword="null" /> or empty.</exception>
+        public static Currency Unregister(string code, string @namespace)
+        {
+            if (string.IsNullOrWhiteSpace(code))
+                throw new ArgumentNullException(nameof(code));
+            if (string.IsNullOrWhiteSpace(@namespace))
+                throw new ArgumentNullException(nameof(@namespace));
+
+            Currency currency;
+            if (!Currency.Registry.TryRemove(code, @namespace, out currency))
+                throw new ArgumentException($"code {code} specifies a currency that is not found in the namespace {@namespace}!");
+
+            return currency;
+        }
+
+        /// <summary>Builds the current <see cref="CurrencyBuilder"/> object as a custom currency.</summary>
+        /// <returns>A <see cref="Currency"/> instance.</returns>
+        //// <exception cref="InvalidOperationException">The current CurrencyBuilder object has a property that must be set before the currency can be registered.</exception>
+        public Currency Build()
+        {
+            // TODO: Add validation?
+            // throw new InvalidOperationException("The current CurrencyBuilder object has a property that must be set before the currency can be registered.");
+            var currency = new Currency(Code, ISONumber, DecimalDigits, EnglishName, Symbol, Namespace, IsObsolete);
+            currency.ValidFrom = ValidFrom;
+            currency.ValidTo = ValidTo;            
+
+            return currency;
+        }
+
+        /// <summary>Registers the current <see cref="CurrencyBuilder"/> object as a custom currency for the current AppDomain.</summary>
+        /// <exception cref="InvalidOperationException">
+        ///     <para>The custom currency is already registered</para>
+        ///     <para>-or-</para>
+        ///     <para>The current CurrencyBuilder object has a property that must be set before the currency can be registered.</para>
+        /// </exception>
+        public Currency Register()
+        {
+            Currency currency = Build();
+            if (!Currency.Registry.TryAdd(Code, Namespace, currency))
+                throw new InvalidOperationException("The custom currency is already registered.");
+
+            return currency;
+        }
+
+        /// <summary>Writes an XML representation of the current <see cref="CurrencyBuilder"/> object to the specified file.</summary>
+        /// <param name="fileName">The name of a file to contain the XML representation of this custom currency.</param>
+        /// <remarks>
+        ///     <para>
+        ///     The Save method writes the current <see cref="CurrencyBuilder"/> object to the file specified by the
+        ///     filename parameter in an XML format called Locale Data Markup Language (LDML) version 1.1.
+        ///     The <see cref="CreateFromLdml"/> method performs the reverse operation of the Save method.
+        ///     </para>
+        ///     <para>
+        ///     For information about the format of an LDML file, see the CreateFromLdml method. For information about the LDML
+        ///     standard, see <see href='http://go.microsoft.com/fwlink/p/?LinkId=252840'>Unicode Technical Standard #35, "Locale
+        ///     Data Markup Language (LDML)"</see> on the Unicode Consortium website.
+        ///     </para>
+        /// </remarks>
+        public void Save(string fileName)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>Sets the properties of the current <see cref="CurrencyBuilder"/> object with the corresponding properties of
+        /// the specified <see cref="Currency"/> object, except for the code and namespace.</summary>
+        /// <param name="currency">The object whose properties will be used.</param>
+        public void LoadDataFromCurrency(Currency currency)
+        {
+            EnglishName = currency.EnglishName;
+            Symbol = currency.Symbol;
+            ISONumber = currency.Number;
+            DecimalDigits = currency.DecimalDigits;
+            IsObsolete = currency.IsObsolete;
+            ValidFrom = currency.ValidFrom;
+            ValidTo = currency.ValidTo;
+        }
+    }
+}
\ No newline at end of file
diff --git a/NodaMoney/CurrencyRegistry.cs b/NodaMoney/CurrencyRegistry.cs
new file mode 100644
index 0000000..a7e1f3d
--- /dev/null
+++ b/NodaMoney/CurrencyRegistry.cs
@@ -0,0 +1,304 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace NodaMoney
+{
+    /// <summary>Represent the central thread-safe registry for currencies.</summary>
+    internal class CurrencyRegistry
+    {
+        // The Malagasy ariary and the Mauritanian ouguiya are technically divided into five subunits (the iraimbilanja and
+        // khoum respectively), rather than by a power of ten. The coins display "1/5" on their face and are referred to as
+        // a "fifth" (Khoum/cinquième). These are not used in practice, but when written out, a single significant digit is
+        // used. E.g. 1.2 UM.
+        // To represent this in decimal we do the following steps: 5 is 10 to the power of log(5) = 0.69897... ~ 0.7
+        internal const double Z07 = 0.69897000433601880478626110527551; // Math.Log10(5);
+        internal const double NotApplicable = -1;
+        private static readonly ConcurrentDictionary<string, Currency> Currencies = new ConcurrentDictionary<string, Currency>(InitializeIsoCurrencies());
+        private static readonly ConcurrentDictionary<string, byte> Namespaces = new ConcurrentDictionary<string, byte>(new Dictionary<string, byte> { ["ISO-4217"] = default(byte) });
+
+        /// <summary>Tries the get <see cref="Currency"/> of the given code and namespace.</summary>
+        /// <param name="code">A currency code, like EUR or USD.</param>
+        /// <param name="currency">When this method returns, contains the <see cref="Currency"/> that has the specified code, or the default value of the type if the operation failed.</param>
+        /// <returns>An instance of the type <see cref="Currency"/>.</returns>
+        /// <exception cref="System.ArgumentNullException">The value of 'code' cannot be null or empty.</exception>
+        public bool TryGet(string code, out Currency currency)
+        {
+            if (string.IsNullOrWhiteSpace(code))
+                throw new ArgumentNullException(nameof(code));
+
+            var found = new List<Currency>();
+            foreach (var ns in Namespaces.Keys)
+            {
+                Currency c;
+                if (Currencies.TryGetValue(ns + "::" + code, out c))
+                {
+                    found.Add(c);
+                }
+            }
+
+            if (found.Count == 0)
+            {
+                currency = default(Currency);
+                return false;
+            }
+
+            currency = found[0]; // TODO: If more than one, sort by prio. 
+            return true;
+        }
+
+        /// <summary>Tries the get <see cref="Currency"/> of the given code and namespace.</summary>
+        /// <param name="code">A currency code, like EUR or USD.</param>
+        /// <param name="namespace">A namespace, like ISO-4217.</param>
+        /// <param name="currency">When this method returns, contains the <see cref="Currency"/> that has the specified code and namespace, or the default value of the type if the operation failed.</param>
+        /// <returns>An instance of the type <see cref="Currency"/>.</returns>
+        /// <exception cref="System.ArgumentNullException">The value of 'code' or 'namespace' cannot be null or empty.</exception>
+        public bool TryGet(string code, string @namespace, out Currency currency)
+        {
+            if (string.IsNullOrWhiteSpace(code))
+                throw new ArgumentNullException(nameof(code));
+            if (string.IsNullOrWhiteSpace(@namespace))
+                throw new ArgumentNullException(nameof(@namespace));
+
+            return Currencies.TryGetValue(@namespace + "::" + code, out currency); // don't use string.Format(), string concat much faster in this case!
+        }
+
+        /// <summary>Attempts to remove and return the <see cref="Currency"/> of the given code and namespace.</summary>
+        /// <param name="code">A currency code, like EUR or USD.</param>
+        /// <param name="namespace">A namespace, like ISO-4217.</param>
+        /// <param name="currency">When this method returns, contains the <see cref="Currency"/> that has the specified code and namespace, or the default value of the type if the operation failed.</param>
+        /// <returns>An instance of the type <see cref="Currency"/>.</returns>
+        /// <exception cref="System.ArgumentNullException">The value of 'code' or 'namespace' cannot be null or empty.</exception>
+        public bool TryAdd(string code, string @namespace, Currency currency)
+        {
+            if (string.IsNullOrWhiteSpace(code))
+                throw new ArgumentNullException(nameof(code));
+            if (string.IsNullOrWhiteSpace(@namespace))
+                throw new ArgumentNullException(nameof(@namespace));
+
+            Namespaces.TryAdd(@namespace, default(byte));
+
+            return Currencies.TryAdd(@namespace + "::" + code, currency);
+        }
+
+        /// <summary>Attempts to remove and return the <see cref="Currency"/> of the given code and namespace.</summary>
+        /// <param name="code">A currency code, like EUR or USD.</param>
+        /// <param name="namespace">A namespace, like ISO-4217.</param>
+        /// <param name="currency">When this method returns, contains the <see cref="Currency"/> that has the specified code and namespace, or the default value of the type if the operation failed.</param>
+        /// <returns>An instance of the type <see cref="Currency"/>.</returns>
+        /// <exception cref="System.ArgumentNullException">The value of 'code' or 'namespace' cannot be null or empty.</exception>
+        public bool TryRemove(string code, string @namespace, out Currency currency)
+        {
+            if (string.IsNullOrWhiteSpace(code))
+                throw new ArgumentNullException(nameof(code));
+            if (string.IsNullOrWhiteSpace(@namespace))
+                throw new ArgumentNullException(nameof(@namespace));
+
+            byte outValue; // temp variable, we don't care about
+            Namespaces.TryRemove(@namespace, out outValue);
+            return Currencies.TryRemove(@namespace + "::" + code, out currency);
+        }
+
+        /// <summary>Get all registered currencies.</summary>
+        /// <returns>An <see cref="IEnumerable{Currency}"/> of all registered currencies.</returns>
+        public IEnumerable<Currency> GetAllCurrencies()
+        {
+            return Currencies.Values.AsEnumerable();
+        }
+
+        private static IDictionary<string, Currency> InitializeIsoCurrencies()
+        {
+            // TODO: Move to resource file.
+            var currencies = new Dictionary<string, Currency>
+                                 {
+                                     { "ISO-4217::AED", new Currency("AED", "784", 2, "United Arab Emirates dirham", "د.إ") },
+                                     { "ISO-4217::AFN", new Currency("AFN", "971", 2, "Afghan afghani", "؋") },
+                                     { "ISO-4217::ALL", new Currency("ALL", "008", 2, "Albanian lek", "Lek") },
+                                     { "ISO-4217::AMD", new Currency("AMD", "051", 2, "Armenian dram", "֏") },
+                                     { "ISO-4217::ANG", new Currency("ANG", "532", 2, "Netherlands Antillean guilder", "ƒ") },
+                                     { "ISO-4217::AOA", new Currency("AOA", "973", 2, "Angolan kwanza", "Kz") },
+                                     { "ISO-4217::ARS", new Currency("ARS", "032", 2, "Argentine peso", "$") },
+                                     { "ISO-4217::AUD", new Currency("AUD", "036", 2, "Australian dollar", "$") },
+                                     { "ISO-4217::AWG", new Currency("AWG", "533", 2, "Aruban florin", "ƒ") },
+                                     { "ISO-4217::AZN", new Currency("AZN", "944", 2, "Azerbaijani manat", "ман") },
+                                     { "ISO-4217::BAM", new Currency("BAM", "977", 2, "Bosnia and Herzegovina convertible mark", "KM") },
+                                     { "ISO-4217::BBD", new Currency("BBD", "052", 2, "Barbados dollar", "$") },
+                                     { "ISO-4217::BDT", new Currency("BDT", "050", 2, "Bangladeshi taka", "৳") }, // or Tk
+                                     { "ISO-4217::BGN", new Currency("BGN", "975", 2, "Bulgarian lev", "лв") },
+                                     { "ISO-4217::BHD", new Currency("BHD", "048", 3, "Bahraini dinar", "BD") }, // or د.ب. (switched for unit tests to work)
+                                     { "ISO-4217::BIF", new Currency("BIF", "108", 0, "Burundian franc", "FBu") },
+                                     { "ISO-4217::BMD", new Currency("BMD", "060", 2, "Bermudian dollar", "$") },
+                                     { "ISO-4217::BND", new Currency("BND", "096", 2, "Brunei dollar", "$") }, // or B$
+                                     { "ISO-4217::BOB", new Currency("BOB", "068", 2, "Boliviano", "Bs.") }, // or BS or $b
+                                     { "ISO-4217::BOV", new Currency("BOV", "984", 2, "Bolivian Mvdol (funds code)", "¤") }, // <==== not found
+                                     { "ISO-4217::BRL", new Currency("BRL", "986", 2, "Brazilian real", "R$") },
+                                     { "ISO-4217::BSD", new Currency("BSD", "044", 2, "Bahamian dollar", "$") },
+                                     { "ISO-4217::BTN", new Currency("BTN", "064", 2, "Bhutanese ngultrum", "Nu.") },
+                                     { "ISO-4217::BWP", new Currency("BWP", "072", 2, "Botswana pula", "P") },
+                                     { "ISO-4217::BYR", new Currency("BYR", "974", 0, "Belarusian ruble", "Br") }, // or p.? wiki controdicts with xe.com
+                                     { "ISO-4217::BZD", new Currency("BZD", "084", 2, "Belize dollar", "BZ$") },
+                                     { "ISO-4217::CAD", new Currency("CAD", "124", 2, "Canadian dollar", "$") },
+                                     { "ISO-4217::CDF", new Currency("CDF", "976", 2, "Congolese franc", "FC") },
+                                     { "ISO-4217::CHE", new Currency("CHE", "947", 2, "WIR Euro (complementary currency)", "CHE") },
+                                     { "ISO-4217::CHF", new Currency("CHF", "756", 2, "Swiss franc", "fr.") }, // or CHF
+                                     { "ISO-4217::CHW", new Currency("CHW", "948", 2, "WIR Franc (complementary currency)", "CHW") },
+                                     { "ISO-4217::CLF", new Currency("CLF", "990", 4, "Unidad de Fomento (funds code)", "CLF") },
+                                     { "ISO-4217::CLP", new Currency("CLP", "152", 0, "Chilean peso", "$") },
+                                     { "ISO-4217::CNY", new Currency("CNY", "156", 2, "Chinese yuan", "¥") },
+                                     { "ISO-4217::COP", new Currency("COP", "170", 2, "Colombian peso", "$") },
+                                     { "ISO-4217::COU", new Currency("COU", "970", 2, "Unidad de Valor Real", "¤") }, // ???
+                                     { "ISO-4217::CRC", new Currency("CRC", "188", 2, "Costa Rican colon", "₡") },
+                                     { "ISO-4217::CUC", new Currency("CUC", "931", 2, "Cuban convertible peso", "CUC$") }, // $ or CUC
+                                     { "ISO-4217::CUP", new Currency("CUP", "192", 2, "Cuban peso", "$") }, // or ₱ (obsolete?)
+                                     { "ISO-4217::CVE", new Currency("CVE", "132", 0, "Cape Verde escudo", "$") },
+                                     { "ISO-4217::CZK", new Currency("CZK", "203", 2, "Czech koruna", "Kč") },
+                                     { "ISO-4217::DJF", new Currency("DJF", "262", 0, "Djiboutian franc", "Fdj") },
+                                     { "ISO-4217::DKK", new Currency("DKK", "208", 2, "Danish krone", "kr") },
+                                     { "ISO-4217::DOP", new Currency("DOP", "214", 2, "Dominican peso", "RD$") }, // or $
+                                     { "ISO-4217::DZD", new Currency("DZD", "012", 2, "Algerian dinar", "DA") }, // (Latin) or د.ج (Arabic)
+                                     { "ISO-4217::EGP", new Currency("EGP", "818", 2, "Egyptian pound", "LE") }, // or E£ or ج.م (Arabic)
+                                     { "ISO-4217::ERN", new Currency("ERN", "232", 2, "Eritrean nakfa", "ERN") },
+                                     { "ISO-4217::ETB", new Currency("ETB", "230", 2, "Ethiopian birr", "Br") }, // (Latin) or ብር (Ethiopic)
+                                     { "ISO-4217::EUR", new Currency("EUR", "978", 2, "Euro", "€") },
+                                     { "ISO-4217::FJD", new Currency("FJD", "242", 2, "Fiji dollar", "$") }, // or FJ$
+                                     { "ISO-4217::FKP", new Currency("FKP", "238", 2, "Falkland Islands pound", "£") },
+                                     { "ISO-4217::GBP", new Currency("GBP", "826", 2, "Pound sterling", "£") },
+                                     { "ISO-4217::GEL", new Currency("GEL", "981", 2, "Georgian lari", "ლ.") }, // TODO: new symbol since July 18, 2014 => see http://en.wikipedia.org/wiki/Georgian_lari
+                                     { "ISO-4217::GHS", new Currency("GHS", "936", 2, "Ghanaian cedi", "GH¢") }, // or GH₵
+                                     { "ISO-4217::GIP", new Currency("GIP", "292", 2, "Gibraltar pound", "£") },
+                                     { "ISO-4217::GMD", new Currency("GMD", "270", 2, "Gambian dalasi", "D") },
+                                     { "ISO-4217::GNF", new Currency("GNF", "324", 0, "Guinean franc", "FG") }, // (possibly also Fr or GFr)
+                                     { "ISO-4217::GTQ", new Currency("GTQ", "320", 2, "Guatemalan quetzal", "Q") },
+                                     { "ISO-4217::GYD", new Currency("GYD", "328", 2, "Guyanese dollar", "$") }, // or G$
+                                     { "ISO-4217::HKD", new Currency("HKD", "344", 2, "Hong Kong dollar", "HK$") }, // or $
+                                     { "ISO-4217::HNL", new Currency("HNL", "340", 2, "Honduran lempira", "L") },
+                                     { "ISO-4217::HRK", new Currency("HRK", "191", 2, "Croatian kuna", "kn") },
+                                     { "ISO-4217::HTG", new Currency("HTG", "332", 2, "Haitian gourde", "G") },
+                                     { "ISO-4217::HUF", new Currency("HUF", "348", 2, "Hungarian forint", "Ft") },
+                                     { "ISO-4217::IDR", new Currency("IDR", "360", 2, "Indonesian rupiah", "Rp") },
+                                     { "ISO-4217::ILS", new Currency("ILS", "376", 2, "Israeli new shekel", "₪") },
+                                     { "ISO-4217::INR", new Currency("INR", "356", 2, "Indian rupee", "₹") },
+                                     { "ISO-4217::IQD", new Currency("IQD", "368", 3, "Iraqi dinar", "د.ع") },
+                                     { "ISO-4217::IRR", new Currency("IRR", "364", 0, "Iranian rial", "ريال") },
+                                     { "ISO-4217::ISK", new Currency("ISK", "352", 0, "Icelandic króna", "kr") },
+                                     { "ISO-4217::JMD", new Currency("JMD", "388", 2, "Jamaican dollar", "J$") }, // or $
+                                     { "ISO-4217::JOD", new Currency("JOD", "400", 3, "Jordanian dinar", "د.ا.‏") },
+                                     { "ISO-4217::JPY", new Currency("JPY", "392", 0, "Japanese yen", "¥") },
+                                     { "ISO-4217::KES", new Currency("KES", "404", 2, "Kenyan shilling", "KSh") },
+                                     { "ISO-4217::KGS", new Currency("KGS", "417", 2, "Kyrgyzstani som", "сом") },
+                                     { "ISO-4217::KHR", new Currency("KHR", "116", 2, "Cambodian riel", "៛") },
+                                     { "ISO-4217::KMF", new Currency("KMF", "174", 0, "Comoro franc", "CF") },
+                                     { "ISO-4217::KPW", new Currency("KPW", "408", 0, "North Korean won", "₩") },
+                                     { "ISO-4217::KRW", new Currency("KRW", "410", 0, "South Korean won", "₩") },
+                                     { "ISO-4217::KWD", new Currency("KWD", "414", 3, "Kuwaiti dinar", "د.ك") }, // or K.D.
+                                     { "ISO-4217::KYD", new Currency("KYD", "136", 2, "Cayman Islands dollar", "$") },
+                                     { "ISO-4217::KZT", new Currency("KZT", "398", 2, "Kazakhstani tenge", "₸") },
+                                     { "ISO-4217::LAK", new Currency("LAK", "418", 0, "Lao kip", "₭") }, // or ₭N
+                                     { "ISO-4217::LBP", new Currency("LBP", "422", 0, "Lebanese pound", "ل.ل") },
+                                     { "ISO-4217::LKR", new Currency("LKR", "144", 2, "Sri Lankan rupee", "Rs") }, // or රු
+                                     { "ISO-4217::LRD", new Currency("LRD", "430", 2, "Liberian dollar", "$") }, // or L$, LD$
+                                     { "ISO-4217::LSL", new Currency("LSL", "426", 2, "Lesotho loti", "L") }, // L or M (pl.)
+                                     { "ISO-4217::LYD", new Currency("LYD", "434", 3, "Libyan dinar", "ل.د") }, // or LD
+                                     { "ISO-4217::MAD", new Currency("MAD", "504", 2, "Moroccan dirham", "د.م.") },
+                                     { "ISO-4217::MDL", new Currency("MDL", "498", 2, "Moldovan leu", "L") },
+                                     { "ISO-4217::MGA", new Currency("MGA", "969", Z07, "Malagasy ariary", "Ar") },  // divided into five subunits rather than by a power of ten. 5 is 10 to the power of 0.69897...
+                                     { "ISO-4217::MKD", new Currency("MKD", "807", 0, "Macedonian denar", "ден") },
+                                     { "ISO-4217::MMK", new Currency("MMK", "104", 0, "Myanma kyat", "K") },
+                                     { "ISO-4217::MNT", new Currency("MNT", "496", 2, "Mongolian tugrik", "₮") },
+                                     { "ISO-4217::MOP", new Currency("MOP", "446", 2, "Macanese pataca", "MOP$") },
+                                     { "ISO-4217::MRO", new Currency("MRO", "478", Z07, "Mauritanian ouguiya", "UM") }, // divided into five subunits rather than by a power of ten. 5 is 10 to the power of 0.69897...
+                                     { "ISO-4217::MUR", new Currency("MUR", "480", 2, "Mauritian rupee", "Rs") },
+                                     { "ISO-4217::MVR", new Currency("MVR", "462", 2, "Maldivian rufiyaa", "Rf") }, // or , MRf, MVR, .ރ or /-
+                                     { "ISO-4217::MWK", new Currency("MWK", "454", 2, "Malawian kwacha", "MK") },
+                                     { "ISO-4217::MXN", new Currency("MXN", "484", 2, "Mexican peso", "$") },
+                                     { "ISO-4217::MXV", new Currency("MXV", "979", 2, "Mexican Unidad de Inversion (UDI) (funds code)", "¤") },  // <==== not found
+                                     { "ISO-4217::MYR", new Currency("MYR", "458", 2, "Malaysian ringgit", "RM") },
+                                     { "ISO-4217::MZN", new Currency("MZN", "943", 2, "Mozambican metical", "MTn") }, // or MTN
+                                     { "ISO-4217::NAD", new Currency("NAD", "516", 2, "Namibian dollar", "N$") }, // or $
+                                     { "ISO-4217::NGN", new Currency("NGN", "566", 2, "Nigerian naira", "₦") },
+                                     { "ISO-4217::NIO", new Currency("NIO", "558", 2, "Nicaraguan córdoba", "C$") },
+                                     { "ISO-4217::NOK", new Currency("NOK", "578", 2, "Norwegian krone", "kr") },
+                                     { "ISO-4217::NPR", new Currency("NPR", "524", 2, "Nepalese rupee", "Rs") }, // or ₨ or रू
+                                     { "ISO-4217::NZD", new Currency("NZD", "554", 2, "New Zealand dollar", "$") },
+                                     { "ISO-4217::OMR", new Currency("OMR", "512", 3, "Omani rial", "ر.ع.") },
+                                     { "ISO-4217::PAB", new Currency("PAB", "590", 2, "Panamanian balboa", "B/.") },
+                                     { "ISO-4217::PEN", new Currency("PEN", "604", 2, "Peruvian nuevo sol", "S/.") },
+                                     { "ISO-4217::PGK", new Currency("PGK", "598", 2, "Papua New Guinean kina", "K") },
+                                     { "ISO-4217::PHP", new Currency("PHP", "608", 2, "Philippine peso", "₱") }, // or P or PHP or PhP
+                                     { "ISO-4217::PKR", new Currency("PKR", "586", 2, "Pakistani rupee", "Rs") },
+                                     { "ISO-4217::PLN", new Currency("PLN", "985", 2, "Polish złoty", "zł") },
+                                     { "ISO-4217::PYG", new Currency("PYG", "600", 0, "Paraguayan guaraní", "₲") },
+                                     { "ISO-4217::QAR", new Currency("QAR", "634", 2, "Qatari riyal", "ر.ق") }, // or QR
+                                     { "ISO-4217::RON", new Currency("RON", "946", 2, "Romanian new leu", "lei") },
+                                     { "ISO-4217::RSD", new Currency("RSD", "941", 2, "Serbian dinar", "РСД") }, // or RSD (or дин. or din. ?)
+                                     { "ISO-4217::RUB", new Currency("RUB", "643", 2, "Russian rouble", "₽") }, // or R or руб (both onofficial)
+                                     { "ISO-4217::RWF", new Currency("RWF", "646", 0, "Rwandan franc", "RFw") }, // or RF, R₣
+                                     { "ISO-4217::SAR", new Currency("SAR", "682", 2, "Saudi riyal", "ر.س") }, // or SR (Latin) or ﷼‎ (Unicode)
+                                     { "ISO-4217::SBD", new Currency("SBD", "090", 2, "Solomon Islands dollar", "SI$") },
+                                     { "ISO-4217::SCR", new Currency("SCR", "690", 2, "Seychelles rupee", "SR") }, // or SRe
+                                     { "ISO-4217::SDG", new Currency("SDG", "938", 2, "Sudanese pound", "ج.س.") },
+                                     { "ISO-4217::SEK", new Currency("SEK", "752", 2, "Swedish krona/kronor", "kr") },
+                                     { "ISO-4217::SGD", new Currency("SGD", "702", 2, "Singapore dollar", "S$") }, // or $
+                                     { "ISO-4217::SHP", new Currency("SHP", "654", 2, "Saint Helena pound", "£") },
+                                     { "ISO-4217::SLL", new Currency("SLL", "694", 0, "Sierra Leonean leone", "Le") },
+                                     { "ISO-4217::SOS", new Currency("SOS", "706", 2, "Somali shilling", "S") }, // or Sh.So.
+                                     { "ISO-4217::SRD", new Currency("SRD", "968", 2, "Surinamese dollar", "$") },
+                                     { "ISO-4217::SSP", new Currency("SSP", "728", 2, "South Sudanese pound", "£") }, // not sure about symbol...
+                                     { "ISO-4217::STD", new Currency("STD", "678", 0, "São Tomé and Príncipe dobra", "Db") },
+                                     { "ISO-4217::SYP", new Currency("SYP", "760", 2, "Syrian pound", "ܠ.ܣ.‏") }, // or LS or £S (or £)
+                                     { "ISO-4217::SZL", new Currency("SZL", "748", 2, "Swazi lilangeni", "L") }, // or E (plural)
+                                     { "ISO-4217::THB", new Currency("THB", "764", 2, "Thai baht", "฿") },
+                                     { "ISO-4217::TJS", new Currency("TJS", "972", 2, "Tajikistani somoni", "смн") },
+                                     { "ISO-4217::TMT", new Currency("TMT", "934", 2, "Turkmenistani manat", "m") }, // or T?
+                                     { "ISO-4217::TND", new Currency("TND", "788", 3, "Tunisian dinar", "د.ت") }, // or DT (Latin)
+                                     { "ISO-4217::TOP", new Currency("TOP", "776", 2, "Tongan paʻanga", "T$") }, // (sometimes PT)
+                                     { "ISO-4217::TRY", new Currency("TRY", "949", 2, "Turkish lira", "₺") },
+                                     { "ISO-4217::TTD", new Currency("TTD", "780", 2, "Trinidad and Tobago dollar", "$") }, // or TT$
+                                     { "ISO-4217::TWD", new Currency("TWD", "901", 2, "New Taiwan dollar", "NT$") }, // or $
+                                     { "ISO-4217::TZS", new Currency("TZS", "834", 2, "Tanzanian shilling", "x/y") }, // or TSh
+                                     { "ISO-4217::UAH", new Currency("UAH", "980", 2, "Ukrainian hryvnia", "₴") },
+                                     { "ISO-4217::UGX", new Currency("UGX", "800", 2, "Ugandan shilling", "USh") },
+                                     { "ISO-4217::USD", new Currency("USD", "840", 2, "United States dollar", "$") }, // or US$
+                                     { "ISO-4217::USN", new Currency("USN", "997", 2, "United States dollar (next day) (funds code)", "$") },
+                                     { "ISO-4217::USS", new Currency("USS", "998", 2, "United States dollar (same day) (funds code)", "$") },
+                                     { "ISO-4217::UYI", new Currency("UYI", "940", 0, "Uruguay Peso en Unidades Indexadas (URUIURUI) (funds code)", "¤") },
+                                     { "ISO-4217::UYU", new Currency("UYU", "858", 2, "Uruguayan peso", "$") }, // or $U
+                                     { "ISO-4217::UZS", new Currency("UZS", "860", 2, "Uzbekistan som", "лв") }, // or сўм ?
+                                     { "ISO-4217::VEF", new Currency("VEF", "937", 2, "Venezuelan bolívar fuerte", "Bs.F.") }, // or Bs.
+                                     { "ISO-4217::VND", new Currency("VND", "704", 0, "Vietnamese dong", "₫") },
+                                     { "ISO-4217::VUV", new Currency("VUV", "548", 0, "Vanuatu vatu", "VT") },
+                                     { "ISO-4217::WST", new Currency("WST", "882", 2, "Samoan tala", "WS$") }, // sometimes SAT, ST or T
+                                     { "ISO-4217::XAF", new Currency("XAF", "950", 0, "CFA franc BEAC", "FCFA") },
+                                     { "ISO-4217::XAG", new Currency("XAG", "961", NotApplicable, "Silver (one troy ounce)", "¤") },
+                                     { "ISO-4217::XAU", new Currency("XAU", "959", NotApplicable, "Gold (one troy ounce)", "¤") },
+                                     { "ISO-4217::XBA", new Currency("XBA", "955", NotApplicable, "European Composite Unit (EURCO) (bond market unit)", "¤") },
+                                     { "ISO-4217::XBB", new Currency("XBB", "956", NotApplicable, "European Monetary Unit (E.M.U.-6) (bond market unit)", "¤") },
+                                     { "ISO-4217::XBC", new Currency("XBC", "957", NotApplicable, "European Unit of Account 9 (E.U.A.-9) (bond market unit)", "¤") },
+                                     { "ISO-4217::XBD", new Currency("XBD", "958", NotApplicable, "European Unit of Account 17 (E.U.A.-17) (bond market unit)", "¤") },
+                                     { "ISO-4217::XCD", new Currency("XCD", "951", 2, "East Caribbean dollar", "$") }, // or EC$
+                                     { "ISO-4217::XDR", new Currency("XDR", "960", NotApplicable, "Special drawing rights", "¤") },
+                                     { "ISO-4217::XFU", new Currency("XFU", "Nil", NotApplicable, "UIC franc (special settlement currency)", "¤") },
+                                     { "ISO-4217::XOF", new Currency("XOF", "952", 0, "CFA franc BCEAO", "CFA") },
+                                     { "ISO-4217::XPD", new Currency("XPD", "964", NotApplicable, "Palladium (one troy ounce)", "¤") },
+                                     { "ISO-4217::XPF", new Currency("XPF", "953", 0, "CFP franc", "F") },
+                                     { "ISO-4217::XPT", new Currency("XPT", "962", NotApplicable, "Platinum (one troy ounce)", "¤") },
+                                     { "ISO-4217::XSU", new Currency("XSU", "994", NotApplicable, "SUCRE", "¤") },
+                                     { "ISO-4217::XTS", new Currency("XTS", "963", NotApplicable, "Code reserved for testing purposes", "¤") },
+                                     { "ISO-4217::XUA", new Currency("XUA", "965", NotApplicable, "ADB Unit of Account", "¤") },
+                                     { "ISO-4217::XXX", new Currency("XXX", "999", NotApplicable, "No currency", "¤") },
+                                     { "ISO-4217::YER", new Currency("YER", "886", 2, "Yemeni rial", "﷼") }, // or ر.ي.‏‏ ?
+                                     { "ISO-4217::ZAR", new Currency("ZAR", "710", 2, "South African rand", "R") },
+                                     { "ISO-4217::ZMW", new Currency("ZMW", "967", 2, "Zambian kwacha", "ZK") }, // or ZMW
+                                     { "ISO-4217::LTL", new Currency("LTL", "440", 2, "Lithuanian litas", "Lt", isObsolete: true) }, // Until 2014-12-31, replaced by EUR
+                                     { "ISO-4217::LVL", new Currency("LVL", "428", 2, "Latvian lats", "Ls", isObsolete: true) }, // Until 2014-01-15, replaced by EUR
+                                     { "ISO-4217::ZMK", new Currency("ZMK", "894", 2, "Zambian kwacha", "ZK", isObsolete: true) },  // Until 2013-01-01, replaced by ZWM
+                                     { "ISO-4217::ZWL", new Currency("ZWL", "932", 2, "Zimbabwean dollar", "$", isObsolete: true) }, // or Z$ (official currency of Zimbabwe from 1980 to 12 April 2009, not used anymore)
+                                     { "ISO-4217::EEK", new Currency("EEK", "233", 2, "Estonian kroon", "kr", isObsolete: true) },  // From 1992 Until 2010-12-31, replaced by EUR
+                                     { "ISO-4217::NLG", new Currency("NLG", "528", 2, "Dutch guilder", "ƒ", isObsolete: true)} // From 1810 to 1998-12-31
+                                 };
+
+            return currencies;
+        }
+    }
+}
diff --git a/NodaMoney/ExchangeRate.cs b/NodaMoney/ExchangeRate.cs
index 48b70c2..a19a6e8 100644
--- a/NodaMoney/ExchangeRate.cs
+++ b/NodaMoney/ExchangeRate.cs
@@ -20,11 +20,11 @@ public ExchangeRate(Currency baseCurrency, Currency quoteCurrency, decimal rate)
             : this()
         {
             if (baseCurrency == null)
-                throw new ArgumentNullException("baseCurrency");
+                throw new ArgumentNullException(nameof(baseCurrency));
             if (rate < 0)
-                throw new ArgumentOutOfRangeException("rate", "Rate must be greater than zero!");
+                throw new ArgumentOutOfRangeException(nameof(rate), "Rate must be greater than zero!");
             if (quoteCurrency == null)
-                throw new ArgumentNullException("quoteCurrency");
+                throw new ArgumentNullException(nameof(quoteCurrency));
             if (baseCurrency == quoteCurrency)
                 throw new ArgumentException("The base and quote currency can't be equal!");
 
@@ -102,7 +102,7 @@ public static bool TryParse(string rate, out ExchangeRate result)
             try
             {
                 if (string.IsNullOrWhiteSpace(rate))
-                    throw new ArgumentNullException("rate");
+                    throw new ArgumentNullException(nameof(rate));
 
                 rate = rate.Trim();
                 var baseCurrency = Currency.FromCode(rate.Substring(0, 3));
@@ -159,7 +159,7 @@ public Money Convert(Money money)
             {
                 throw new ArgumentException(
                     "Money should have the same currency as the base currency or the quote currency!", 
-                    "money");
+                    nameof(money));
             }
 
             return money.Currency == BaseCurrency
@@ -201,7 +201,7 @@ public override bool Equals(object obj)
         /// <remarks>See http://en.wikipedia.org/wiki/Currency_Pair for more info about how an ExchangeRate can be presented.</remarks>
         public override string ToString()
         {
-            return string.Format(CultureInfo.CurrentCulture, "{0}/{1} {2}", BaseCurrency.Code, QuoteCurrency.Code, Value);
+            return $"{BaseCurrency.Code}/{QuoteCurrency.Code} {Value}";
         }
     }
 }
\ No newline at end of file
diff --git a/NodaMoney/Extensions/MoneyExtensions.SaveDivide.cs b/NodaMoney/Extensions/MoneyExtensions.SaveDivide.cs
index c8ed352..5935b16 100644
--- a/NodaMoney/Extensions/MoneyExtensions.SaveDivide.cs
+++ b/NodaMoney/Extensions/MoneyExtensions.SaveDivide.cs
@@ -33,7 +33,7 @@ public static IEnumerable<Money> SafeDivide(this Money money, int shares)
         public static IEnumerable<Money> SafeDivide(this Money money, int shares, MidpointRounding rounding)
         {
             if (shares <= 1)
-                throw new ArgumentOutOfRangeException("shares", "Number of shares must be greater than 1");
+                throw new ArgumentOutOfRangeException(nameof(shares), "Number of shares must be greater than 1");
 
             decimal shareAmount = Math.Round(money.Amount / shares, (int)money.Currency.DecimalDigits, rounding);
             decimal remainder = money.Amount;
diff --git a/NodaMoney/Money.Comparable.cs b/NodaMoney/Money.Comparable.cs
index 948c1eb..6159e1e 100644
--- a/NodaMoney/Money.Comparable.cs
+++ b/NodaMoney/Money.Comparable.cs
@@ -104,7 +104,7 @@ public int CompareTo(object obj)
                 return 1;
 
             if (!(obj is Money))
-                throw new ArgumentException("obj is not the same type as this instance", "obj");
+                throw new ArgumentException("obj is not the same type as this instance", nameof(obj));
 
             return CompareTo((Money)obj);
         }
diff --git a/NodaMoney/Money.Formattable.cs b/NodaMoney/Money.Formattable.cs
index 41d4158..b37cc69 100644
--- a/NodaMoney/Money.Formattable.cs
+++ b/NodaMoney/Money.Formattable.cs
@@ -28,7 +28,7 @@ public string ToString(string format)
         {
             // http://msdn.microsoft.com/en-us/library/syy068tk.aspx
             if (format == null)
-                throw new ArgumentNullException("format");
+                throw new ArgumentNullException(nameof(format));
 
             return ConvertToString(format, null);
         }
@@ -41,7 +41,7 @@ public string ToString(string format)
         public string ToString(IFormatProvider formatProvider)
         {
             if (formatProvider == null)
-                throw new ArgumentNullException("formatProvider");
+                throw new ArgumentNullException(nameof(formatProvider));
 
             return ConvertToString(null, formatProvider);
         }
@@ -71,7 +71,7 @@ private static NumberFormatInfo GetNumberFormatInfo(Currency currency, IFormatPr
                     numberFormatInfo = (NumberFormatInfo)nfi.Clone();
             }
 
-            numberFormatInfo.CurrencySymbol = currency.Sign;
+            numberFormatInfo.CurrencySymbol = currency.Symbol;
             numberFormatInfo.CurrencyDecimalDigits = (int)currency.DecimalDigits;
             return numberFormatInfo;
         }
diff --git a/NodaMoney/Money.Parsable.cs b/NodaMoney/Money.Parsable.cs
index c33a3e7..3065587 100644
--- a/NodaMoney/Money.Parsable.cs
+++ b/NodaMoney/Money.Parsable.cs
@@ -18,7 +18,7 @@ public partial struct Money
         public static Money Parse(string value)
         {
             if (string.IsNullOrWhiteSpace(value))
-                throw new ArgumentNullException("value");
+                throw new ArgumentNullException(nameof(value));
 
             Currency currency = ExtractCurrencyFromString(value);
 
@@ -35,7 +35,7 @@ public static Money Parse(string value)
         public static Money Parse(string value, Currency currency)
         {
             if (string.IsNullOrWhiteSpace(value))
-                throw new ArgumentNullException("value");
+                throw new ArgumentNullException(nameof(value));
 
             return Parse(value, NumberStyles.Currency, GetNumberFormatInfo(currency, null), currency);
         }
@@ -52,7 +52,7 @@ public static Money Parse(string value, Currency currency)
         public static Money Parse(string value, NumberStyles style, IFormatProvider provider, Currency currency)
         {
             if (string.IsNullOrWhiteSpace(value))
-                throw new ArgumentNullException("value");
+                throw new ArgumentNullException(nameof(value));
 
             decimal amount = decimal.Parse(value, style, GetNumberFormatInfo(currency, provider));
             return new Money(amount, currency);
@@ -136,31 +136,26 @@ private static Currency ExtractCurrencyFromString(string value)
             // TODO: How to handle alternative symbols, like US$
             string currencyAsString = new string(value.Cast<char>().Where(IsNotNumericCharacter()).ToArray());
 
-            if (currencyAsString.Length == 0 || Currency.CurrentCurrency.Sign == currencyAsString
+            if (currencyAsString.Length == 0 || Currency.CurrentCurrency.Symbol == currencyAsString
                 || Currency.CurrentCurrency.Code == currencyAsString)
             {
                 return Currency.CurrentCurrency;
             }
 
             List<Currency> match =
-                Currency.GetAllCurrencies().Where(c => c.Sign == currencyAsString || c.Code == currencyAsString).ToList();
+                Currency.GetAllCurrencies().Where(c => c.Symbol == currencyAsString || c.Code == currencyAsString).ToList();
 
             if (match.Count == 0)
             {
-                throw new FormatException(
-                    string.Format(CultureInfo.InvariantCulture, "{0} is an unknown currency sign or code!", currencyAsString));
+                throw new FormatException($"{currencyAsString} is an unknown currency sign or code!");
             }
 
             if (match.Count > 1)
             {
-                if (currencyAsString == "¥" && Currency.CurrentCurrency.Sign == "¥")
+                if (currencyAsString == "¥" && Currency.CurrentCurrency.Symbol == "¥")
                     Debug.WriteLine("in error");
 
-                throw new FormatException(
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        "Currency sign {0} matches with multiple known currencies! Specify currency or culture explicit.",
-                        currencyAsString));
+                throw new FormatException($"Currency sign {currencyAsString} matches with multiple known currencies! Specify currency or culture explicit.");
             }
 
             return match[0];
diff --git a/NodaMoney/Money.Serializable.cs b/NodaMoney/Money.Serializable.cs
index e15c982..cc25a12 100644
--- a/NodaMoney/Money.Serializable.cs
+++ b/NodaMoney/Money.Serializable.cs
@@ -32,7 +32,7 @@ public XmlSchema GetSchema()
         public void ReadXml(XmlReader reader)
         {
             if (reader == null)
-                throw new ArgumentNullException("reader");
+                throw new ArgumentNullException(nameof(reader));
 
             if (reader.MoveToContent() != XmlNodeType.Element)
                 throw new SerializationException("Couldn't find content element with name Money!");
@@ -47,7 +47,7 @@ public void ReadXml(XmlReader reader)
         public void WriteXml(XmlWriter writer)
         {
             if (writer == null)
-                throw new ArgumentNullException("writer");
+                throw new ArgumentNullException(nameof(writer));
 
             writer.WriteAttributeString("Amount", Amount.ToString(CultureInfo.InvariantCulture));
             writer.WriteAttributeString("Currency", Currency.Code);
diff --git a/NodaMoney/Money.cs b/NodaMoney/Money.cs
index 1ec9ebb..6ebe2a9 100644
--- a/NodaMoney/Money.cs
+++ b/NodaMoney/Money.cs
@@ -86,12 +86,18 @@ public Money(decimal amount, Currency currency, MidpointRounding rounding)
             Currency = currency;
 
             // TODO: Currency.Z07 and Currency.DOT edge case handeling!
-            if (Currency.DecimalDigits == Currency.DOT)
-                Amount = Math.Round(amount);
-            if (Currency.DecimalDigits == Currency.Z07)
+            if (Currency.DecimalDigits == CurrencyRegistry.NotApplicable)
+            {
+                Amount = Math.Round(amount);                
+            }
+            else if (Currency.DecimalDigits == CurrencyRegistry.Z07)
+            {
                 Amount = Math.Round(amount, 1);
-
-            Amount = Math.Round(amount, (int)Currency.DecimalDigits, rounding);
+            }
+            else
+            {
+                Amount = Math.Round(amount, (int)Currency.DecimalDigits, rounding);
+            }
         }
 
         // int, uint ([CLSCompliant(false)]) // auto-casting to decimal so not needed
@@ -288,7 +294,7 @@ public override int GetHashCode()
         private static void AssertIsSameCurrency(Money left, Money right)
         {
             if (left.Currency != right.Currency)
-                throw new InvalidCurrencyException(string.Format("{0} ({1}) and {2} ({3}) are not of the same Currency!", left, left.Currency.Code, right, right.Currency.Code));
+                throw new InvalidCurrencyException($"{left} ({left.Currency.Code}) and {right} ({right.Currency.Code}) are not of the same Currency!");
         }
     }
 }
\ No newline at end of file
diff --git a/NodaMoney/NodaMoney.csproj b/NodaMoney/NodaMoney.csproj
index 4063b6a..45b779d 100644
--- a/NodaMoney/NodaMoney.csproj
+++ b/NodaMoney/NodaMoney.csproj
@@ -40,14 +40,17 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <RunCodeAnalysis>true</RunCodeAnalysis>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
     <DocumentationFile>bin\Release\NodaMoney.xml</DocumentationFile>
+    <CodeAnalysisAdditionalOptions>/assemblycomparemode:StrongNameIgnoringVersion</CodeAnalysisAdditionalOptions>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="..\SolutionInfo.cs">
       <Link>Properties\SolutionInfo.cs</Link>
     </Compile>
     <Compile Include="Currency.cs" />
+    <Compile Include="CurrencyBuilder.cs" />
+    <Compile Include="CurrencyRegistry.cs" />
     <Compile Include="ExchangeRate.cs" />
     <Compile Include="Extensions\MoneyExtensions.SaveDivide.cs" />
     <Compile Include="GlobalSuppressions.cs" />
@@ -66,18 +69,22 @@
   <ItemGroup>
     <Compile Include="Money.BinaryOperators.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml">
-      <Link>Properties\CodeAnalysisDictionary.xml</Link>
-    </CodeAnalysisDictionary>
-  </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
-    <Reference Include="Newtonsoft.Json">
-      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\portable-net45+wp80+win8+wpa81+aspnetcore50\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\packages\Newtonsoft.Json.7.0.1\lib\portable-net40+sl5+wp80+win8+wpa81\Newtonsoft.Json.dll</HintPath>
+      <Private>True</Private>
     </Reference>
+    <Reference Include="System.Collections.Concurrent">
+      <HintPath>..\..\..\..\..\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETPortable\v4.5\System.Collections.Concurrent.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <CodeAnalysisDictionary Include="..\CustomDictionary.xml">
+      <Link>Properties\CustomDictionary.xml</Link>
+    </CodeAnalysisDictionary>
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
   <Import Project="..\packages\StyleCop.MSBuild.4.7.49.1\build\StyleCop.MSBuild.Targets" Condition="Exists('..\packages\StyleCop.MSBuild.4.7.49.1\build\StyleCop.MSBuild.Targets')" />
diff --git a/NodaMoney/Serialization/JsonNet/MoneyJsonConverter.cs b/NodaMoney/Serialization/JsonNet/MoneyJsonConverter.cs
index 83a0601..eab3136 100644
--- a/NodaMoney/Serialization/JsonNet/MoneyJsonConverter.cs
+++ b/NodaMoney/Serialization/JsonNet/MoneyJsonConverter.cs
@@ -24,11 +24,11 @@ public override bool CanRead
         public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
         {
             if (writer == null)
-                throw new ArgumentNullException("writer");
+                throw new ArgumentNullException(nameof(writer));
             if (value == null)
-                throw new ArgumentNullException("value");
+                throw new ArgumentNullException(nameof(value));
             if (serializer == null)
-                throw new ArgumentNullException("serializer");
+                throw new ArgumentNullException(nameof(serializer));
 
             Money money = (Money)value;
 
@@ -50,7 +50,7 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
         {
             if (reader == null)
-                throw new ArgumentNullException("reader");
+                throw new ArgumentNullException(nameof(reader));
 
             JObject jsonObject = JObject.Load(reader);
             var properties = jsonObject.Properties().ToList();
diff --git a/NodaMoney/packages.config b/NodaMoney/packages.config
index b6e80c7..7358312 100644
--- a/NodaMoney/packages.config
+++ b/NodaMoney/packages.config
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Newtonsoft.Json" version="6.0.8" targetFramework="portable-net45+win+wpa81+wp80" />
-  <package id="StyleCop.MSBuild" version="4.7.49.1" targetFramework="portable-net45+win+wpa81+wp80" developmentDependency="true" />
+  <package id="Newtonsoft.Json" version="7.0.1" targetFramework="portable45-net45+win8+wp8+wpa81" />
+  <package id="StyleCop.MSBuild" version="4.7.49.1" targetFramework="portable-net45+win8+wp8+wpa81" developmentDependency="true" />
 </packages>
\ No newline at end of file
diff --git a/README.md b/README.md
index 37d568d..bfbee6b 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-NodaMoney
+NodaMoney
 =========
 <img align="right" src="https://raw.githubusercontent.com/remyvd/NodaMoney/master/Tools/logo_nodamoney.png">
 You can get the latest stable release from the [official Nuget.org feed](https://www.nuget.org/packages/NodaMoney) or from our
@@ -35,11 +35,12 @@ base layer, providing classes that should be in the .NET Framework. It complies
 
 Usage
 -----
-At the moment there are three classes:
-- Currency: An immutable structure that represents a currency. It can give all ISO 4217 currencies.
+At the moment there are four classes:
+- Currency: An immutable structure that represents a currency. It can give all ISO 4217 and custom currencies.
 - Money: An immutable structure that represents money in a specified currency.
 - ExchangeRate: A stucture that represents a [currency pair](http://en.wikipedia.org/wiki/Currency_pair) that can convert money
 from one currency to another currency.
+- CurrencyBuilder: Defines a custom currency that is new or based on another currency.
 
 **Initalizing money**
 
@@ -105,25 +106,25 @@ var dollar = new Money(765.43m, "USD");
 var dinar = new Money(765.432m, "BHD");
 
 // Implicit when current culture is 'en-US'
-yen.ToString();    // "�765"
-euro.ToString();   // "�765.43"
+yen.ToString();    // "¥765"
+euro.ToString();   // "€765.43"
 dollar.ToString(); // "$765.43"
 dinar.ToString();  // "BD765.432"
 
-yen.ToString("C2");    // "�765.00"
-euro.ToString("C2");   // "�765.43"
+yen.ToString("C2");    // "¥765.00"
+euro.ToString("C2");   // "€765.43"
 dollar.ToString("C2"); // "$765.43"
 dinar.ToString("C2");  // "BD765.43"
 
 // Implicit when current culture is 'nl-BE'
-yen.ToString();    // "� 765"
-euro.ToString();   // "� 765,43"
+yen.ToString();    // "¥ 765"
+euro.ToString();   // "€ 765,43"
 dollar.ToString(); // "$ 765,43"
 dinar.ToString();  // "BD 765,432"
 
 // Implicit when current culture is 'fr-BE'
-yen.ToString();    // "765 �"
-euro.ToString();   // "765,43 �"
+yen.ToString();    // "765 ¥"
+euro.ToString();   // "765,43 €"
 dollar.ToString(); // "765,43 $"
 dinar.ToString();  // "765,432 BD"
 }
@@ -131,8 +132,77 @@ dinar.ToString();  // "765,432 BD"
 // Explicit format for culture 'nl-NL'
 var ci = new CultureInfo("nl-NL");
 
-yen.ToString(ci);    // "� 765"
-euro.ToString(ci);   // "� 765,43"
+yen.ToString(ci);    // "¥ 765"
+euro.ToString(ci);   // "€ 765,43"
 dollar.ToString(ci); // "$ 765,43"
 dinar.ToString(ci);  // "BD 765,432"
+```
+
+**Money parsing**
+
+```C#
+// Implicit parsing when current culture is 'nl-BE'
+Money euro = Money.Parse("€ 765,43");
+Money euro = Money.Parse("-€ 765,43");
+Money euro = Money.Parse("€-765,43");
+Money euro = Money.Parse("765,43 €");
+Money yen = Money.Parse("¥ 765"); // throw FormatException, because ¥ symbol is used for Japanese yen and Chinese yuan
+Money dollar = Money.Parse("$ 765,43"); // throw FormatException, because $ symbol is used for multiple currencies
+
+// Implicit parsing when current culture is 'ja-JP'
+Money yen = Money.Parse("¥ 765");
+
+// Implicit parsing when current culture is 'zh-CN'
+Money yuan = Money.Parse("¥ 765");
+
+// Implicit parsing when current culture is 'en-US'
+Money dollar = Money.Parse("$765.43");
+Money dollar = Money.Parse("($765.43)"); // -$765.43
+
+// Implicit parsing when current culture is 'es-AR'
+Money peso = Money.Parse("$765.43");
+
+// Explicit parsing when current culture is 'nl-BE'
+Money euro = Money.Parse("€ 765,43", Currency.FromCode("EUR"));
+Money euro = Money.Parse("765,43 €", Currency.FromCode("EUR"));
+Money yen = Money.Parse("¥ 765", Currency.FromCode("JPY"));
+Money yuan = Money.Parse("¥ 765", Currency.FromCode("CNY"));
+
+// Implicit try parsing when current culture is 'nl-BE'
+Money euro;
+Money.TryParse("€ 765,43", out euro);
+
+// Explicit try parsing when current culture is 'nl-BE'
+Money euro;
+Money.TryParse("€ 765,43", Currency.FromCode("EUR"), out euro);
+```
+
+**Adding custom currencies**
+
+```C#
+// Create custom currency and register it (for the life-time of the app domain)
+var builder = new CurrencyBuilder("BTC", "virtual")
+				{
+					EnglishName = "Bitcoin",
+					Symbol = "฿",
+					DecimalDigits = 8
+				};
+
+var bitcoin = builder.Build(); // build BTC, but will not register it
+var bitcoin = builder.Register(); // build and register BTC in namespace 'virtual'
+
+// When the custom is registered, it can be called as any other currency
+Money bitcoins = new Money(1.2, Currency.FromCode("BTC", "virtual"));
+Money bitcoins = new Money(1.2. "BTC");
+
+// Replace ISO 4217 currency (for the life-time of the app domain)
+Currency oldEuro = CurrencyBuilder.Unregister("EUR", "ISO-4217");
+
+var builder = new CurrencyBuilder("EUR", "ISO-4217");
+builder.LoadDataFromCurrency(oldEuro);
+builder.EnglishName = "New Euro";
+builder.DecimalDigits = 1;
+builder.Register();
+
+Currency newEuro = Currency.FromCode("EUR");
 ```
\ No newline at end of file
diff --git a/Settings.StyleCop b/Settings.StyleCop
index e250c10..0a190fb 100644
--- a/Settings.StyleCop
+++ b/Settings.StyleCop
@@ -4,6 +4,7 @@
       <Value>ariary</Value>
       <Value>cinquième</Value>
       <Value>iraimbilanja</Value>
+      <Value>Ldml</Value>
     </CollectionProperty>
   </GlobalSettings>
   <Analyzers>
diff --git a/appveyor.yml b/appveyor.yml
index 8891154..05ad9e8 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -2,6 +2,7 @@
 #      general configuration      #
 #---------------------------------#
 version: '{build}-{branch}'
+os: Visual Studio 2015 RC
 
 #---------------------------------#
 #    environment configuration    #
@@ -19,6 +20,7 @@ nuget:
   disable_publish_on_pr: true
 
 before_build:
+- set PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
 - nuget restore
 - GitVersion /output buildserver /updateAssemblyInfo SolutionInfo.cs