Enable nullable reference type warnings

FantasyTeddy · FantasyTeddy · commit 80798880fa9d · 2026-06-05T14:16:49.000+02:00
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -6,5 +6,6 @@
    <PackageProjectUrl>https://github.com/sharpbrick/powered-up</PackageProjectUrl>
    <RepositoryUrl>https://github.com/sharpbrick/powered-up</RepositoryUrl>
    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+   <Nullable>warnings</Nullable>
  </PropertyGroup>
 </Project>
diff --git a/examples/SharpBrick.PoweredUp.Examples/BaseExample.cs b/examples/SharpBrick.PoweredUp.Examples/BaseExample.cs
@@ -31,7 +31,7 @@ public async Task InitExampleAndDiscoverAsync(IServiceProvider serviceProvider,
 
         Host = serviceProvider.GetService<PoweredUpHost>();
 
-        Log = serviceProvider.GetService<ILoggerFactory>().CreateLogger("Example");
+        Log = serviceProvider.GetRequiredService<ILoggerFactory>().CreateLogger("Example");
 
         var enableTrace = bool.TryParse(configuration["EnableTrace"], out var x) && x;
 
@@ -49,7 +49,7 @@ public virtual Task DiscoverAsync(bool enableTrace)
             // add this when you are interested in a tracing of the message ("human readable")
             if (enableTrace)
             {
-                var tracer = hub.ServiceProvider.GetService<TraceMessages>();
+                var tracer = hub.ServiceProvider.GetRequiredService<TraceMessages>();
                 await tracer.ExecuteAsync();
             }
 
diff --git a/examples/SharpBrick.PoweredUp.Examples/ExampleCalibrationSteering.cs b/examples/SharpBrick.PoweredUp.Examples/ExampleCalibrationSteering.cs
@@ -14,7 +14,7 @@ public override async Task ExecuteAsync()
 
         var motor = technicMediumHub.A.GetDevice<TechnicLargeLinearMotor>();
 
-        var calibration = ServiceProvider.GetService<LinearMidCalibration>();
+        var calibration = ServiceProvider.GetRequiredService<LinearMidCalibration>();
         await calibration.ExecuteAsync(motor);
         await technicMediumHub.WaitButtonClickAsync();
 
diff --git a/examples/SharpBrick.PoweredUp.Examples/ExampleRampUp.cs b/examples/SharpBrick.PoweredUp.Examples/ExampleRampUp.cs
@@ -18,7 +18,7 @@ public override async Task ExecuteAsync()
         var motor = technicMediumHub.A.GetDevice<TechnicLargeLinearMotor>();
 
         // ramp up with linear speed
-        var rampUp = ServiceProvider.GetService<LinearSpeedChange>();
+        var rampUp = ServiceProvider.GetRequiredService<LinearSpeedChange>();
 
         await technicMediumHub.RgbLight.SetRgbColorNoAsync(PoweredUpColor.Red);
 
@@ -33,7 +33,7 @@ public override async Task ExecuteAsync()
         await technicMediumHub.RgbLight.SetRgbColorNoAsync(PoweredUpColor.Orange);
 
         // ramp down with linear speed
-        var rampDown = ServiceProvider.GetService<LinearSpeedChange>();
+        var rampDown = ServiceProvider.GetRequiredService<LinearSpeedChange>();
 
         var beforeOrangePhase = stopWatch.ElapsedMilliseconds;
         await rampDown.ExecuteAsync(motor, 100, 0, 100, 20_000);
diff --git a/examples/SharpBrick.PoweredUp.Examples/Program.cs b/examples/SharpBrick.PoweredUp.Examples/Program.cs
@@ -35,7 +35,7 @@ static async Task Main(string[] args)
         var typeToExecute = Assembly
             .GetExecutingAssembly()
             .GetTypes()
-            .FirstOrDefault(x => x.FullName.StartsWith($"Example.Example{exampleToExecute}"));
+            .FirstOrDefault(x => x.FullName?.StartsWith($"Example.Example{exampleToExecute}") == true);
 
         if (typeToExecute is null)
         {
@@ -45,7 +45,11 @@ static async Task Main(string[] args)
         }
 
         var example = Activator.CreateInstance(typeToExecute) as Example.BaseExample;
-
+        if (example is null)
+        {
+            Console.WriteLine("Could not create example instance.");
+            return;
+        }
 
         // (2) build the DI container
         var serviceCollection = new ServiceCollection();
diff --git a/examples/SharpBrick.PoweredUp.ExampplesOnProtocol/Program.cs b/examples/SharpBrick.PoweredUp.ExampplesOnProtocol/Program.cs
@@ -15,8 +15,8 @@
     .BuildServiceProvider();
 
 // getting utilities
-var bt = serviceProvider.GetService<IPoweredUpBluetoothAdapter>();
-var host = serviceProvider.GetService<PoweredUpHost>();
+var bt = serviceProvider.GetRequiredService<IPoweredUpBluetoothAdapter>();
+var host = serviceProvider.GetRequiredService<PoweredUpHost>();
 
 // discover a LWP bluetooth device 
 var tcs = new TaskCompletionSource<ILegoWirelessProtocol>();
diff --git a/src/SharpBrick.PoweredUp.BlueGigaBLE/BlueGigaBLEPoweredUpBluetoothAdapater.cs b/src/SharpBrick.PoweredUp.BlueGigaBLE/BlueGigaBLEPoweredUpBluetoothAdapater.cs
@@ -85,8 +85,7 @@ async void GAPScanResponseEvent(object sender, BleScanResponseReceivedEventArgs
             //we only want to discover Lego-devices
             //filter for correct service-GUID for LEGO-Hub, containing manufacturerData and the name
             var addressNumber = BlueGigaBLEHelper.ByteArrayToUlong(e.Address);
-            var bleAdvertisingListFound = bleParsedData.TryGetValue(addressNumber, out var actualListAdvertisingData);
-            if (!bleAdvertisingListFound)
+            if (!bleParsedData.TryGetValue(addressNumber, out var actualListAdvertisingData))
             {
                 actualListAdvertisingData = bleParsedData.AddOrUpdate(addressNumber, new List<BleAdvertisingData>(), (oldkey, oldvalue) => oldvalue = new List<BleAdvertisingData>());
             }
diff --git a/src/SharpBrick.PoweredUp.Cli/Program.cs b/src/SharpBrick.PoweredUp.Cli/Program.cs
@@ -86,9 +86,9 @@ static async Task<int> Main(string[] args)
 
                             await AddTraceWriterAsync(scopedServiceProvider, enableTrace);
 
-                            scopedServiceProvider.GetService<BluetoothKernel>().BluetoothDeviceInfo = bluetoothDeviceInfo;
+                            scopedServiceProvider.GetRequiredService<BluetoothKernel>().BluetoothDeviceInfo = bluetoothDeviceInfo;
 
-                            var deviceListCli = scopedServiceProvider.GetService<DevicesList>(); // ServiceLocator ok: transient factory
+                            var deviceListCli = scopedServiceProvider.GetRequiredService<DevicesList>(); // ServiceLocator ok: transient factory
 
                             await deviceListCli.ExecuteAsync(systemType);
                         }
@@ -138,11 +138,11 @@ static async Task<int> Main(string[] args)
 
                             await AddTraceWriterAsync(scopedServiceProvider, enableTrace);
 
-                            scopedServiceProvider.GetService<BluetoothKernel>().BluetoothDeviceInfo = bluetoothDeviceInfo;
+                            scopedServiceProvider.GetRequiredService<BluetoothKernel>().BluetoothDeviceInfo = bluetoothDeviceInfo;
 
-                            var dumpStaticPortInfoCommand = scopedServiceProvider.GetService<DumpStaticPortInfo>(); // ServiceLocator ok: transient factory
+                            var dumpStaticPortInfoCommand = scopedServiceProvider.GetRequiredService<DumpStaticPortInfo>(); // ServiceLocator ok: transient factory
 
-                            var port = byte.Parse(portOption.Value());
+                            var port = byte.TryParse(portOption.Value(), out var parsedPort) ? parsedPort : (byte)0;
 
                             await dumpStaticPortInfoCommand.ExecuteAsync(systemType, port, headerEnabled);
                         }
