Update InequalityVsIsNotInCSharp to .NET 10

csharp-basic-topics/InequalityVsIsNotInCSharp/InequalityVsIsNot/InequalityVsIsNot.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

csharp-basic-topics/InequalityVsIsNotInCSharp/InequalityVsIsNot/InequalityVsIsNotComparer.cs

@@ -110,5 +110,27 @@ public void AnotherModelComparerUsingIsNot(Car car)
                 Console.WriteLine("model is not Focus"); 
             } 
         }
+
+        public void SerialNumberNotInUsingIsNot(Vehicle vehicle)
+        {
+            if (vehicle.SerialNumber is not (1000 or 2000 or 3000))
+            {
+                Console.WriteLine("serial number is not 1000, 2000 or 3000");
+            }
+        }
+
+        public void SerialNumberNotInListUsingNot(Vehicle vehicle, int[] recalledSerialNumbers)
+        {
+            if (!recalledSerialNumbers.Contains(vehicle.SerialNumber))
+            {
+                Console.WriteLine("serial number is not recalled");
+            }
+        }
+
+        public void MeasurementComparer(double measurement)
+        {
+            Console.WriteLine(measurement != double.NaN);
+            Console.WriteLine(measurement is not double.NaN);
+        }
     }
 }

csharp-basic-topics/InequalityVsIsNotInCSharp/InequalityVsIsNot/Program.cs

@@ -38,6 +38,12 @@
 
 comparer.CarTypeComparerUsingIsNot(car);
 
+comparer.SerialNumberNotInUsingIsNot(vehicle);
+
+comparer.SerialNumberNotInListUsingNot(vehicle, [1000, 2000, 3000]);
+
+comparer.MeasurementComparer(double.NaN);
+
 var otherVehicle = new Vehicle()
 {
     SerialNumber = 1002,
@@ -47,4 +53,6 @@
 Console.WriteLine(vehicle != otherVehicle);
 Console.WriteLine(vehicle == otherVehicle);
 
-Console.WriteLine(vehicle != null);
+Console.WriteLine(vehicle != null);
+Console.WriteLine(!(vehicle == null));
+Console.WriteLine(vehicle is not null);

csharp-basic-topics/InequalityVsIsNotInCSharp/InequalityVsIsNot/Vehicle.cs

@@ -1,25 +1,25 @@
 namespace InequalityVsIsNot
 {
     public class Vehicle
     {
         public Brand VehicleBrand { get; set; }
         public int SerialNumber { get; set; }
 
-        public static bool operator ==(Vehicle vehicle, Vehicle otherVehicle)
+        public static bool operator ==(Vehicle? vehicle, Vehicle? otherVehicle)
         {
             if (otherVehicle is not null)
             {
-                return otherVehicle.VehicleBrand == vehicle.VehicleBrand;
+                return otherVehicle.VehicleBrand == vehicle?.VehicleBrand;
             }
 
             return false;
         }
 
-        public static bool operator !=(Vehicle vehicle, Vehicle otherVehicle)
+        public static bool operator !=(Vehicle? vehicle, Vehicle? otherVehicle)
         {
             if (otherVehicle is not null)
             {
-                return otherVehicle.VehicleBrand != vehicle.VehicleBrand;
+                return otherVehicle.VehicleBrand != vehicle?.VehicleBrand;
             }
 
             return false;

csharp-basic-topics/InequalityVsIsNotInCSharp/Tests/InequalityVsIsNotTest.cs

@@ -193,5 +193,94 @@ public void WhenNotEqualOperatorIsOverloaded_ThenCorrectOutput()
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void WhenNotEqualOperatorIsOverloaded_ThenIsNotNullIgnoresIt()
+        {
+            var vehicle = new Vehicle()
+            {
+                SerialNumber = 1001,
+                VehicleBrand = Brand.Toyota
+            };
+
+            Assert.False(vehicle != null);
+            Assert.True(!(vehicle == null));
+            Assert.True(vehicle is not null);
+        }
+
+        [Fact]
+        public void WhenSerialNumberIsBoxedAndEqualToConstant_ThenNotEqualStillReportsDifferent()
+        {
+            var vehicle = new Vehicle() { SerialNumber = 1000 };
+            using var sw = new StringWriter();
+            Console.SetOut(sw);
+
+            _comparer.BoxedSerialNumberComparerUsingNotEqual(vehicle);
+            _comparer.BoxedSerialNumberComparerUsingIsNot(vehicle);
+
+            Assert.Equal($"boxed serial number != 1000{Environment.NewLine}", sw.ToString());
+        }
+
+        [Fact]
+        public void WhenCarIsNull_ThenCarIsNotVehicle()
+        {
+            Car? car = null;
+
+            Assert.True(car is not Vehicle);
+        }
+
+        [Fact]
+        public void WhenSerialNumberIsNotInTheList_ThenMessageIsPrinted()
+        {
+            using var sw = new StringWriter();
+            Console.SetOut(sw);
+
+            _comparer.SerialNumberNotInUsingIsNot(_vehicle);
+            _comparer.SerialNumberNotInUsingIsNot(new Vehicle() { SerialNumber = 2000 });
+
+            Assert.Equal($"serial number is not 1000, 2000 or 3000{Environment.NewLine}", sw.ToString());
+        }
+
+        [Fact]
+        public void WhenNotHasNoParentheses_ThenItOnlyNegatesTheFirstPattern()
+        {
+            var serialNumber = 2000;
+
+#pragma warning disable CS9336 // The pattern is redundant: this test documents the trap
+            Assert.True(serialNumber is not 1000 or 2000 or 3000);
+#pragma warning restore CS9336
+            Assert.False(serialNumber is not (1000 or 2000 or 3000));
+        }
+
+        [Fact]
+        public void WhenMeasurementIsNaN_ThenOnlyIsNotRecognisesIt()
+        {
+            using var sw = new StringWriter();
+            Console.SetOut(sw);
+
+            _comparer.MeasurementComparer(double.NaN);
+
+            Assert.Equal($"True{Environment.NewLine}False{Environment.NewLine}", sw.ToString());
+        }
+
+        [Fact]
+        public void WhenVehicleIsNotEmptyPattern_ThenItIsNull()
+        {
+            Vehicle? vehicle = null;
+
+            Assert.True(vehicle is not { });
+            Assert.False(_vehicle is not { });
+        }
+
+        [Fact]
+        public void WhenSerialNumberIsNotInTheArray_ThenMessageIsPrinted()
+        {
+            using var sw = new StringWriter();
+            Console.SetOut(sw);
+
+            _comparer.SerialNumberNotInListUsingNot(_vehicle, [1000, 2000, 3000]);
+            _comparer.SerialNumberNotInListUsingNot(new Vehicle() { SerialNumber = 2000 }, [1000, 2000, 3000]);
+
+            Assert.Equal($"serial number is not recalled{Environment.NewLine}", sw.ToString());
+        }
     }
-}
+}

csharp-basic-topics/InequalityVsIsNotInCSharp/Tests/Tests.csproj

@@ -1,20 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <Nullable>enable</Nullable>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.11.0" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="4.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.1.0">
+    <PackageReference Include="coverlet.collector" Version="10.1.0">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>