Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/DikeProfiles/DikeProfileDataReader.cs
===================================================================
diff -u -r02b9c1938c77fec1599daf755bc1e7e70598621c -r9b2cc43e34e4e4202f435ea6720c8e9637db45a7
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/DikeProfiles/DikeProfileDataReader.cs	(.../DikeProfileDataReader.cs)	(revision 02b9c1938c77fec1599daf755bc1e7e70598621c)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/DikeProfiles/DikeProfileDataReader.cs	(.../DikeProfileDataReader.cs)	(revision 9b2cc43e34e4e4202f435ea6720c8e9637db45a7)
@@ -57,21 +57,8 @@
             KRUINHOOGTE = 128,
             DIJK = 256,
             MEMO = 512,
-            All = 1023
         }
 
-        private const string idPattern = @"^ID(\s+(?<id>.+?)?)?\s*$";
-        private const string versionPattern = @"^VERSIE(\s+(?<version>.+?)?)?\s*$";
-        private const string orientationPattern = @"^RICHTING(\s+(?<orientation>.+?)?)?\s*$";
-        private const string damTypePattern = @"^DAM(\s+(?<damtype>.+?)?)?\s*$";
-        private const string profileTypePattern = @"^DAMWAND(\s+(?<profiletype>.+?)?)?\s*$";
-        private const string damHeightPattern = @"^DAMHOOGTE(\s+(?<damheight>.+?)?)?\s*$";
-        private const string crestLevelPattern = @"^KRUINHOOGTE(\s+(?<crestlevel>.+?)?)?\s*$";
-        private const string dikeGeometryPattern = @"^DIJK(\s+(?<dikegeometry>.+?)?)?\s*$";
-        private const string foreshoreGeometryPattern = @"^VOORLAND(\s+(?<foreshoregeometry>.+?)?)?\s*$";
-        private const string roughnessPointPattern = @"^(\s*)?(?<localx>.+?)?(\s+(?<localz>.+?)?(\s+(?<roughness>.+?)?)?)?\s*$";
-        private const string memoPattern = @"^MEMO\s*$";
-
         private string fileBeingRead;
         private ParametersFoundInFile readParameters;
 
@@ -82,10 +69,11 @@
         /// <returns>The read dike profile data.</returns>
         /// <exception cref="CriticalFileReadException">When an error occurs like:
         /// <list type="bullet">
+        /// <item><paramref name="filePath"/> is invalid.</item>
         /// <item><paramref name="filePath"/> refers to a file that doesn't exist.</item>
         /// <item>A piece of text from the file cannot be converted in the expected variable type.</item>
         /// <item>A converted value is invalid.</item>
