CRC's are now calculated whenever a CRC is found. Renamed solution file. Renamed CRCCalculator to CRCVerifier to better match what it does.

Author: RobThree

DSMR.sln DSMRParser.Net.slnDSMR.sln renamed to DSMRParser.Net.sln

@@ -33,13 +33,5 @@ public void DSMRTelegramParser_Reads_Telegram()
             Assert.AreEqual(1, result.Values.Count);
             Assert.AreEqual("ThisLineIsNotIgnored", result.GetByObisID("0-1:2.3"));
         }
-
-        [TestMethod]
-        public void DSMRTelegramParser_Ignores_CRC_For_Unknown_Versions()
-        {
-            var target = new DSMRTelegramParser();
-            var result = target.Parse("/Foo\r\n\r\n0-1:2.3(Test)\r\n!ABCD");
-            Assert.AreEqual("Test", result.GetByObisID("0-1:2.3"));
-        }
     }
 }

DSMRParser.Tests/ExtendedTelegramParserTests.cs

@@ -8,18 +8,18 @@ namespace DSMRParser.CRCHandling
     /// Implements a CRC-16-IBM CRC.
     /// </summary>
     /// <remarks>See https://en.wikipedia.org/wiki/Cyclic_redundancy_check</remarks>
-    public class CRC16Calculator : ICRCCalculator
+    public class CRC16Verifier : ICRCVerifier
     {
         /// <summary>
         /// Internal lookup table
         /// </summary>
         private readonly ushort[] _lookup = new ushort[256];
 
         /// <summary>
-        /// Initializes a new instance of a <see cref="CRC16Calculator" /> with the given polynomial (defaults to a reversed polynomial 0XA001).
+        /// Initializes a new instance of a <see cref="CRC16Verifier" /> with the given polynomial (defaults to a reversed polynomial 0XA001).
         /// </summary>
         /// <param name="polynomial">The polynomial this </param>
-        public CRC16Calculator(ushort polynomial = 0xA001)
+        public CRC16Verifier(ushort polynomial = 0xA001)
         {
             ushort value;
             ushort temp;

DSMRParser/CRCHandling/CRC16Calculator.cs DSMRParser/CRCHandling/CRC16Verifier.csDSMRParser/CRCHandling/CRC16Calculator.cs renamed to DSMRParser/CRCHandling/CRC16Verifier.cs

@@ -5,7 +5,7 @@ namespace DSMRParser.CRCHandling
     /// <summary>
     /// Provides the base interface for CRC calculation
     /// </summary>
-    public interface ICRCCalculator
+    public interface ICRCVerifier
     {
         /// <summary>
         /// Extracts the CRC of the given Telegram data and verifies it against the calculated CRC.
@@ -22,8 +22,8 @@ public interface ICRCCalculator
         ushort CalculateCRC(Span<byte> rawTelegram);
 
         /// <summary>
-        /// Returns the default CRC calculator.
+        /// Returns the default CRC verifier.
         /// </summary>
-        static ICRCCalculator Default => new CRC16Calculator();
+        static ICRCVerifier Default => new CRC16Verifier();
     }
 }

DSMRParser/CRCHandling/ICRCCalculator.cs DSMRParser/CRCHandling/ICRCVerifier.csDSMRParser/CRCHandling/ICRCCalculator.cs renamed to DSMRParser/CRCHandling/ICRCVerifier.cs

@@ -19,7 +19,7 @@
     <RepositoryUrl>https://github.com/RobThree/DSMR.Net</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageProjectUrl>https://github.com/RobThree/DSMR.Net</PackageProjectUrl>
-    <Version>1.0.1</Version>
+    <Version>1.0.2</Version>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseWithDocumentation|AnyCPU'">

DSMRParser/DSMRParser.csproj

@@ -17,20 +17,20 @@ namespace DSMRParser
     /// </remarks>
     public class DSMRTelegramParser : IDSMRTelegramParser
     {
-        private readonly ICRCCalculator _crc;
+        private readonly ICRCVerifier _crc;
         private const bool DEFAULTIGNORECRC = false;
 
         /// <summary>
-        /// Initializes a new instance of a <see cref="DSMRTelegramParser"/> with a default <see cref="ICRCCalculator"/>.
+        /// Initializes a new instance of a <see cref="DSMRTelegramParser"/> with a default <see cref="ICRCVerifier"/>.
         /// </summary>
         public DSMRTelegramParser()
-            : this(ICRCCalculator.Default) { }
+            : this(ICRCVerifier.Default) { }
 
         /// <summary>
-        /// Initializes a new instance of a <see cref="DSMRTelegramParser"/> with a given <see cref="ICRCCalculator"/>.
+        /// Initializes a new instance of a <see cref="DSMRTelegramParser"/> with a given <see cref="ICRCVerifier"/>.
         /// </summary>
-        /// <exception cref="ArgumentNullException"/>Thrown when the <param name="crcCalculator"/> is null.
-        public DSMRTelegramParser(ICRCCalculator crcCalculator) => _crc = crcCalculator ?? throw new ArgumentNullException(nameof(crcCalculator));
+        /// <exception cref="ArgumentNullException"/>Thrown when the <param name="crcVerifier"/> is null.
+        public DSMRTelegramParser(ICRCVerifier crcVerifier) => _crc = crcVerifier ?? throw new ArgumentNullException(nameof(crcVerifier));
 
         /// <summary>
         /// Parses a DSMR telegram in raw byte form into a <see cref="Telegram"/>.
@@ -140,24 +140,25 @@ public Telegram Parse(Span<byte> telegram, bool ignoreCrc = DEFAULTIGNORECRC)
             if (telegram[0] == (byte)'/')
             {
                 // Get individual lines
-                var lines = Encoding.ASCII.GetString(telegram).Split("\r\n");
+                var lines = Encoding.ASCII.GetString(telegram).Split("\r\n", StringSplitOptions.RemoveEmptyEntries);
+
+                // Do we have a CRC, then check it!
+                if (!ignoreCrc && lines[^1][0] == '!' && lines[^1].Length > 1)
+                {
+                    var crcex = _crc.Verify(telegram);
+                    if (crcex != null)  // CRC failed?
+                        return crcex;   // Return exception from CRCVerifier
+                }
 
                 result = new Telegram(
                                 lines[0].TrimStart('/'),    // Get identification (part after the "/" of the first line)
-                                lines.Skip(2)               // Skip identification and mandatory empty line
+                                lines.Skip(1)               // Skip identification (mandatory empty line has already been removed by Split method)
                                     .Where(l => !string.IsNullOrEmpty(l) && char.IsDigit(l[0])) // Only process lines starting with a digit
                                     .Select(l => (          // Parse values from telegram data
                                         OBISId.FromString(l.Substring(0, Math.Max(0, l.IndexOf("(", StringComparison.Ordinal)))), GetValues(l)
                                     ))
                 );
 
-                if (!ignoreCrc && result.DSMRVersion >= 40)
-                {
-                    var crcex = _crc.Verify(telegram);
-                    if (crcex != null)  // CRC failed?
-                        return crcex;   // Return exception froom CRCCalculator
-                }
-
                 return null;    // No exceptions, all went well!
             }
             // If we reache this point it must be an invalid format.

DSMRParser/DSMRTelegramParser.cs

@@ -477,15 +477,15 @@ protected static IEnumerable<byte> DecodeHexString(string? value)
         /// <summary>
         /// Gets the string representation of this <see cref="Telegram"/>.
         /// </summary>
-        /// <param name="crcCalculator">
-        /// The <see cref="ICRCCalculator"/> to use when determining the CRC for the telegram. Defaults to <see cref="ICRCCalculator.Default"/>.
+        /// <param name="crcVerifier">
+        /// The <see cref="ICRCVerifier"/> to use when determining the CRC for the telegram. Defaults to <see cref="ICRCVerifier.Default"/>.
         /// </param>
         /// <returns>The string representation of this <see cref="Telegram"/>.</returns>
-        public string AsString(ICRCCalculator? crcCalculator = null)
+        public string AsString(ICRCVerifier? crcVerifier = null)
         {
             var values = string.Join("\r\n", Values.Select(kv => $"{kv.Key}({string.Join(")(", kv.Value)})"));
             var telegram = $"/{Identification}\r\n\r\n{values}\r\n!";
-            var crc = (crcCalculator ?? ICRCCalculator.Default).CalculateCRC(Encoding.ASCII.GetBytes(telegram));
+            var crc = (crcVerifier ?? ICRCVerifier.Default).CalculateCRC(Encoding.ASCII.GetBytes(telegram));
             return $"{telegram}{crc:X4}\r\n";
         }
     }