GetCommandClass is no longer nullable

jdomnitz · jdomnitz · commit dfb8d42acd0e · 2025-01-14T21:21:55.000-05:00
diff --git a/Examples.md b/Examples.md
@@ -48,33 +48,32 @@ _Line 2 Begins smart start inclusion._
 The list of command classes can be enumerated or you can get a specific command class directly and call commands.
 ```c#
 CancellationTokenSource cts = new CancellationTokenSource(5000);
-List<CommandClass> lst = await controller.Nodes[3].GetCommandClass<Security2>()!.GetSupportedCommands(cts.Token);
+List<CommandClass> lst = await controller.Nodes[3].GetCommandClass<Security2>().GetSupportedCommands(cts.Token);
 ```
 
 #### Notifications:
 Command classes have events which can be subscribed to for events/notifications.
 ```c#
-controller.Nodes[3].GetCommandClass<Meter>()!.Update += Meter_Update;
+controller.Nodes[3].GetCommandClass<Meter>().Update += Meter_Update;
 
-async Task Meter_Update(Node sender, CommandClassEventArgs args)
+async Task Meter_Updated(Node sender, CommandClassEventArgs<MeterReport> args)
 {
-    MeterReport mr = (MeterReport)args.Report!;
-    Console.WriteLine($"Meter Update: {mr.Value} {mr.Unit}");
+    Console.WriteLine($"Meter Update: {args.Report!.Value} {args.Report!.Unit}");
 }
 ```
 
 #### Broadcast Commands:
 The controller contains a broadcast node with a set of command classes prepopulated. Broadcast commands do not reflect what command classes the network may or may not support.
 ```c#
-await controller.BroadcastNode.GetCommandClass<SwitchBinary>()!.Set(true);
+await controller.BroadcastNode.GetCommandClass<SwitchBinary>().Set(true);
 ```
 _This example turns on all switches in the network_
 
 #### Multicast Commands:
 The controller can create Multicast Groups of multiple Nodes. Multicast Command Classes will be the minimum set supported by all group members.
 ```c#
 1: NodeGroup group = controller.CreateGroup(node1, node2);
-2: await group.GetCommandClass<SwitchBinary>()!.Set(true, TimeSpan.FromSeconds(1));
+2: await group.GetCommandClass<SwitchBinary>().Set(true, TimeSpan.FromSeconds(1));
 ```
 _Line 1 Creates a group with two members._\
-_Line 2 Turn on all binary switches in the group with a single multicast command._
+_Line 2 Turn on both binary switches in the group with a single multicast command._
diff --git a/TestConsole/TestConsole.cs b/TestConsole/TestConsole.cs
@@ -147,19 +147,19 @@ private static async Task Controller_NodeReady(Node node)
         private static void AttachListeners(Node node)
         {
             if (node.HasCommandClass(CommandClass.SensorMultiLevel))
-                node.GetCommandClass<SensorMultiLevel>()!.Updated += Node_Updated;
+                node.GetCommandClass<SensorMultiLevel>().Updated += Node_Updated;
             if (node.HasCommandClass(CommandClass.Meter))
                 node.GetCommandClass<Meter>()!.Updated += Node_Updated;
             if (node.HasCommandClass(CommandClass.Notification) && node.GetCommandClass<Notification>() is Notification not) //ZWave Weirdness
                 not.Updated += Node_Updated;
             if (node.HasCommandClass(CommandClass.Battery))
-                node.GetCommandClass<Battery>()!.Status += Node_Updated;
+                node.GetCommandClass<Battery>().Status += Node_Updated;
             if (node.HasCommandClass(CommandClass.SensorBinary))
-                node.GetCommandClass<SensorBinary>()!.Updated += Node_Updated;
+                node.GetCommandClass<SensorBinary>().Updated += Node_Updated;
             if (node.HasCommandClass(CommandClass.SensorAlarm))
-                node.GetCommandClass<SensorAlarm>()!.Alarm += Node_Updated;
+                node.GetCommandClass<SensorAlarm>().Alarm += Node_Updated;
             if (node.HasCommandClass(CommandClass.SwitchBinary))
-                node.GetCommandClass<SwitchBinary>()!.SwitchReport += Node_Updated;
+                node.GetCommandClass<SwitchBinary>().SwitchReport += Node_Updated;
         }
 
         private static Task Node_Updated<T>(Node sender, CommandClassEventArgs<T> args) where T : ICommandClassReport
