Index: DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/CsvParserTest.cs
===================================================================
diff -u -r4259 -r4287
--- DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/CsvParserTest.cs	(.../CsvParserTest.cs)	(revision 4259)
+++ DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/CsvParserTest.cs	(.../CsvParserTest.cs)	(revision 4287)
@@ -39,7 +39,7 @@
     {
         testFile = "test.csv";
         using StreamWriter writer = File.CreateText(testFile);
-        writer.WriteLine("name;age"); //<- header contains name and age
+        writer.WriteLine("name;age");
         writer.WriteLine("Anouar;31");
         writer.WriteLine("Barry;39");
         writer.WriteLine("Tom;48");
@@ -58,26 +58,25 @@
     [Test]
     public void ThrowsArgumentExceptionWhenHeaderStringIsNullByCallingParseHeader()
     {
-        var expectedMessage = "The header in the import file is not valid";
-        Assert.That(() => CsvParser.ParseHeader(null, new Regex("")), Throws.ArgumentException.With.Message.EqualTo(expectedMessage));
+        const string expectedMessage = "The header in the import file is not valid";
+        Assert.That(() => CsvParser.ParseHeader(null, new Regex("")), Throws.InstanceOf<CsvParserException>().With.Message.EqualTo(expectedMessage));
     }
 
     [Test]
     public void ThrowsArgumentExceptionSplitterIsNull()
     {
         string expectedMessage = "The given pattern to split the data values of the CSV files is not valid" + Environment.NewLine + "Parameter name: splitter";
-        Assert.That(() => CsvParser.ParseHeader("test;test", null), Throws.ArgumentNullException.With.Message.EqualTo(expectedMessage));
+        Assert.That(() => CsvParser.ParseHeader("test;test", null), Throws.InstanceOf<CsvParserException>().With.Message.EqualTo(expectedMessage));
     }
 
     [Test]
     public void ThrowsWhenSplitPatternIsEmpty()
     {
-        var expectedMessage = "The given pattern to split the data values of the CSV files is not valid";
-        Assert.That(() => CsvParser.ParseHeader("test", new Regex("")), Throws.ArgumentException.With.Message.EqualTo(expectedMessage));
+        const string expectedMessage = "The given pattern to split the data values of the CSV files is not valid";
+        Assert.That(() => CsvParser.ParseHeader("test", new Regex("")), Throws.InstanceOf<CsvParserException>().With.Message.EqualTo(expectedMessage));
     }
 
     [Test]
-    [Ignore("[ExpectedException(typeof(CsvParserException))]")]
     public void ThrowsWhenNoHeaderItemsAreParsed()
     {
         Assert.That(() => CsvParser.ParseHeader("test", new Regex("")), Throws.InstanceOf<CsvParserException>());
@@ -154,7 +153,7 @@
     {
         using (StreamWriter writer = File.CreateText(testFile))
         {
-            writer.WriteLine("name;age"); //<- header contains name and age
+            writer.WriteLine("name;age");
             writer.WriteLine("Barry;39;");
         }
 
@@ -169,7 +168,7 @@
     {
         using (StreamWriter writer = File.CreateText(testFile))
         {
-            writer.WriteLine("name;age"); //<- header contains name and age
+            writer.WriteLine("name;age");
             writer.WriteLine("Anouar;31");
             writer.WriteLine("Barry;39");
             writer.WriteLine("Tom;48");
@@ -180,7 +179,7 @@
         loader.Add("name", (entity, value) => entity.Name = value);
         loader.Add("age", (entity, value) => entity.Age = int.Parse(value));
         List<Foo> items = loader.LoadFromCsvFile(testFile).ToList();
-        Assert.AreEqual(4, items.Count());
+        Assert.AreEqual(4, items.Count);
         Assert.AreEqual("Tom", items.ElementAt(2).Name);
         Assert.AreEqual(48, items.ElementAt(2).Age);
     }
Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/CsvParser.cs
===================================================================
diff -u -r4277 -r4287
--- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/CsvParser.cs	(.../CsvParser.cs)	(revision 4277)
+++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/CsvParser.cs	(.../CsvParser.cs)	(revision 4287)
@@ -28,53 +28,61 @@
 namespace Deltares.Dam.Data;
 
 /// <summary>
-/// Parses a csv file and returns a sequence of entities of a specific type
+///     Parses a csv file and returns a sequence of entities of a specific type
 /// </summary>
 public static class CsvParser
 {
     /// <summary>
-    /// This regex splits semicolon separated lists of optionally quoted strings. It handles quoted delimiters and escaped quotes. 
-    /// Whitespace inside quotes is preserved, outside is eaten.
-    /// See: http://regexlib.com/REDetails.aspx?regexp_id=1325
+    ///     This regex splits semicolon separated lists of optionally quoted strings. It handles quoted delimiters and escaped
+    ///     quotes.
+    ///     Whitespace inside quotes is preserved, outside is eaten.
+    ///     See: http://regexlib.com/REDetails.aspx?regexp_id=1325
     /// </summary>
     public static readonly string CsvSplitPatternSemicolonOnly =
         @"\s*[;]\s*(?!(?<=(?:^|[;])\s*""(?:[^""]|""""|\\"")*[;]\s*)(?:[^""]|""""|\\"")*""\s*(?:[;]|$))";
 
     /// <summary>
-    /// Parses the header of an csv import file
+    ///     Parses the header of an csv import file
     /// </summary>
     /// <param name="header">The header string</param>
     /// <param name="splitter">The regular expression</param>
     /// <returns>An array of strings containing the header names</returns>
     public static string[] ParseHeader(string header, Regex splitter)
     {
-        ThrowHelper.ThrowIfStringArgumentNullOrEmpty(header, StringResourceNames.CsvHeaderNullOrEmpty);
-        ThrowHelper.ThrowIfArgumentNull(splitter, "splitter", StringResourceNames.CsvSplitterPatternNotValid);
-        ThrowHelper.ThrowIfStringArgumentNullOrEmpty(splitter.ToString(), StringResourceNames.CsvSplitterPatternNotValid);
+        try
+        {
+            ThrowHelper.ThrowIfStringArgumentNullOrEmpty(header, StringResourceNames.CsvHeaderNullOrEmpty);
+            ThrowHelper.ThrowIfArgumentNull(splitter, "splitter", StringResourceNames.CsvSplitterPatternNotValid);
+            ThrowHelper.ThrowIfStringArgumentNullOrEmpty(splitter.ToString(), StringResourceNames.CsvSplitterPatternNotValid);
+        }
+        catch (Exception e)
+        {
+            throw new CsvParserException(e.Message);
+        }
 
         return splitter.Split(header);
     }
 
     /// <summary>
-    /// Loads entities of an specific type from a csv file
+    ///     Loads entities of an specific type from a csv file
     /// </summary>
     /// <typeparam name="T">The type to construct</typeparam>
     /// <param name="setter">The object materializer (property setters)</param>
     /// <param name="fileName">The file name to parse</param>
-    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns> 
+    /// <returns>A sequence containing materialized instances of the type to construct from the csv data</returns>
     public static IEnumerable<T> LoadFromCsvFile<T>(this ObjectMaterializer<T> setter, string fileName)
         where T : new()
     {
         return LoadFromCsvFile(setter, fileName, true);
     }
 
     /// <summary>
-    /// Loads entities of an specific type from a csv file. Also returns the parsed headers
+    ///     Loads entities of an specific type from a csv file. Also returns the parsed headers
     /// </summary>
     /// <typeparam name="T">The type to construct</typeparam>
     /// <param name="setter">The object materializer (property setters)</param>
     /// <param name="fileName">The file name to parse</param>
-    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns> 
+    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns>
     public static IEnumerable<T> LoadFromCsvFile<T>(this ObjectMaterializer<T> setter, string fileName, ref string[] headers)
         where T : new()
     {
@@ -97,42 +105,42 @@
     }
 
     /// <summary>
-    /// Loads entities of an specific type from a csv file
+    ///     Loads entities of an specific type from a csv file
     /// </summary>
     /// <typeparam name="T">The type to construct</typeparam>
     /// <param name="setter">The object materializer (property setters)</param>
     /// <param name="fileName">The file name to parse</param>
     /// <param name="splitPattern">The regular expression for splitting the items in a string</param>
-    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns> 
+    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns>
     public static IEnumerable<T> LoadFromCsvFile<T>(this ObjectMaterializer<T> setter, string fileName, string splitPattern)
         where T : new()
     {
         return LoadFromCsvFile(setter, fileName, true, splitPattern);
     }
 
     /// <summary>
-    /// Loads entities of an specific type from a csv file
+    ///     Loads entities of an specific type from a csv file
     /// </summary>
     /// <typeparam name="T">The type to construct</typeparam>
     /// <param name="setter">The object materializer (property setters)</param>
     /// <param name="fileName">The file name to parse</param>
     /// <param name="headerInfoInFirstLine">Indicates if the first line in the csv file contains the header info</param>
-    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns> 
+    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns>
     public static IEnumerable<T> LoadFromCsvFile<T>(this ObjectMaterializer<T> setter, string fileName, bool headerInfoInFirstLine)
         where T : new()
     {
         return LoadFromCsvFile(setter, fileName, true, CsvSplitPatternSemicolonOnly);
     }
 
     /// <summary>
-    /// Loads entities of an specific type from a csv file
+    ///     Loads entities of an specific type from a csv file
     /// </summary>
     /// <typeparam name="T">The type to construct</typeparam>
     /// <param name="materializer">The object materializer (property setters)</param>
     /// <param name="fileName">The file name to parse</param>
     /// <param name="headerInfoInFirstLine">Indicates if the first line in the csv file contains the header info</param>
     /// <param name="splitPattern">The regular expression for splitting the items in a string</param>
-    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns> 
+    /// <returns>A sequance containing materialized intances of the type to construct from the csv data</returns>
     public static IEnumerable<T> LoadFromCsvFile<T>(this ObjectMaterializer<T> materializer, string fileName, bool headerInfoInFirstLine, string splitPattern)
         where T : new()
     {