@@ -193,7 +193,7 @@ static async Task<int> Main(string[] args)
 
                             await AddTraceWriterAsync(scopedServiceProvider, enableTrace);
 
-                            var prettyPrintCommand = scopedServiceProvider.GetService<PrettyPrint>(); // ServiceLocator ok: transient factory
+                            var prettyPrintCommand = scopedServiceProvider.GetRequiredService<PrettyPrint>(); // ServiceLocator ok: transient factory
 
                             TextReader reader = Console.In;
 
@@ -273,7 +273,7 @@ public static async Task AddTraceWriterAsync(IServiceProvider serviceProvider, b
     {
         if (enableTrace)
         {
-            var traceMessages = serviceProvider.GetService<TraceMessages>(); // ServiceLocator ok: transient factory
+            var traceMessages = serviceProvider.GetRequiredService<TraceMessages>(); // ServiceLocator ok: transient factory
 
             await traceMessages.ExecuteAsync();
         }
diff --git a/src/SharpBrick.PoweredUp/Deployment/HubExtensions.cs b/src/SharpBrick.PoweredUp/Deployment/HubExtensions.cs
@@ -105,7 +105,7 @@ private static Action<DeploymentModelError[]> LogErrors(Hub self)
     {
         return errors =>
         {
-            var logger = self.ServiceProvider.GetService<ILoggerFactory>().CreateLogger<Hub>();
+            var logger = self.ServiceProvider.GetRequiredService<ILoggerFactory>().CreateLogger<Hub>();
             if (errors.Length > 0)
             {
 
diff --git a/src/SharpBrick.PoweredUp/Hubs/HubFactory.cs b/src/SharpBrick.PoweredUp/Hubs/HubFactory.cs
@@ -14,15 +14,24 @@ public HubFactory(IServiceProvider serviceProvider)
 
     public Hub CreateByBluetoothManufacturerData(byte[] manufacturerData)
     {
-        var hub = (manufacturerData is null || manufacturerData.Length < 3) ? null : Create(GetTypeFromSystemType(GetSystemTypeFromManufacturerData((PoweredUpHubManufacturerData)manufacturerData[1])));
+        if (manufacturerData is null)
+        {
+            throw new ArgumentNullException(nameof(manufacturerData));
+        }
+        if (manufacturerData.Length < 3)
+        {
+            throw new ArgumentException("Manufacturer data must be at least 3 bytes long.", nameof(manufacturerData));
+        }
+
+        var hub = Create(GetTypeFromSystemType(GetSystemTypeFromManufacturerData((PoweredUpHubManufacturerData)manufacturerData[1])));
         hub.Configure(0x00);
 
         return hub;
     }
 
     public THub Create<THub>() where THub : Hub
     {
-        var hub = Create(typeof(THub)) as THub;
+        var hub = (THub)Create(typeof(THub));
         hub.Configure(0x00);
 
         return hub;
diff --git a/src/SharpBrick.PoweredUp/PoweredUpHost.cs b/src/SharpBrick.PoweredUp/PoweredUpHost.cs
@@ -123,7 +123,7 @@ public IServiceScope CreateProtocolScope(IPoweredUpBluetoothDeviceInfo bluetooth
         var scopedServiceProvider = scope.ServiceProvider;
 
         // initialize scoped bluetooth kernel to bluetooth address.
-        var kernel = scopedServiceProvider.GetService<BluetoothKernel>();
+        var kernel = scopedServiceProvider.GetRequiredService<BluetoothKernel>();
         kernel.BluetoothDeviceInfo = bluetoothDeviceInfo;
 
         return scope;
diff --git a/src/SharpBrick.PoweredUp/Protocol/Formatter/MessageEncoder.cs b/src/SharpBrick.PoweredUp/Protocol/Formatter/MessageEncoder.cs
@@ -83,7 +83,7 @@ public static LegoWirelessMessage Decode(in Span<byte> data, ProtocolKnowledge k
 
         if (encoder is not null)
         {
-            var message = encoder?.Decode(hubId, content);
+            var message = encoder.Decode(hubId, content);
 
             message.Length = length;
             message.HubId = hubId;
diff --git a/src/SharpBrick.PoweredUp/Protocol/ILegoWirelessProtocolExtensions.cs b/src/SharpBrick.PoweredUp/Protocol/ILegoWirelessProtocolExtensions.cs
@@ -29,6 +29,6 @@ public static async Task<PortFeedback> SendPortOutputCommandAsync(this ILegoWire
 
         var response = await self.SendMessageReceiveResultAsync<PortOutputCommandFeedbackMessage>(message, msg => msg.Feedbacks.Any(f => f.PortId == portId));
 
-        return response.Feedbacks.FirstOrDefault(f => f.PortId == portId).Feedback;
+        return response.Feedbacks.First(f => f.PortId == portId).Feedback;
     }
 }
diff --git a/test/SharpBrick.PoweredUp.Test/Devices/VoltageTest.cs b/test/SharpBrick.PoweredUp.Test/Devices/VoltageTest.cs
@@ -76,7 +76,7 @@ await mock.WriteUpstreamAsync(new PortInputFormatSingleMessage(0x20, 1, 0, true)
 
         var poweredUpBluetoothAdapterMock = serviceProvider.GetMockBluetoothAdapter();
 
-        var protocol = serviceProvider.GetService<ILegoWirelessProtocol>();
+        var protocol = serviceProvider.GetRequiredService<ILegoWirelessProtocol>();
 
         protocol.ConnectAsync(knownSystemType).Wait();
 
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/HubActionsEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/HubActionsEncoderTest.cs
@@ -46,9 +46,10 @@ public void HubActionsEncoder_Decode(HubAction expectedAction, string dataAsStri
         var data = BytesStringUtil.StringToData(dataAsString);
 
         // act
-        var message = MessageEncoder.Decode(data, null) as HubActionMessage;
+        var message = MessageEncoder.Decode(data, null);
 
         // assert
-        Assert.Equal(expectedAction, message.Action);
+        var hubActionMessage = Assert.IsType<HubActionMessage>(message);
+        Assert.Equal(expectedAction, hubActionMessage.Action);
     }
 }
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/HubAlertEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/HubAlertEncoderTest.cs
@@ -42,11 +42,12 @@ public void HubAlertEncoder_Decode(HubAlert expectedAlert, HubAlertOperation exp
         var data = BytesStringUtil.StringToData(dataAsString);
 
         // act
-        var message = MessageEncoder.Decode(data, null) as HubAlertMessage;
+        var message = MessageEncoder.Decode(data, null);
 
         // assert
-        Assert.Equal(expectedAlert, message.Alert);
-        Assert.Equal(expectedOperation, message.Operation);
-        Assert.Equal(expectedPayload, message.DownstreamPayload);
+        var hubAlertMessage = Assert.IsType<HubAlertMessage>(message);
+        Assert.Equal(expectedAlert, hubAlertMessage.Alert);
+        Assert.Equal(expectedOperation, hubAlertMessage.Operation);
+        Assert.Equal(expectedPayload, hubAlertMessage.DownstreamPayload);
     }
 }
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/HubAttachedIOEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/HubAttachedIOEncoderTest.cs
@@ -23,13 +23,14 @@ public void HubAttachedIOEncoder_Decode_Attached<T>(string messageAsString, Devi
         var data = BytesStringUtil.StringToData(messageAsString).AsSpan()[3..];
 
         // act
-        var message = new HubAttachedIOEncoder().Decode(0x00, data) as HubAttachedIOForAttachedDeviceMessage;
+        var message = new HubAttachedIOEncoder().Decode(0x00, data);
 
         // assert
-        Assert.Equal(expectedPortId, message.PortId);
-        Assert.Equal(expectedType, message.IOTypeId);
-        Assert.Equal(new Version(expectedHwVersion), message.HardwareRevision);
-        Assert.Equal(new Version(expectedSwVersion), message.SoftwareRevision);
+        var hubAttachedIOForAttachedDeviceMessage = Assert.IsType<HubAttachedIOForAttachedDeviceMessage>(message);
+        Assert.Equal(expectedPortId, hubAttachedIOForAttachedDeviceMessage.PortId);
+        Assert.Equal(expectedType, hubAttachedIOForAttachedDeviceMessage.IOTypeId);
+        Assert.Equal(new Version(expectedHwVersion), hubAttachedIOForAttachedDeviceMessage.HardwareRevision);
+        Assert.Equal(new Version(expectedSwVersion), hubAttachedIOForAttachedDeviceMessage.SoftwareRevision);
 
         // reverse test
         var reverseMessage = new HubAttachedIOForAttachedDeviceMessage(expectedPortId, expectedType, Version.Parse(expectedHwVersion), Version.Parse(expectedSwVersion));
@@ -50,12 +51,13 @@ public void HubAttachedIOEncoder_Decode_AttachedVirutalIO(string messageAsString
         var data = BytesStringUtil.StringToData(messageAsString).AsSpan()[3..];
 
         // act
-        var message = new HubAttachedIOEncoder().Decode(0x00, data) as HubAttachedIOForAttachedVirtualDeviceMessage;
+        var message = new HubAttachedIOEncoder().Decode(0x00, data);
 
         // assert
-        Assert.Equal(expectedPortId, message.PortId);
-        Assert.Equal(expectedType, message.IOTypeId);
-        Assert.Equal(portA, message.PortAId);
-        Assert.Equal(portB, message.PortBId);
+        var hubAttachedIOForAttachedVirtualDeviceMessage = Assert.IsType<HubAttachedIOForAttachedVirtualDeviceMessage>(message);
+        Assert.Equal(expectedPortId, hubAttachedIOForAttachedVirtualDeviceMessage.PortId);
+        Assert.Equal(expectedType, hubAttachedIOForAttachedVirtualDeviceMessage.IOTypeId);
+        Assert.Equal(portA, hubAttachedIOForAttachedVirtualDeviceMessage.PortAId);
+        Assert.Equal(portB, hubAttachedIOForAttachedVirtualDeviceMessage.PortBId);
     }
 }
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/HubPropertiesEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/HubPropertiesEncoderTest.cs
@@ -25,12 +25,13 @@ public void HubPropertiesEncoder_Decode_UpdateUpstream<T>(string messageAsString
         var data = BytesStringUtil.StringToData(messageAsString).AsSpan()[3..];
 
         // act
-        var message = new HubPropertiesEncoder().Decode(0x00, data) as HubPropertyMessage<T>;
+        var message = new HubPropertiesEncoder().Decode(0x00, data);
 
         // assert
-        Assert.Equal(expectedProperty, message.Property);
-        Assert.Equal(expectedPropertyOperation, message.Operation);
-        Assert.Equal(payload, message.Payload);
+        var hubPropertyMessage = Assert.IsType<HubPropertyMessage<T>>(message);
+        Assert.Equal(expectedProperty, hubPropertyMessage.Property);
+        Assert.Equal(expectedPropertyOperation, hubPropertyMessage.Operation);
+        Assert.Equal(payload, hubPropertyMessage.Payload);
     }
 
     [Theory]
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortInformationEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortInformationEncoderTest.cs
@@ -18,18 +18,19 @@ public void PortInformationEncoder_Decode_PortInformationForModeInfoMessage(byte
         var data = BytesStringUtil.StringToData(dataAsString);
 
         // act
-        var message = MessageEncoder.Decode(data, null) as PortInformationForModeInfoMessage;
+        var message = MessageEncoder.Decode(data, null);
 
         // assert
-        Assert.Equal(expectedPort, message.PortId);
-        Assert.Equal(expectedType, message.InformationType);
-        Assert.Equal(expectedOutput, message.OutputCapability);
-        Assert.Equal(expectedInput, message.InputCapability);
-        Assert.Equal(expectedLogicalCombinable, message.LogicalCombinableCapability);
-        Assert.Equal(expectedLogicalSynchronizable, message.LogicalSynchronizableCapability);
-        Assert.Equal(expectedTotalCount, message.TotalModeCount);
-        Assert.Equal(expectedInputModes, message.InputModes);
-        Assert.Equal(expectedOutputModes, message.OutputModes);
+        var portInformationForModeInfoMessage = Assert.IsType<PortInformationForModeInfoMessage>(message);
+        Assert.Equal(expectedPort, portInformationForModeInfoMessage.PortId);
+        Assert.Equal(expectedType, portInformationForModeInfoMessage.InformationType);
+        Assert.Equal(expectedOutput, portInformationForModeInfoMessage.OutputCapability);
+        Assert.Equal(expectedInput, portInformationForModeInfoMessage.InputCapability);
+        Assert.Equal(expectedLogicalCombinable, portInformationForModeInfoMessage.LogicalCombinableCapability);
+        Assert.Equal(expectedLogicalSynchronizable, portInformationForModeInfoMessage.LogicalSynchronizableCapability);
+        Assert.Equal(expectedTotalCount, portInformationForModeInfoMessage.TotalModeCount);
+        Assert.Equal(expectedInputModes, portInformationForModeInfoMessage.InputModes);
+        Assert.Equal(expectedOutputModes, portInformationForModeInfoMessage.OutputModes);
     }
 
 
@@ -43,11 +44,12 @@ public void PortInformationEncoder_Decode_PortInformationForPossibleModeCombinat
         var data = BytesStringUtil.StringToData(dataAsString);
 
         // act
-        var message = MessageEncoder.Decode(data, null) as PortInformationForPossibleModeCombinationsMessage;
+        var message = MessageEncoder.Decode(data, null);
 
         // assert
-        Assert.Equal(expectedPort, message.PortId);
-        Assert.Equal(expectedType, message.InformationType);
-        Assert.Collection(message.ModeCombinations, expectedCombinations.Select<ushort, Action<ushort>>(combination => { return (item) => Assert.Equal(combination, item); }).ToArray());
+        var portInformationForPossibleModeCombinationsMessage = Assert.IsType<PortInformationForPossibleModeCombinationsMessage>(message);
+        Assert.Equal(expectedPort, portInformationForPossibleModeCombinationsMessage.PortId);
+        Assert.Equal(expectedType, portInformationForPossibleModeCombinationsMessage.InformationType);
+        Assert.Collection(portInformationForPossibleModeCombinationsMessage.ModeCombinations, expectedCombinations.Select<ushort, Action<ushort>>(combination => { return (item) => Assert.Equal(combination, item); }).ToArray());
     }
 }
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortInputFormatCombinedModeEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortInputFormatCombinedModeEncoderTest.cs
@@ -16,12 +16,13 @@ public void PortInputFormatCombinedModeEncoder_Decode(string dataAsString, byte
         var data = BytesStringUtil.StringToData(dataAsString);
 
         // act
-        var message = MessageEncoder.Decode(data, null) as PortInputFormatCombinedModeMessage;
+        var message = MessageEncoder.Decode(data, null);
 
         // assert
-        Assert.Equal(expectedPortId, message.PortId);
-        Assert.Equal(expectedCombinationIndex, message.UsedCombinationIndex);
-        Assert.Equal(expectedEnabled, message.MultiUpdateEnabled);
-        Assert.Collection(message.ConfiguredModeDataSetIndex, expectedIndexes.Select<int, Action<int>>(exp => (act) => Assert.Equal(exp, act)).ToArray());
+        var portInputFormatCombinedModeMessage = Assert.IsType<PortInputFormatCombinedModeMessage>(message);
+        Assert.Equal(expectedPortId, portInputFormatCombinedModeMessage.PortId);
+        Assert.Equal(expectedCombinationIndex, portInputFormatCombinedModeMessage.UsedCombinationIndex);
+        Assert.Equal(expectedEnabled, portInputFormatCombinedModeMessage.MultiUpdateEnabled);
+        Assert.Collection(portInputFormatCombinedModeMessage.ConfiguredModeDataSetIndex, expectedIndexes.Select<int, Action<int>>(exp => (act) => Assert.Equal(exp, act)).ToArray());
     }
 }
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortInputFormatSingleEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortInputFormatSingleEncoderTest.cs
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortValueCombinedModeEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortValueCombinedModeEncoderTest.cs
diff --git a/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortValueEncoderTest.cs b/test/SharpBrick.PoweredUp.Test/Protocol/Formatter/PortValueEncoderTest.cs
diff --git a/test/SharpBrick.PoweredUp.TestScript/Program.cs b/test/SharpBrick.PoweredUp.TestScript/Program.cs
diff --git a/test/SharpBrick.PoweredUp.TestScript/TestScriptExecutionContext.cs b/test/SharpBrick.PoweredUp.TestScript/TestScriptExecutionContext.cs

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public async Task InitExampleAndDiscoverAsync(IServiceProvider serviceProvider,`
`31`	`31`
`32`	`32`	`Host = serviceProvider.GetService<PoweredUpHost>();`
`33`	`33`
`34`		`- Log = serviceProvider.GetService<ILoggerFactory>().CreateLogger("Example");`
	`34`	`+ Log = serviceProvider.GetRequiredService<ILoggerFactory>().CreateLogger("Example");`
`35`	`35`
`36`	`36`	`var enableTrace = bool.TryParse(configuration["EnableTrace"], out var x) && x;`
`37`	`37`
`@@ -49,7 +49,7 @@ public virtual Task DiscoverAsync(bool enableTrace)`
`49`	`49`	`// add this when you are interested in a tracing of the message ("human readable")`
`50`	`50`	`if (enableTrace)`
`51`	`51`	`{`
`52`		`- var tracer = hub.ServiceProvider.GetService<TraceMessages>();`
	`52`	`+ var tracer = hub.ServiceProvider.GetRequiredService<TraceMessages>();`
`53`	`53`	`await tracer.ExecuteAsync();`
`54`	`54`	`}`
`55`	`55`
Original file line number	Diff line number	Diff line change
`@@ -85,8 +85,7 @@ async void GAPScanResponseEvent(object sender, BleScanResponseReceivedEventArgs`
`85`	`85`	`//we only want to discover Lego-devices`
`86`	`86`	`//filter for correct service-GUID for LEGO-Hub, containing manufacturerData and the name`
`87`	`87`	`var addressNumber = BlueGigaBLEHelper.ByteArrayToUlong(e.Address);`
`88`		`- var bleAdvertisingListFound = bleParsedData.TryGetValue(addressNumber, out var actualListAdvertisingData);`
`89`		`- if (!bleAdvertisingListFound)`
	`88`	`+ if (!bleParsedData.TryGetValue(addressNumber, out var actualListAdvertisingData))`
`90`	`89`	`{`
`91`	`90`	`actualListAdvertisingData = bleParsedData.AddOrUpdate(addressNumber, new List<BleAdvertisingData>(), (oldkey, oldvalue) => oldvalue = new List<BleAdvertisingData>());`
`92`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,9 +86,9 @@ static async Task<int> Main(string[] args)`
`86`	`86`
`87`	`87`	`await AddTraceWriterAsync(scopedServiceProvider, enableTrace);`
`88`	`88`
`89`		`- scopedServiceProvider.GetService<BluetoothKernel>().BluetoothDeviceInfo = bluetoothDeviceInfo;`
	`89`	`+ scopedServiceProvider.GetRequiredService<BluetoothKernel>().BluetoothDeviceInfo = bluetoothDeviceInfo;`
`90`	`90`
`91`		`- var deviceListCli = scopedServiceProvider.GetService<DevicesList>(); // ServiceLocator ok: transient factory`
	`91`	`+ var deviceListCli = scopedServiceProvider.GetRequiredService<DevicesList>(); // ServiceLocator ok: transient factory`
`92`	`92`
`93`	`93`	`await deviceListCli.ExecuteAsync(systemType);`
`94`	`94`	`}`
`@@ -138,11 +138,11 @@ static async Task<int> Main(string[] args)`
`138`	`138`
`139`	`139`	`await AddTraceWriterAsync(scopedServiceProvider, enableTrace);`
`140`	`140`
`141`		`- scopedServiceProvider.GetService<BluetoothKernel>().BluetoothDeviceInfo = bluetoothDeviceInfo;`
	`141`	`+ scopedServiceProvider.GetRequiredService<BluetoothKernel>().BluetoothDeviceInfo = bluetoothDeviceInfo;`
`142`	`142`
`143`		`- var dumpStaticPortInfoCommand = scopedServiceProvider.GetService<DumpStaticPortInfo>(); // ServiceLocator ok: transient factory`
	`143`	`+ var dumpStaticPortInfoCommand = scopedServiceProvider.GetRequiredService<DumpStaticPortInfo>(); // ServiceLocator ok: transient factory`
`144`	`144`
`145`		`- var port = byte.Parse(portOption.Value());`
	`145`	`+ var port = byte.TryParse(portOption.Value(), out var parsedPort) ? parsedPort : (byte)0;`
`146`	`146`
`147`	`147`	`await dumpStaticPortInfoCommand.ExecuteAsync(systemType, port, headerEnabled);`
`148`	`148`	`}`
`@@ -193,7 +193,7 @@ static async Task<int> Main(string[] args)`
`193`	`193`
`194`	`194`	`await AddTraceWriterAsync(scopedServiceProvider, enableTrace);`
`195`	`195`
`196`		`- var prettyPrintCommand = scopedServiceProvider.GetService<PrettyPrint>(); // ServiceLocator ok: transient factory`
	`196`	`+ var prettyPrintCommand = scopedServiceProvider.GetRequiredService<PrettyPrint>(); // ServiceLocator ok: transient factory`
`197`	`197`
`198`	`198`	`TextReader reader = Console.In;`
`199`	`199`
`@@ -273,7 +273,7 @@ public static async Task AddTraceWriterAsync(IServiceProvider serviceProvider, b`
`273`	`273`	`{`
`274`	`274`	`if (enableTrace)`
`275`	`275`	`{`
`276`		`- var traceMessages = serviceProvider.GetService<TraceMessages>(); // ServiceLocator ok: transient factory`
	`276`	`+ var traceMessages = serviceProvider.GetRequiredService<TraceMessages>(); // ServiceLocator ok: transient factory`
`277`	`277`
`278`	`278`	`await traceMessages.ExecuteAsync();`
`279`	`279`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ private static Action<DeploymentModelError[]> LogErrors(Hub self)`
`105`	`105`	`{`
`106`	`106`	`return errors =>`
`107`	`107`	`{`
`108`		`- var logger = self.ServiceProvider.GetService<ILoggerFactory>().CreateLogger<Hub>();`
	`108`	`+ var logger = self.ServiceProvider.GetRequiredService<ILoggerFactory>().CreateLogger<Hub>();`
`109`	`109`	`if (errors.Length > 0)`
`110`	`110`	`{`
`111`	`111`