diff --git a/ZWaveDotNet/CommandClasses/CommandClassBase.cs b/ZWaveDotNet/CommandClasses/CommandClassBase.cs
@@ -357,9 +357,9 @@ internal async Task<bool> SendCommand(CommandMessage data, CancellationToken tok
                     throw new InvalidOperationException("Secure command requires security manager");
                 SecurityManager.NetworkKey key = controller.SecurityManager.GetHighestKey(node.ID) ?? throw new InvalidOperationException($"Command classes are secure but no keys exist for node {node.ID}");
                 if (key.Key == SecurityManager.RecordType.S0)
-                    await node.GetCommandClass<Security0>()!.Encapsulate(data.Payload, token).ConfigureAwait(false);
+                    await node.GetCommandClass<Security0>().Encapsulate(data.Payload, token).ConfigureAwait(false);
                 else if (key.Key > SecurityManager.RecordType.S0)
-                    await node.GetCommandClass<Security2>()!.Encapsulate(data.Payload, key.Key, token).ConfigureAwait(false);
+                    await node.GetCommandClass<Security2>().Encapsulate(data.Payload, key.Key, token).ConfigureAwait(false);
                 else
                     throw new InvalidOperationException("Security required but no keys are available");
             }
diff --git a/ZWaveDotNet/CommandClasses/Security0.cs b/ZWaveDotNet/CommandClasses/Security0.cs
@@ -169,7 +169,7 @@ internal async Task Encapsulate(List<byte> payload, CancellationToken cancellati
             {
                 Log.Verbose("Providing Next Nonce");
                 using CancellationTokenSource cts = new CancellationTokenSource(3000);
-                await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security0>()!.SendCommand(Security0Command.NonceReport, cts.Token, controller.SecurityManager.CreateS0Nonce(msg.SourceNodeID)).ConfigureAwait(false);
+                await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security0>().SendCommand(Security0Command.NonceReport, cts.Token, controller.SecurityManager.CreateS0Nonce(msg.SourceNodeID)).ConfigureAwait(false);
             }
 
             Log.Verbose("Decrypted: " + msg.ToString());
diff --git a/ZWaveDotNet/CommandClasses/Security2.cs b/ZWaveDotNet/CommandClasses/Security2.cs
@@ -276,7 +276,7 @@ internal async Task Encapsulate(List<byte> payload, SecurityManager.RecordType?
                 else if (controller.SecurityManager.HasKey(msg.SourceNodeID, SecurityManager.RecordType.ECDH_TEMP))
                 {
                     using (CancellationTokenSource cts = new CancellationTokenSource(3000))
-                    await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security2>()!.KexFail(KexFailType.KEX_FAIL_KEY_VERIFY).ConfigureAwait(false);
+                    await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security2>().KexFail(KexFailType.KEX_FAIL_KEY_VERIFY).ConfigureAwait(false);
                     if (networkKey.Key != SecurityManager.RecordType.ECDH_TEMP)
                         controller.SecurityManager.RevokeKey(msg.SourceNodeID, networkKey.Key);
                     return null;
@@ -288,7 +288,7 @@ internal async Task Encapsulate(List<byte> payload, SecurityManager.RecordType?
                         Log.Warning("Declaring SPAN failed and sending SOS");
                         controller.SecurityManager.PurgeRecords(msg.SourceNodeID, networkKey.Key);
                         using (CancellationTokenSource cts = new CancellationTokenSource(3000))
-                        await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security2>()!.SendNonceReport(true, false, false, cts.Token).ConfigureAwait(false);
+                        await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security2>().SendNonceReport(true, false, false, cts.Token).ConfigureAwait(false);
                     }
                     catch (Exception e)
                     {
diff --git a/ZWaveDotNet/CommandClasses/TransportService.cs b/ZWaveDotNet/CommandClasses/TransportService.cs
@@ -82,7 +82,7 @@ internal static async Task<bool> Transmit (DataMessage message, CancellationToke
             for (int i = 0; i < message.Data.Count; i += MAX_SEGMENT)
             {
                 DataMessage segment = new DataMessage(message.Controller, message.DestinationNodeID, message.Data.GetRange(i, Math.Min(message.Data.Count, i + MAX_SEGMENT) - i), true, (message.Options & TransmitOptions.ExploreNPDUs) == TransmitOptions.ExploreNPDUs);
-                success &= await message.Controller.Nodes[message.SourceNodeID].GetCommandClass<TransportService>()!.TransmitSegment(segment, sessionId, i, message.Data.Count, token);
+                success &= await message.Controller.Nodes[message.SourceNodeID].GetCommandClass<TransportService>().TransmitSegment(segment, sessionId, i, message.Data.Count, token);
             }
             return success;
         }
@@ -176,7 +176,7 @@ private async Task<bool> TransmitSegment(DataMessage msg, byte sessionId, int of
                             if (!msg.IsMulticastMethod)
                             {
                                 CancellationTokenSource cts = new CancellationTokenSource(5000);
-                                await controller.Nodes[msg.SourceNodeID].GetCommandClass<TransportService>()!.RequestRetransmission(sessionId, 0, cts.Token);
+                                await controller.Nodes[msg.SourceNodeID].GetCommandClass<TransportService>().RequestRetransmission(sessionId, 0, cts.Token);
                             }
                             return null;
                         }
@@ -196,7 +196,7 @@ private async Task<bool> TransmitSegment(DataMessage msg, byte sessionId, int of
                             buffers.Remove(key);
                             segments.Remove(key);
                             CancellationTokenSource cts = new CancellationTokenSource(5000);
-                            await controller.Nodes[msg.SourceNodeID].GetCommandClass<TransportService>()!.SendComplete(sessionId, cts.Token);
+                            await controller.Nodes[msg.SourceNodeID].GetCommandClass<TransportService>().SendComplete(sessionId, cts.Token);
                             return fullMessage;
                         }
                         break;
@@ -232,7 +232,7 @@ internal override async Task<SupervisionStatus> Handle(ReportMessage msg)
                         Log.Information("Retransmitting segment " + offset + " for session " + (msg.Payload.Span[0] >> 4));
 
                         DataMessage segment = new DataMessage(message.Controller, message.DestinationNodeID, message.Data.GetRange(offset, Math.Min(message.Data.Count, offset + MAX_SEGMENT) - offset), true, (message.Options & TransmitOptions.ExploreNPDUs) == TransmitOptions.ExploreNPDUs);
-                        await message.Controller.Nodes[message.SourceNodeID].GetCommandClass<TransportService>()!.TransmitSegment(segment, (byte)(msg.Payload.Span[0] >> 4), offset, message.Data.Count);
+                        await message.Controller.Nodes[message.SourceNodeID].GetCommandClass<TransportService>().TransmitSegment(segment, (byte)(msg.Payload.Span[0] >> 4), offset, message.Data.Count);
                     }
                     break;
             }
@@ -255,7 +255,7 @@ private static async Task<bool> CheckComplete(Controller controller, ushort sour
                         if (requestMissing)
                         {
                             Log.Information($"Requesting retransmission for session {sessionId} at index {current}");
-                            await controller.Nodes[sourceNodeId].GetCommandClass<TransportService>()!.RequestRetransmission(sessionId, current, combo.Token);
+                            await controller.Nodes[sourceNodeId].GetCommandClass<TransportService>().RequestRetransmission(sessionId, current, combo.Token);
                         }
                         else
                             Log.Information("Broadcast transport class was incomplete. Ignoring...");
diff --git a/ZWaveDotNet/Entities/Controller.cs b/ZWaveDotNet/Entities/Controller.cs
@@ -835,7 +835,7 @@ private async Task<bool> BootstrapS0(Node node)
             {
                 try
                 {
-                    Security0 sec0 = node.GetCommandClass<Security0>()!;
+                    Security0 sec0 = node.GetCommandClass<Security0>();
                     await sec0.SchemeGet(cts.Token).ConfigureAwait(false);
                     _ = Task.Run(() => sec0.KeySet(cts.Token));
                     await sec0.WaitForKeyVerified(cts.Token).ConfigureAwait(false);
@@ -858,7 +858,7 @@ private async Task<bool> BootstrapS0(Node node)
         private async Task<bool> BootstrapS2(Node node)
         {
             await Task.Delay(1000); //Give including node a chance to get ready
-            Security2 sec2 = node.GetCommandClass<Security2>()!;
+            Security2 sec2 = node.GetCommandClass<Security2>();
             Log.Information("Starting Secure S2 Inclusion");
             try
             {
diff --git a/ZWaveDotNet/Entities/Node.cs b/ZWaveDotNet/Entities/Node.cs
@@ -306,18 +306,18 @@ public bool HasCommandClass(CommandClass commandClass)
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
-        public T? GetCommandClass<T>() where T : CommandClassBase
+        public T GetCommandClass<T>() where T : CommandClassBase
         {
             CommandClass commandClass = ((CCVersion)typeof(T).GetCustomAttribute(typeof(CCVersion))!).commandClass;
             if (commandClasses.TryGetValue(commandClass, out CommandClassBase? ccb))
             {
                 if (typeof(T) == typeof(Notification) && ccb.Version <= 2)
-                    return null;
+                    throw new ArgumentException("Notification command class is not present. Fetch alarm instead");
                 if (typeof(T) == typeof(Alarm) && ccb.Version > 2)
-                    return null;
+                    throw new ArgumentException("Alarm command class is not present. Fetch Notification instead");
                 return (T)ccb;
             }
-            return null;
+            throw new ArgumentNullException("Command class does not exist on this node");
         }
 
         internal NodeJSON Serialize()
@@ -537,7 +537,7 @@ private async Task Interview(bool newlyIncluded, SecurityManager.NetworkKey? key
                     if (HasCommandClass(CommandClass.WakeUp))
                     {
                         Log.Information("Security query complete. Sleeping before continuing");
-                        await GetCommandClass<WakeUp>()!.WaitForAwake(cancellationToken);
+                        await GetCommandClass<WakeUp>().WaitForAwake(cancellationToken);
                     }
                 }
                 else
@@ -552,10 +552,10 @@ private async Task Interview(bool newlyIncluded, SecurityManager.NetworkKey? key
             if (HasCommandClass(CommandClass.MultiChannel))
             {
                 Log.Information("Requesting MultiChannel EndPoints");
-                EndPointReport epReport = await GetCommandClass<MultiChannel>()!.GetEndPoints(cancellationToken);
+                EndPointReport epReport = await GetCommandClass<MultiChannel>().GetEndPoints(cancellationToken);
                 for (int i = 0; i < epReport.IndividualEndPoints; i++)
                 {
-                    EndPointCapabilities caps = await GetCommandClass<MultiChannel>()!.GetCapabilities((byte)(i + 1), cancellationToken);
+                    EndPointCapabilities caps = await GetCommandClass<MultiChannel>().GetCapabilities((byte)(i + 1), cancellationToken);
                     endPoints.Add(new EndPoint((byte)(i + 1), this, caps.CommandClasses));
                 }
             }
diff --git a/ZWaveDotNet/Untested/FirmwareUpdate.cs b/ZWaveDotNet/Untested/FirmwareUpdate.cs
@@ -106,7 +106,7 @@ public async Task<FirmwareDataReport> GetData(byte numberOfReports, ushort repor
         public async Task DownloadAsync(string destination, CancellationToken cancellationToken = default)
         {
             FirmwareMetadataReport report = await Get(cancellationToken);
-            VersionReport version = await node.GetCommandClass<Version>()!.Get(cancellationToken);
+            VersionReport version = await node.GetCommandClass<Version>().Get(cancellationToken);
             Log.Information($"Downloading Manufacturer {report.Manufacturer}, Firmware {report.FirmwareIDs[0]}, Version {version.Firmware[0]}");
             using (FileStream fs = new FileStream(destination, FileMode.Create, FileAccess.Write))
             {
@@ -125,7 +125,7 @@ public async Task UploadAsync(string source, CancellationToken cancellationToken
             ushort checksum = 0x42; //TODO
 
             FirmwareMetadataReport report = await Get(cancellationToken);
-            VersionReport version = await node.GetCommandClass<Version>()!.Get(cancellationToken);
+            VersionReport version = await node.GetCommandClass<Version>().Get(cancellationToken);
             Log.Information($"@Downloading Manufacturer {report.Manufacturer}, Firmware {report.FirmwareIDs[0]}, Version {version.Firmware[0]}, HW {report.HardwareVersion}");
             FirmwareUpdateStatus start = await StartUpdate(report.Manufacturer, report.FirmwareIDs[0], checksum, 0x0, 28, false, report.HardwareVersion, cancellationToken);
             if (start != FirmwareUpdateStatus.Success)

Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ internal async Task Encapsulate(List<byte> payload, CancellationToken cancellati`
`169`	`169`	`{`
`170`	`170`	`Log.Verbose("Providing Next Nonce");`
`171`	`171`	`using CancellationTokenSource cts = new CancellationTokenSource(3000);`
`172`		`- await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security0>()!.SendCommand(Security0Command.NonceReport, cts.Token, controller.SecurityManager.CreateS0Nonce(msg.SourceNodeID)).ConfigureAwait(false);`
	`172`	`+ await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security0>().SendCommand(Security0Command.NonceReport, cts.Token, controller.SecurityManager.CreateS0Nonce(msg.SourceNodeID)).ConfigureAwait(false);`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`Log.Verbose("Decrypted: " + msg.ToString());`
Original file line number	Diff line number	Diff line change
`@@ -276,7 +276,7 @@ internal async Task Encapsulate(List<byte> payload, SecurityManager.RecordType?`
`276`	`276`	`else if (controller.SecurityManager.HasKey(msg.SourceNodeID, SecurityManager.RecordType.ECDH_TEMP))`
`277`	`277`	`{`
`278`	`278`	`using (CancellationTokenSource cts = new CancellationTokenSource(3000))`
`279`		`- await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security2>()!.KexFail(KexFailType.KEX_FAIL_KEY_VERIFY).ConfigureAwait(false);`
	`279`	`+ await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security2>().KexFail(KexFailType.KEX_FAIL_KEY_VERIFY).ConfigureAwait(false);`
`280`	`280`	`if (networkKey.Key != SecurityManager.RecordType.ECDH_TEMP)`
`281`	`281`	`controller.SecurityManager.RevokeKey(msg.SourceNodeID, networkKey.Key);`
`282`	`282`	`return null;`
`@@ -288,7 +288,7 @@ internal async Task Encapsulate(List<byte> payload, SecurityManager.RecordType?`
`288`	`288`	`Log.Warning("Declaring SPAN failed and sending SOS");`
`289`	`289`	`controller.SecurityManager.PurgeRecords(msg.SourceNodeID, networkKey.Key);`
`290`	`290`	`using (CancellationTokenSource cts = new CancellationTokenSource(3000))`
`291`		`- await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security2>()!.SendNonceReport(true, false, false, cts.Token).ConfigureAwait(false);`
	`291`	`+ await controller.Nodes[msg.SourceNodeID].GetCommandClass<Security2>().SendNonceReport(true, false, false, cts.Token).ConfigureAwait(false);`
`292`	`292`	`}`
`293`	`293`	`catch (Exception e)`
`294`	`294`	`{`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ internal static async Task<bool> Transmit (DataMessage message, CancellationToke`
`82`	`82`	`for (int i = 0; i < message.Data.Count; i += MAX_SEGMENT)`
`83`	`83`	`{`
`84`	`84`	`DataMessage segment = new DataMessage(message.Controller, message.DestinationNodeID, message.Data.GetRange(i, Math.Min(message.Data.Count, i + MAX_SEGMENT) - i), true, (message.Options & TransmitOptions.ExploreNPDUs) == TransmitOptions.ExploreNPDUs);`
`85`		`- success &= await message.Controller.Nodes[message.SourceNodeID].GetCommandClass<TransportService>()!.TransmitSegment(segment, sessionId, i, message.Data.Count, token);`
	`85`	`+ success &= await message.Controller.Nodes[message.SourceNodeID].GetCommandClass<TransportService>().TransmitSegment(segment, sessionId, i, message.Data.Count, token);`
`86`	`86`	`}`
`87`	`87`	`return success;`
`88`	`88`	`}`
`@@ -176,7 +176,7 @@ private async Task<bool> TransmitSegment(DataMessage msg, byte sessionId, int of`
`176`	`176`	`if (!msg.IsMulticastMethod)`
`177`	`177`	`{`
`178`	`178`	`CancellationTokenSource cts = new CancellationTokenSource(5000);`
`179`		`- await controller.Nodes[msg.SourceNodeID].GetCommandClass<TransportService>()!.RequestRetransmission(sessionId, 0, cts.Token);`
	`179`	`+ await controller.Nodes[msg.SourceNodeID].GetCommandClass<TransportService>().RequestRetransmission(sessionId, 0, cts.Token);`
`180`	`180`	`}`
`181`	`181`	`return null;`
`182`	`182`	`}`
`@@ -196,7 +196,7 @@ private async Task<bool> TransmitSegment(DataMessage msg, byte sessionId, int of`
`196`	`196`	`buffers.Remove(key);`
`197`	`197`	`segments.Remove(key);`
`198`	`198`	`CancellationTokenSource cts = new CancellationTokenSource(5000);`
`199`		`- await controller.Nodes[msg.SourceNodeID].GetCommandClass<TransportService>()!.SendComplete(sessionId, cts.Token);`
	`199`	`+ await controller.Nodes[msg.SourceNodeID].GetCommandClass<TransportService>().SendComplete(sessionId, cts.Token);`
`200`	`200`	`return fullMessage;`
`201`	`201`	`}`
`202`	`202`	`break;`
`@@ -232,7 +232,7 @@ internal override async Task<SupervisionStatus> Handle(ReportMessage msg)`
`232`	`232`	`Log.Information("Retransmitting segment " + offset + " for session " + (msg.Payload.Span[0] >> 4));`
`233`	`233`
`234`	`234`	`DataMessage segment = new DataMessage(message.Controller, message.DestinationNodeID, message.Data.GetRange(offset, Math.Min(message.Data.Count, offset + MAX_SEGMENT) - offset), true, (message.Options & TransmitOptions.ExploreNPDUs) == TransmitOptions.ExploreNPDUs);`
`235`		`- await message.Controller.Nodes[message.SourceNodeID].GetCommandClass<TransportService>()!.TransmitSegment(segment, (byte)(msg.Payload.Span[0] >> 4), offset, message.Data.Count);`
	`235`	`+ await message.Controller.Nodes[message.SourceNodeID].GetCommandClass<TransportService>().TransmitSegment(segment, (byte)(msg.Payload.Span[0] >> 4), offset, message.Data.Count);`
`236`	`236`	`}`
`237`	`237`	`break;`
`238`	`238`	`}`
`@@ -255,7 +255,7 @@ private static async Task<bool> CheckComplete(Controller controller, ushort sour`
`255`	`255`	`if (requestMissing)`
`256`	`256`	`{`
`257`	`257`	`Log.Information($"Requesting retransmission for session {sessionId} at index {current}");`
`258`		`- await controller.Nodes[sourceNodeId].GetCommandClass<TransportService>()!.RequestRetransmission(sessionId, current, combo.Token);`
	`258`	`+ await controller.Nodes[sourceNodeId].GetCommandClass<TransportService>().RequestRetransmission(sessionId, current, combo.Token);`
`259`	`259`	`}`
`260`	`260`	`else`
`261`	`261`	`Log.Information("Broadcast transport class was incomplete. Ignoring...");`
Original file line number	Diff line number	Diff line change
`@@ -835,7 +835,7 @@ private async Task<bool> BootstrapS0(Node node)`
`835`	`835`	`{`
`836`	`836`	`try`
`837`	`837`	`{`
`838`		`- Security0 sec0 = node.GetCommandClass<Security0>()!;`
	`838`	`+ Security0 sec0 = node.GetCommandClass<Security0>();`
`839`	`839`	`await sec0.SchemeGet(cts.Token).ConfigureAwait(false);`
`840`	`840`	`_ = Task.Run(() => sec0.KeySet(cts.Token));`
`841`	`841`	`await sec0.WaitForKeyVerified(cts.Token).ConfigureAwait(false);`
`@@ -858,7 +858,7 @@ private async Task<bool> BootstrapS0(Node node)`
`858`	`858`	`private async Task<bool> BootstrapS2(Node node)`
`859`	`859`	`{`
`860`	`860`	`await Task.Delay(1000); //Give including node a chance to get ready`
`861`		`- Security2 sec2 = node.GetCommandClass<Security2>()!;`
	`861`	`+ Security2 sec2 = node.GetCommandClass<Security2>();`
`862`	`862`	`Log.Information("Starting Secure S2 Inclusion");`
`863`	`863`	`try`
`864`	`864`	`{`
Original file line number	Diff line number	Diff line change
`@@ -306,18 +306,18 @@ public bool HasCommandClass(CommandClass commandClass)`
`306`	`306`	`/// </summary>`
`307`	`307`	`/// <typeparam name="T"></typeparam>`
`308`	`308`	`/// <returns></returns>`
`309`		`- public T? GetCommandClass<T>() where T : CommandClassBase`
	`309`	`+ public T GetCommandClass<T>() where T : CommandClassBase`
`310`	`310`	`{`
`311`	`311`	`CommandClass commandClass = ((CCVersion)typeof(T).GetCustomAttribute(typeof(CCVersion))!).commandClass;`
`312`	`312`	`if (commandClasses.TryGetValue(commandClass, out CommandClassBase? ccb))`
`313`	`313`	`{`
`314`	`314`	`if (typeof(T) == typeof(Notification) && ccb.Version <= 2)`
`315`		`- return null;`
	`315`	`+ throw new ArgumentException("Notification command class is not present. Fetch alarm instead");`
`316`	`316`	`if (typeof(T) == typeof(Alarm) && ccb.Version > 2)`
`317`		`- return null;`
	`317`	`+ throw new ArgumentException("Alarm command class is not present. Fetch Notification instead");`
`318`	`318`	`return (T)ccb;`
`319`	`319`	`}`
`320`		`- return null;`
	`320`	`+ throw new ArgumentNullException("Command class does not exist on this node");`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`internal NodeJSON Serialize()`
`@@ -537,7 +537,7 @@ private async Task Interview(bool newlyIncluded, SecurityManager.NetworkKey? key`
`537`	`537`	`if (HasCommandClass(CommandClass.WakeUp))`
`538`	`538`	`{`
`539`	`539`	`Log.Information("Security query complete. Sleeping before continuing");`
`540`		`- await GetCommandClass<WakeUp>()!.WaitForAwake(cancellationToken);`
	`540`	`+ await GetCommandClass<WakeUp>().WaitForAwake(cancellationToken);`
`541`	`541`	`}`
`542`	`542`	`}`
`543`	`543`	`else`
`@@ -552,10 +552,10 @@ private async Task Interview(bool newlyIncluded, SecurityManager.NetworkKey? key`
`552`	`552`	`if (HasCommandClass(CommandClass.MultiChannel))`
`553`	`553`	`{`
`554`	`554`	`Log.Information("Requesting MultiChannel EndPoints");`
`555`		`- EndPointReport epReport = await GetCommandClass<MultiChannel>()!.GetEndPoints(cancellationToken);`
	`555`	`+ EndPointReport epReport = await GetCommandClass<MultiChannel>().GetEndPoints(cancellationToken);`
`556`	`556`	`for (int i = 0; i < epReport.IndividualEndPoints; i++)`
`557`	`557`	`{`
`558`		`- EndPointCapabilities caps = await GetCommandClass<MultiChannel>()!.GetCapabilities((byte)(i + 1), cancellationToken);`
	`558`	`+ EndPointCapabilities caps = await GetCommandClass<MultiChannel>().GetCapabilities((byte)(i + 1), cancellationToken);`
`559`	`559`	`endPoints.Add(new EndPoint((byte)(i + 1), this, caps.CommandClasses));`
`560`	`560`	`}`
`561`	`561`	`}`