-        /// <item>The file is not complete.</item>
+        /// <item>The file is incomplete.</item>
         /// </list></exception>
         public DikeProfileData ReadDikeProfileData(string filePath)
         {
@@ -173,20 +161,16 @@
         /// <returns><c>True</c> if the text matches a VERSIE key-value pair and has been
         /// validated successfully; <c>false</c> otherwise.</returns>
         /// <exception cref="CriticalFileReadException">The value after the VERSIE key does
-        /// not represent a valid version code or the file version is not supported by this reader.</exception>
+        /// not represent a valid version code or the version is not supported by this reader.</exception>
         private bool TryReadVersion(string text, int lineNumber)
         {
-            Match versionMatch = new Regex(versionPattern).Match(text);
+            Match versionMatch = new Regex(@"^VERSIE(\s+(?<version>.+?)?)?\s*$").Match(text);
             if (versionMatch.Success)
             {
                 string readVersionText = versionMatch.Groups["version"].Value;
                 Version fileVersion = ParseVersion(lineNumber, readVersionText);
 
-                if (!fileVersion.Equals(new Version(4, 0)))
-                {
-                    string message = Resources.DikeProfileDataReader_TryReadVersion_Only_version_four_zero_supported;
-                    throw CreateCriticalFileReadException(lineNumber, message);
-                }
+                ValidateVersion(fileVersion, lineNumber);
 
                 readParameters |= ParametersFoundInFile.VERSIE;
                 return true;
@@ -195,10 +179,10 @@
         }
 
         /// <summary>
-        /// Parses the version code from a piece of text representing a VERSIE key-value pair.
+        /// Parses the version code from a piece of text.
         /// </summary>
         /// <param name="lineNumber">The line number.</param>
-        /// <param name="readVersionText">The VERSIE key-value pair text.</param>
+        /// <param name="readVersionText">The text to parse.</param>
         /// <returns>The read version code.</returns>
         /// <exception cref="CriticalFileReadException">When <paramref name="readVersionText"/>
         /// does not represent a valid version code.</exception>
@@ -229,34 +213,40 @@
         }
 
         /// <summary>
-        /// Attempts to match the given text to a ID key-value pair. If a match is found,
+        /// Validates the version.
+        /// </summary>
+        /// <param name="fileVersion">The file version.</param>
+        /// <param name="lineNumber">The line number.</param>
+        /// <exception cref="CriticalFileReadException">When <paramref name="fileVersion"/>
+        /// is not supported by this reader.</exception>
+        private void ValidateVersion(Version fileVersion, int lineNumber)
+        {
+            if (!fileVersion.Equals(new Version(4, 0)))
+            {
+                string message = Resources.DikeProfileDataReader_ValidateVersion_Only_version_four_zero_supported;
+                throw CreateCriticalFileReadException(lineNumber, message);
+            }
+        }
+
+        /// <summary>
+        /// Attempts to match the given text to an ID key-value pair. If a match is found,
         /// the value is parsed and validated.
         /// </summary>
         /// <param name="text">The text.</param>
         /// <param name="data">The data to be updated.</param>
         /// <param name="lineNumber">The line number.</param>
-        /// <returns><c>True</c> if the text matches a ID key-value pair and has been
+        /// <returns><c>True</c> if the text matches an ID key-value pair and has been
         /// validated successfully; <c>false</c> otherwise.</returns>
         /// <exception cref="CriticalFileReadException">The value after the ID key does
-        /// not represent a id.</exception>
+        /// not represent an id.</exception>
         private bool TryReadId(string text, DikeProfileData data, int lineNumber)
         {
-            Match idMatch = new Regex(idPattern).Match(text);
+            Match idMatch = new Regex(@"^ID(\s+(?<id>.+?)?)?\s*$").Match(text);
             if (idMatch.Success)
             {
                 string readIdText = idMatch.Groups["id"].Value;
-                if (string.IsNullOrWhiteSpace(readIdText))
-                {
-                    string message = string.Format(Resources.DikeProfileDataReader_TryReadId_Id_0_not_valid,
-                                                   readIdText);
-                    throw CreateCriticalFileReadException(lineNumber, message);
-                }
-                if (new Regex(@"\s").IsMatch(readIdText))
-                {
-                    string message = string.Format(Resources.DikeProfileDataReader_TryReadId_Id_0_has_unsupported_white_space,
-                                                   readIdText);
-                    throw CreateCriticalFileReadException(lineNumber, message);
-                }
+                ValidateId(readIdText, lineNumber);
+
                 data.Id = readIdText;
                 readParameters |= ParametersFoundInFile.ID;
                 return true;
@@ -265,6 +255,30 @@
         }
 
         /// <summary>
+        /// Validates the identifier.
+        /// </summary>
+        /// <param name="id">The id.</param>
+        /// <param name="lineNumber">The line number.</param>
+        /// <exception cref="CriticalFileReadException">When <paramref name="id"/> is not
+        /// present or has a whitespace.</exception>
+        private void ValidateId(string id, int lineNumber)
+        {
+            if (string.IsNullOrWhiteSpace(id))
+            {
+                string message = string.Format(Resources.DikeProfileDataReader_ValidateId_Id_0_not_valid,
+                                               id);
+                throw CreateCriticalFileReadException(lineNumber, message);
+            }
+
+            if (new Regex(@"\s").IsMatch(id))
+            {
+                string message = string.Format(Resources.DikeProfileDataReader_ValidateId_Id_0_has_unsupported_white_space,
+                                               id);
+                throw CreateCriticalFileReadException(lineNumber, message);
+            }
+        }
+
+        /// <summary>
         /// Attempts to match the given text to a RICHTING key-value pair. If a match is
         /// found, the value is parsed and validated. If valid, the value is stored.
         /// </summary>
@@ -277,18 +291,14 @@
         /// not represent a valid number or the orientation value is not in the range [0, 360].</exception>
         private bool TryReadOrientation(string text, DikeProfileData data, int lineNumber)
         {
-            Match orientationMatch = new Regex(orientationPattern).Match(text);
+            Match orientationMatch = new Regex(@"^RICHTING(\s+(?<orientation>.+?)?)?\s*$").Match(text);
             if (orientationMatch.Success)
             {
                 string readOrientationText = orientationMatch.Groups["orientation"].Value;
                 double orientation = ParseOrientation(lineNumber, readOrientationText);
 
-                if (orientation < 0.0 || orientation > 360.0)
-                {
-                    string message = string.Format(Resources.DikeProfileDataReader_TryReadOrientation_Orientation_0_must_be_in_range,
-                                                   orientation);
-                    throw CreateCriticalFileReadException(lineNumber, message);
-                }
+                ValidateOrientation(orientation, lineNumber);
+
                 data.Orientation = orientation;
                 readParameters |= ParametersFoundInFile.RICHTING;
                 return true;
@@ -297,10 +307,10 @@
         }
 
         /// <summary>
-        /// Parses the orientation from a piece representing a RICHTING key-value pair.
+        /// Parses the orientation from a piece of text.
         /// </summary>
         /// <param name="lineNumber">The line number.</param>
-        /// <param name="readOrientationText">The RICHTING key-value pair text.</param>
+        /// <param name="readOrientationText">The text.</param>
         /// <returns>The value corresponding to the RICHTING key.</returns>
         /// <exception cref="CriticalFileReadException">When <paramref name="readOrientationText"/>
         /// does not represent a valid number.</exception>
@@ -325,6 +335,23 @@
         }
 
         /// <summary>
+        /// Validates the orientation.
+        /// </summary>
+        /// <param name="orientation">The orientation.</param>
+        /// <param name="lineNumber">The line number.</param>
+        /// <exception cref="CriticalFileReadException">When <paramref name="orientation"/>
+        /// is outside the [0, 360] range.</exception>
+        private void ValidateOrientation(double orientation, int lineNumber)
+        {
+            if (orientation < 0.0 || orientation > 360.0)
+            {
+                string message = string.Format(Resources.DikeProfileDataReader_ValidateOrientation_Orientation_0_must_be_in_range,
+                                               orientation);
+                throw CreateCriticalFileReadException(lineNumber, message);
+            }
+        }
+
+        /// <summary>
         /// Attempts to match the given text to a DAM key-value pair. If a match is found,
         /// the value is parsed and validated. If valid, the value is stored.
         /// </summary>
@@ -337,7 +364,7 @@
         /// not represent a valid <see cref="DamType"/> value.</exception>
         private bool TryReadDamType(string text, DikeProfileData data, int lineNumber)
         {
-            Match damTypeMatch = new Regex(damTypePattern).Match(text);
+            Match damTypeMatch = new Regex(@"^DAM(\s+(?<damtype>.+?)?)?\s*$").Match(text);
             if (damTypeMatch.Success)
             {
                 string readDamTypeText = damTypeMatch.Groups["damtype"].Value;
@@ -351,10 +378,10 @@
         }
 
         /// <summary>
-        /// Parses the dam-type from a piece of text representing a DAM key-value pair.
+        /// Parses the dam-type from a piece of text.
         /// </summary>
         /// <param name="lineNumber">The line number.</param>
-        /// <param name="readDamTypeText">The DAM key-value pair text.</param>
+        /// <param name="readDamTypeText">The text.</param>
         /// <returns>The read dam-type.</returns>
         /// <exception cref="CriticalFileReadException">When <paramref name="readDamTypeText"/>
         /// does not represent a <see cref="DamType"/>.</exception>
@@ -401,7 +428,7 @@
         /// does not represent a valid <see cref="ProfileType"/> value.</exception>
         private bool TryReadProfileType(string text, DikeProfileData data, int lineNumber)
         {
-            Match profileTypeMatch = new Regex(profileTypePattern).Match(text);
+            Match profileTypeMatch = new Regex(@"^DAMWAND(\s+(?<profiletype>.+?)?)?\s*$").Match(text);
             if (profileTypeMatch.Success)
             {
                 string readProfileTypeText = profileTypeMatch.Groups["profiletype"].Value;
@@ -415,10 +442,10 @@
         }
 
         /// <summary>
-        /// Parses the profile-type from a piece of text representing a DAMWAND key-value pair.
+        /// Parses the profile-type from a piece of text.
         /// </summary>
         /// <param name="lineNumber">The line number.</param>
-        /// <param name="readProfileTypeText">The DAMWAND key-value pair text.</param>
+        /// <param name="readProfileTypeText">The text.</param>
         /// <returns>The read profile-type.</returns>
         /// <exception cref="CriticalFileReadException">When <paramref name="readProfileTypeText"/>
         /// does not represent a <see cref="ProfileType"/>.</exception>
@@ -464,7 +491,7 @@
         /// does not represent a valid number.</exception>
         private bool TryReadDamHeight(string text, DikeProfileData data, int lineNumber)
         {
-            Match damHeightMatch = new Regex(damHeightPattern).Match(text);
+            Match damHeightMatch = new Regex(@"^DAMHOOGTE(\s+(?<damheight>.+?)?)?\s*$").Match(text);
             if (damHeightMatch.Success)
             {
                 string readDamHeightText = damHeightMatch.Groups["damheight"].Value;
@@ -478,11 +505,10 @@
         }
 
         /// <summary>
-        /// Parses the height of the dam from a piece of text representing a DAMHOOGTE
-        /// key-value pair.
+        /// Parses the height of the dam from a piece of text.
         /// </summary>
         /// <param name="lineNumber">The line number.</param>
-        /// <param name="readDamHeightText">The DAMHOOGTE key-value pair text.</param>
+        /// <param name="readDamHeightText">The text.</param>
         /// <returns>The height of the dam.</returns>
         /// <exception cref="CriticalFileReadException">When <paramref name="readDamHeightText"/>
         /// does not represent a number.</exception>
@@ -519,7 +545,7 @@
         /// does not represent a valid number.</exception>
         private bool TryReadCrestLevel(string text, DikeProfileData data, int lineNumber)
         {
-            Match crestLevelMatch = new Regex(crestLevelPattern).Match(text);
+            Match crestLevelMatch = new Regex(@"^KRUINHOOGTE(\s+(?<crestlevel>.+?)?)?\s*$").Match(text);
             if (crestLevelMatch.Success)
             {
                 string readCrestLevelText = crestLevelMatch.Groups["crestlevel"].Value;
@@ -533,11 +559,10 @@
         }
 
         /// <summary>
-        /// Parses the height of the dike from a piece of text representing a KRUINHOOGTE
-        /// key-value pair.
+        /// Parses the height of the dike from a piece of text.
         /// </summary>
         /// <param name="lineNumber">The line number.</param>
-        /// <param name="readCrestLevelText">The KRUINHOOGTE key-value pair text.</param>
+        /// <param name="readCrestLevelText">The text.</param>
         /// <returns>The height of the dike.</returns>
         /// <exception cref="CriticalFileReadException">When <paramref name="readCrestLevelText"/>
         /// does not represent a number.</exception>
@@ -576,25 +601,21 @@
         /// data block is invalid.</exception>
         private bool TryReadDikeRoughnessPoints(string text, DikeProfileData data, TextReader reader, ref int lineNumber)
         {
-            Match dikeGeometryMatch = new Regex(dikeGeometryPattern).Match(text);
+            Match dikeGeometryMatch = new Regex(@"^DIJK(\s+(?<dikegeometry>.+?)?)?\s*$").Match(text);
             if (dikeGeometryMatch.Success)
             {
                 string readDikeGeometryCountText = dikeGeometryMatch.Groups["dikegeometry"].Value;
                 int numberOfElements = ParseNumberOfDikeElements(lineNumber, readDikeGeometryCountText);
 
-                if (numberOfElements < 0)
-                {
-                    string message = string.Format(Resources.DikeProfileDataReader_ReadDikeProfileData_DikeCount_cannot_be_negative,
-                                                   numberOfElements);
-                    throw CreateCriticalFileReadException(lineNumber, message);
-                }
+                ValidateDikePointCount(numberOfElements, lineNumber);
+
                 if (numberOfElements == 0)
                 {
                     readParameters |= ParametersFoundInFile.DIJK;
                     return true;
                 }
+                
                 data.DikeGeometry = new RoughnessPoint[numberOfElements];
-
                 for (int i = 0; i < numberOfElements; i++)
                 {
                     lineNumber++;
@@ -645,20 +666,36 @@
         }
 
         /// <summary>
-        /// Attempts to match the given text to a roughness-point value triplet. If a match
-        /// is found, the values are parsed and validated. If valid, the resulting <see cref="RoughnessPoint"/>
+        /// Validates the number of dike points to be read from file.
+        /// </summary>
+        /// <param name="numberOfElements">The number of elements.</param>
+        /// <param name="lineNumber">The line number.</param>
+        /// <exception cref="CriticalFileReadException">When <paramref name="numberOfElements"/>
+        /// is negative.</exception>
+        private void ValidateDikePointCount(int numberOfElements, int lineNumber)
+        {
+            if (numberOfElements < 0)
+            {
+                string message = string.Format(Resources.DikeProfileDataReader_ReadDikeProfileData_DikeCount_cannot_be_negative,
+                                               numberOfElements);
+                throw CreateCriticalFileReadException(lineNumber, message);
+            }
+        }
+
+        /// <summary>
+        /// Matches the given text to a roughness-point value triplet. If a match is found,
+        /// the values are parsed and validated. If valid, the resulting <see cref="RoughnessPoint"/>
         /// based on the values will be returned.
         /// </summary>
         /// <param name="text">The text.</param>
         /// <param name="lineNumber">The line number.</param>
-        /// <returns><c>True</c> if the text matches a roughness-point value triplet and
-        /// has been validated successfully; <c>false</c> otherwise.</returns>
+        /// <returns>A <see cref="RoughnessPoint"/> instance built using data in <paramref name="text"/>.</returns>
         /// <exception cref="CriticalFileReadException">Any parameter value in the roughness-point
         /// value triplet does not represent a valid number or the roughness parameter
         /// is not valid.</exception>
         private RoughnessPoint ReadRoughnessPoint(string text, int lineNumber)
         {
-            Match roughnessSectionDataMatch = new Regex(roughnessPointPattern).Match(text);
+            Match roughnessSectionDataMatch = new Regex(@"^(\s*)?(?<localx>.+?)?(\s+(?<localz>.+?)?(\s+(?<roughness>.+?)?)?)?\s*$").Match(text);
 
             string readLocalXText = roughnessSectionDataMatch.Groups["localx"].Value;
             double localX = ParseRoughnessPointParameter(readLocalXText, 
@@ -675,12 +712,8 @@
                 Resources.DikeProfileDataReader_ReadRoughnessPoint_Roughness_DisplayName, 
                 lineNumber);
 
-            if (roughness < 0.5 || roughness > 1.0)
-            {
-                string message = string.Format(Resources.DikeProfileDataReader_ReadRoughnessPoint_Roughness_0_must_be_in_range_LowerLimit_1_,
-                                               roughness, 0.5);
-                throw CreateCriticalFileReadException(lineNumber, message);
-            }
+            ValidateRoughness(roughness, lineNumber);
+
             return new RoughnessPoint(new Point2D(localX, localY), roughness);
         }
 
@@ -714,6 +747,23 @@
         }
 
         /// <summary>
+        /// Validates the roughness.
+        /// </summary>
+        /// <param name="roughness">The roughness.</param>
+        /// <param name="lineNumber">The line number.</param>
+        /// <exception cref="CriticalFileReadException">When <paramref name="roughness"/>
+        /// is outside the range [0.5, 1].</exception>
+        private void ValidateRoughness(double roughness, int lineNumber)
+        {
+            if (roughness < 0.5 || roughness > 1.0)
+            {
+                string message = string.Format(Resources.DikeProfileDataReader_ReadRoughnessPoint_Roughness_0_must_be_in_range_LowerLimit_1_,
+                                               roughness, 0.5);
+                throw CreateCriticalFileReadException(lineNumber, message);
+            }
+        }
+
+        /// <summary>
         /// Attempts to match the given text to a VOORLAND key-value pair. If a match is
         /// found, the data block is being read. If valid, the value is stored.
         /// </summary>
@@ -728,18 +778,14 @@
         /// data block is invalid.</exception>
         private bool TryReadForeshoreRoughnessPoints(string text, DikeProfileData data, TextReader reader, ref int lineNumber)
         {
-            Match foreshoreGeometryMatch = new Regex(foreshoreGeometryPattern).Match(text);
+            Match foreshoreGeometryMatch = new Regex(@"^VOORLAND(\s+(?<foreshoregeometry>.+?)?)?\s*$").Match(text);
             if (foreshoreGeometryMatch.Success)
             {
                 string readForeshoreCountText = foreshoreGeometryMatch.Groups["foreshoregeometry"].Value;
                 var numberOfElements = ParseNumberOfForeshoreElements(readForeshoreCountText, lineNumber);
 
-                if (numberOfElements < 0)
-                {
-                    string message = string.Format(Resources.DikeProfileDataReader_ReadDikeProfileData_ForeshoreCount_0_cannot_be_negative,
-                                                   numberOfElements);
-                    throw CreateCriticalFileReadException(lineNumber, message);
-                }
+                ValidateForeshorePointCount(numberOfElements, lineNumber);
+
                 if (numberOfElements == 0)
                 {
                     readParameters |= ParametersFoundInFile.VOORLAND;
@@ -768,11 +814,10 @@
         }
 
         /// <summary>
-        /// Parses the number of foreshore roughness points from a piece of text representing
-        /// a VOORLAND key-value pair.
+        /// Parses the number of foreshore roughness points from a piece of text.
         /// </summary>
         /// <param name="lineNumber">The line number.</param>
-        /// <param name="readForeshoreCountText">The VOORLAND key-value pair text.</param>
+        /// <param name="readForeshoreCountText">The text.</param>
         /// <returns>The number of foreshore roughness points.</returns>
         /// <exception cref="CriticalFileReadException">When <paramref name="readForeshoreCountText"/>
         /// does not represent a number.</exception>
@@ -796,9 +841,26 @@
             }
         }
 
+        /// <summary>
+        /// Validates the number of foreshore points.
+        /// </summary>
+        /// <param name="numberOfElements">The number of elements.</param>
+        /// <param name="lineNumber">The line number.</param>
+        /// <exception cref="CriticalFileReadException">When <paramref name="numberOfElements"/>
+        /// is negative.</exception>
+        private void ValidateForeshorePointCount(int numberOfElements, int lineNumber)
+        {
+            if (numberOfElements < 0)
+            {
+                string message = string.Format(Resources.DikeProfileDataReader_ReadDikeProfileData_ForeshoreCount_0_cannot_be_negative,
+                                               numberOfElements);
+                throw CreateCriticalFileReadException(lineNumber, message);
+            }
+        }
+
         private bool TryReadMemo(string text, DikeProfileData data, StreamReader reader)
         {
-            Match memoMatch = new Regex(memoPattern).Match(text);
+            Match memoMatch = new Regex(@"^MEMO\s*$").Match(text);
             if (memoMatch.Success)
             {
                 data.Memo = reader.ReadToEnd();
@@ -841,7 +903,7 @@
         }
 
         /// <summary>
-        /// Throws a configured instance of <see cref="CriticalFileReadException"/>.
+        /// Returns a configured instance of <see cref="CriticalFileReadException"/>.
         /// </summary>
         /// <param name="currentLine">The line number being read.</param>
         /// <param name="criticalErrorMessage">The critical error message.</param>
@@ -855,7 +917,6 @@
             return new CriticalFileReadException(message, innerException);
         }
 
-
         private void ValidateNoMissingParameters()
         {
             string[] missingParameters = GetMissingParameterNames();
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Properties/Resources.Designer.cs
===================================================================
diff -u -r02b9c1938c77fec1599daf755bc1e7e70598621c -r9b2cc43e34e4e4202f435ea6720c8e9637db45a7
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 02b9c1938c77fec1599daf755bc1e7e70598621c)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 9b2cc43e34e4e4202f435ea6720c8e9637db45a7)
@@ -330,36 +330,36 @@
         /// <summary>
         ///   Looks up a localized string similar to De ingelezen Id ({0}) bevat spaties, welke niet zijn toegestaan..
         /// </summary>
-        internal static string DikeProfileDataReader_TryReadId_Id_0_has_unsupported_white_space {
+        internal static string DikeProfileDataReader_ValidateId_Id_0_has_unsupported_white_space {
             get {
-                return ResourceManager.GetString("DikeProfileDataReader_TryReadId_Id_0_has_unsupported_white_space", resourceCulture);
+                return ResourceManager.GetString("DikeProfileDataReader_ValidateId_Id_0_has_unsupported_white_space", resourceCulture);
             }
         }
         
         /// <summary>
         ///   Looks up a localized string similar to De ingelezen Id ({0}) is geen geldig id..
         /// </summary>
-        internal static string DikeProfileDataReader_TryReadId_Id_0_not_valid {
+        internal static string DikeProfileDataReader_ValidateId_Id_0_not_valid {
             get {
-                return ResourceManager.GetString("DikeProfileDataReader_TryReadId_Id_0_not_valid", resourceCulture);
+                return ResourceManager.GetString("DikeProfileDataReader_ValidateId_Id_0_not_valid", resourceCulture);
             }
         }
         
         /// <summary>
         ///   Looks up a localized string similar to De ingelezen orientatie waarde ({0}) moet binnen het bereik [0, 360] vallen..
         /// </summary>
-        internal static string DikeProfileDataReader_TryReadOrientation_Orientation_0_must_be_in_range {
+        internal static string DikeProfileDataReader_ValidateOrientation_Orientation_0_must_be_in_range {
             get {
-                return ResourceManager.GetString("DikeProfileDataReader_TryReadOrientation_Orientation_0_must_be_in_range", resourceCulture);
+                return ResourceManager.GetString("DikeProfileDataReader_ValidateOrientation_Orientation_0_must_be_in_range", resourceCulture);
             }
         }
         
         /// <summary>
         ///   Looks up a localized string similar to Enkel bestanden van versie &apos;4.0&apos; worden ondersteund..
         /// </summary>
-        internal static string DikeProfileDataReader_TryReadVersion_Only_version_four_zero_supported {
+        internal static string DikeProfileDataReader_ValidateVersion_Only_version_four_zero_supported {
             get {
-                return ResourceManager.GetString("DikeProfileDataReader_TryReadVersion_Only_version_four_zero_supported", resourceCulture);
+                return ResourceManager.GetString("DikeProfileDataReader_ValidateVersion_Only_version_four_zero_supported", resourceCulture);
             }
         }
         
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Properties/Resources.resx
===================================================================
diff -u -r02b9c1938c77fec1599daf755bc1e7e70598621c -r9b2cc43e34e4e4202f435ea6720c8e9637db45a7
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Properties/Resources.resx	(.../Resources.resx)	(revision 02b9c1938c77fec1599daf755bc1e7e70598621c)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Properties/Resources.resx	(.../Resources.resx)	(revision 9b2cc43e34e4e4202f435ea6720c8e9637db45a7)
@@ -144,10 +144,10 @@
   <data name="DikeProfileDataReader_ReadDikeProfileData_List_mising_parameters_0_" xml:space="preserve">
     <value>De volgende parameter(s) zijn niet aanwezig in het bestand: {0}</value>
   </data>
-  <data name="DikeProfileDataReader_TryReadVersion_Only_version_four_zero_supported" xml:space="preserve">
+  <data name="DikeProfileDataReader_ValidateVersion_Only_version_four_zero_supported" xml:space="preserve">
     <value>Enkel bestanden van versie '4.0' worden ondersteund.</value>
   </data>
-  <data name="DikeProfileDataReader_TryReadOrientation_Orientation_0_must_be_in_range" xml:space="preserve">
+  <data name="DikeProfileDataReader_ValidateOrientation_Orientation_0_must_be_in_range" xml:space="preserve">
     <value>De ingelezen orientatie waarde ({0}) moet binnen het bereik [0, 360] vallen.</value>
   </data>
   <data name="DikeProfileDataReader_ReadDikeProfileData_ProfileType_0_must_be_in_range" xml:space="preserve">
@@ -210,10 +210,10 @@
   <data name="DikeProfileLocation_DikeProfileLocation_X0_is_invalid" xml:space="preserve">
     <value>De locatie parameter 'X0' bevat een ongeldig getal.</value>
   </data>
-  <data name="DikeProfileDataReader_TryReadId_Id_0_not_valid" xml:space="preserve">
+  <data name="DikeProfileDataReader_ValidateId_Id_0_not_valid" xml:space="preserve">
     <value>De ingelezen Id ({0}) is geen geldig id.</value>
   </data>
-  <data name="DikeProfileDataReader_TryReadId_Id_0_has_unsupported_white_space" xml:space="preserve">
+  <data name="DikeProfileDataReader_ValidateId_Id_0_has_unsupported_white_space" xml:space="preserve">
     <value>De ingelezen Id ({0}) bevat spaties, welke niet zijn toegestaan.</value>
   </data>
   <data name="DikeProfileDataReader_ParseNumberOfDikeElements_DijkCount_0_not_integer" xml:space="preserve">