Vectron · Vectron · Nov 15, 2024 · Nov 15, 2024 · Nov 15, 2024 · Nov 15, 2024
diff --git a/.editorconfig b/.editorconfig
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -7,7 +7,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <WarningsAsErrors></WarningsAsErrors>
-    <WarningsNotAsErrors>MA0026</WarningsNotAsErrors>
+    <WarningsNotAsErrors>MA0026;MA0051;NU1901;NU1902;NU1903;NU1904</WarningsNotAsErrors>
     <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
     <EnableNETAnalyzers>true</EnableNETAnalyzers>
     <AnalysisLevel>latest</AnalysisLevel>

diff --git a/src/PlcInterface.Abstraction/TypeConverter.cs b/src/PlcInterface.Abstraction/TypeConverter.cs
@@ -40,7 +40,7 @@ public virtual object Convert(object value, Type targetType)
         if (targetType.IsEnum
             && value.GetType() == typeof(string))
         {
-            var enumNumber = Convert(value, typeof(long));
+            var enumNumber = Convert<long>(value);
             return Enum.ToObject(targetType, enumNumber);
         }
 

diff --git a/test/PlcInterface.Abstraction/ConnectedTests.cs b/test/PlcInterface.Abstraction/ConnectedTests.cs
@@ -12,12 +12,12 @@ public void ConnectedImplementsIConnected()
         var connected = new Connected<GenericParameterHelper>();
 
         // Act
-        Assert.IsInstanceOfType(connected, typeof(IConnected));
-        Assert.IsInstanceOfType(connected, typeof(IConnected<GenericParameterHelper>));
+        Assert.IsInstanceOfType<IConnected>(connected);
+        Assert.IsInstanceOfType<IConnected<GenericParameterHelper>>(connected);
 
         // Assert
-        Assert.IsInstanceOfType(connected, typeof(IConnected));
-        Assert.IsInstanceOfType(connected, typeof(IConnected<GenericParameterHelper>));
+        Assert.IsInstanceOfType<IConnected>(connected);
+        Assert.IsInstanceOfType<IConnected<GenericParameterHelper>>(connected);
     }
 
     [TestMethod]
@@ -29,8 +29,8 @@ public void ConnectedNoReturnsAValidIConnected()
         var notConnected = Connected.No<GenericParameterHelper>();
 
         // Assert
-        Assert.IsInstanceOfType(notConnected, typeof(IConnected));
-        Assert.IsInstanceOfType(notConnected, typeof(IConnected<GenericParameterHelper>));
+        Assert.IsInstanceOfType<IConnected>(notConnected);
+        Assert.IsInstanceOfType<IConnected<GenericParameterHelper>>(notConnected);
         Assert.IsFalse(notConnected.IsConnected);
         _ = Assert.ThrowsException<InvalidOperationException>(() => notConnected.Value);
     }
@@ -45,8 +45,8 @@ public void ConnectedYesReturnsAValidIConnected()
         var connected = Connected.Yes(expectedValue);
 
         // Assert
-        Assert.IsInstanceOfType(connected, typeof(IConnected));
-        Assert.IsInstanceOfType(connected, typeof(IConnected<GenericParameterHelper>));
+        Assert.IsInstanceOfType<IConnected>(connected);
+        Assert.IsInstanceOfType<IConnected<GenericParameterHelper>>(connected);
         Assert.IsTrue(connected.IsConnected);
         Assert.AreSame(expectedValue, connected.Value);
     }

diff --git a/test/PlcInterface.Abstraction/TypeConverterTests.cs b/test/PlcInterface.Abstraction/TypeConverterTests.cs
@@ -73,7 +73,7 @@ public void ConvertConvertsDateTimeToDateTimeOffset()
         var actual = typeConverter.Convert<DateTimeOffset>(dateTime);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(DateTimeOffset));
+        Assert.IsInstanceOfType<DateTimeOffset>(actual);
         Assert.AreEqual(new DateTimeOffset(dateTime), actual);
     }
 
@@ -135,7 +135,7 @@ public void ConvertConvertsDynamicObjectToType()
         var actual = typeConverter.Convert<TestType>(sourceMock.Object);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(TestType));
+        Assert.IsInstanceOfType<TestType>(actual);
         Assert.AreEqual(expected.IntValue, actual.IntValue);
         CollectionAssert.AreEqual(expected.IntArray, actual.IntArray);
 
@@ -158,7 +158,7 @@ public void ConvertConvertsExpandoToRequestedType()
         var actual = typeConverter.Convert<TestType>(source);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(TestType));
+        Assert.IsInstanceOfType<TestType>(actual);
         Assert.AreEqual(expected.IntValue, actual.IntValue);
         CollectionAssert.AreEqual(expected.IntArray, actual.IntArray);
 
@@ -175,12 +175,12 @@ public void ConvertConvertsStringToRequestedInt()
 
         // Act
         var actual = typeConverter.Convert<int>(stringObject);
-        var actual2 = typeConverter.Convert(stringObject, typeof(int));
+        var actual2 = typeConverter.Convert<int>(stringObject);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(int));
+        Assert.IsInstanceOfType<int>(actual);
         Assert.AreEqual(100, actual);
-        Assert.IsInstanceOfType(actual2, typeof(int));
+        Assert.IsInstanceOfType<int>(actual2);
         Assert.AreEqual(100, actual2);
     }
 
@@ -193,13 +193,13 @@ public void ConvertConvertsToEnum()
 
         // Act
         var actual = typeConverter.Convert<TestEnum>(value);
-        var actual2 = typeConverter.Convert(value, typeof(TestEnum));
+        var actual2 = typeConverter.Convert<TestEnum>(value);
 
         // Assert
         Assert.AreEqual(TestEnum.Value4, actual);
-        Assert.IsInstanceOfType(actual, typeof(TestEnum));
+        Assert.IsInstanceOfType<TestEnum>(actual);
         Assert.AreEqual(TestEnum.Value4, actual2);
-        Assert.IsInstanceOfType(actual2, typeof(TestEnum));
+        Assert.IsInstanceOfType<TestEnum>(actual2);
     }
 
     [TestMethod]
@@ -211,10 +211,10 @@ public void ConvertReturnsSourceObjectIfAlreadyTheRightType()
 
         // Act
         var actual = typeConverter.Convert<GenericParameterHelper>(expected);
-        var actual2 = typeConverter.Convert(expected, typeof(GenericParameterHelper));
+        var actual2 = typeConverter.Convert<GenericParameterHelper>(expected);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(GenericParameterHelper));
+        Assert.IsInstanceOfType<GenericParameterHelper>(actual);
         Assert.AreEqual(expected, actual);
         Assert.AreEqual(expected, actual2);
     }
@@ -252,7 +252,7 @@ public void ConvertSupportsRecordTypes()
         var actual = typeConverter.Convert<TestRecordType>(sourceMock.Object);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(TestRecordType));
+        Assert.IsInstanceOfType<TestRecordType>(actual);
         Assert.AreEqual(expected.IntValue, actual.IntValue);
         CollectionAssert.AreEqual(expected.IntArray, actual.IntArray);
 
@@ -293,7 +293,7 @@ public void ConvertSupportsRecordValueTypes()
         var actual = typeConverter.Convert<TestRecordStructType>(sourceMock.Object);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(TestRecordStructType));
+        Assert.IsInstanceOfType<TestRecordStructType>(actual);
         Assert.AreEqual(expected.IntValue, actual.IntValue);
         CollectionAssert.AreEqual(expected.IntArray, actual.IntArray);
 
@@ -334,7 +334,7 @@ public void ConvertSupportsValueTypes()
         var actual = typeConverter.Convert<TestValueType>(sourceMock.Object);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(TestValueType));
+        Assert.IsInstanceOfType<TestValueType>(actual);
         Assert.AreEqual(expected.IntValue, actual.IntValue);
         CollectionAssert.AreEqual(expected.IntArray, actual.IntArray);
 

diff --git a/test/PlcInterface.Ads.Tests/AdsTypeConverterTests.cs b/test/PlcInterface.Ads.Tests/AdsTypeConverterTests.cs
@@ -27,7 +27,7 @@ public void ConvertCanConvertADynamicIValueSymbol()
         var actual = typeConverter.Convert(sourceMock.Object, Mock.Of<IValueSymbol>());
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(ICollection));
+        Assert.IsInstanceOfType<ICollection>(actual);
         CollectionAssert.AreEqual(expected, (ICollection)actual);
     }
 
@@ -66,7 +66,7 @@ public void ConvertChangesPlcOpenTypesToDotNetTypes()
         var actual = typeConverter.Convert<TimesTestType>(sourceMock.Object);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(TimesTestType));
+        Assert.IsInstanceOfType<TimesTestType>(actual);
         Assert.AreEqual(expected.Date, actual.Date);
         Assert.AreEqual(expected.Time, actual.Time);
         Assert.AreEqual(expected.LTime, actual.LTime);
@@ -87,7 +87,7 @@ public void ConvertConvertsDateTimeToDateTimeOffset()
         var actual = typeConverter.Convert(source, valueSymbolMock.Object);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(DateTimeOffset));
+        Assert.IsInstanceOfType<DateTimeOffset>(actual);
         Assert.AreEqual(expected, actual);
     }
 
@@ -104,10 +104,10 @@ public void ConvertConvertsShortToIntWhenTypeIsEnum()
         var actual2 = typeConverter.Convert(1L, valueSymbolMock.Object);
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(int));
+        Assert.IsInstanceOfType<int>(actual);
         Assert.AreEqual(1, actual);
 
-        Assert.IsInstanceOfType(actual2, typeof(long));
+        Assert.IsInstanceOfType<long>(actual2);
         Assert.AreEqual(1L, actual2);
     }
 

diff --git a/test/PlcInterface.Ads.Tests/DynamicObjectExtensionsTests.cs b/test/PlcInterface.Ads.Tests/DynamicObjectExtensionsTests.cs
@@ -152,7 +152,7 @@ public void CleanDynamicConvertsStructTypeToExpando()
         // Assert
         Assert.AreEqual(255, expando.Property1);
         Assert.AreEqual("test", expando.Property2);
-        Assert.AreEqual(false, expando.Property3);
+        Assert.AreEqual(expected: false, actual: expando.Property3);
         Assert.AreEqual(10L, expando.Property4);
         Assert.IsNull(expando.Property5);
     }

diff --git a/test/PlcInterface.Ads.Tests/IServiceCollectionExtensionTests.cs b/test/PlcInterface.Ads.Tests/IServiceCollectionExtensionTests.cs
@@ -35,7 +35,7 @@ public void AdsTypeConverterIsRegisteredCorrect()
 
         Assert.IsNull(concrete);
         Assert.IsNull(typeConverter);
-        Assert.IsInstanceOfType(adsTypeConverter, typeof(AdsTypeConverter));
+        Assert.IsInstanceOfType<AdsTypeConverter>(adsTypeConverter);
     }
 
     [TestMethod]
@@ -65,10 +65,10 @@ public void IfBaseInterfaceRegistrationIsOverwrittenSpecificStillResolvesCorrect
         var monitor = serviceProvider.GetService<IMonitor>();
 
         // Assert
-        Assert.IsInstanceOfType(adsPlcConnection, typeof(PlcConnection));
-        Assert.IsInstanceOfType(adsSymbolHandler, typeof(SymbolHandler));
-        Assert.IsInstanceOfType(adsReadWrite, typeof(ReadWrite));
-        Assert.IsInstanceOfType(adsMonitor, typeof(Monitor));
+        Assert.IsInstanceOfType<PlcConnection>(adsPlcConnection);
+        Assert.IsInstanceOfType<SymbolHandler>(adsSymbolHandler);
+        Assert.IsInstanceOfType<ReadWrite>(adsReadWrite);
+        Assert.IsInstanceOfType<Monitor>(adsMonitor);
         Assert.AreNotSame(adsPlcConnection, plcConnection);
         Assert.AreNotSame(adsSymbolHandler, symbolHandler);
         Assert.AreNotSame(adsReadWrite, readWrite);
@@ -86,7 +86,7 @@ public void MonitorIsRegisterCorrect()
 
         Assert.IsNull(concrete);
         Assert.AreSame(adsMonitor, monitor);
-        Assert.IsInstanceOfType(adsMonitor, typeof(Monitor));
+        Assert.IsInstanceOfType<Monitor>(adsMonitor);
     }
 
     [TestMethod]
@@ -102,7 +102,7 @@ public void PlCConnectionIsRegisterCorrect()
         Assert.IsNull(concrete);
         Assert.AreSame(adsConnection, connection);
         Assert.AreSame(adsConnection, genericConnection);
-        Assert.IsInstanceOfType(adsConnection, typeof(PlcConnection));
+        Assert.IsInstanceOfType<PlcConnection>(adsConnection);
     }
 
     [TestMethod]
@@ -116,7 +116,7 @@ public void ReadWriteIsRegisterCorrect()
 
         Assert.IsNull(concrete);
         Assert.AreSame(adsReadWrite, readWrite);
-        Assert.IsInstanceOfType(adsReadWrite, typeof(ReadWrite));
+        Assert.IsInstanceOfType<ReadWrite>(adsReadWrite);
     }
 
     [TestMethod]
@@ -130,6 +130,6 @@ public void SymbolHandlerIsRegisterCorrect()
 
         Assert.IsNull(concrete);
         Assert.AreSame(adsSymbolHandler, symbolHandler);
-        Assert.IsInstanceOfType(adsSymbolHandler, typeof(SymbolHandler));
+        Assert.IsInstanceOfType<SymbolHandler>(adsSymbolHandler);
     }
 }
diff --git a/test/PlcInterface.Ads.Tests/ISymbolInfoExtensionTests.cs b/test/PlcInterface.Ads.Tests/ISymbolInfoExtensionTests.cs
@@ -17,8 +17,8 @@ public void CastAndValidateReturnsSymbolInfo()
         var actual = symbolInfo.CastAndValidate();
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(IAdsSymbolInfo));
-        Assert.IsInstanceOfType(actual, typeof(ISymbolInfo));
+        Assert.IsInstanceOfType<IAdsSymbolInfo>(actual);
+        Assert.IsInstanceOfType<ISymbolInfo>(actual);
         Assert.AreSame(symbolInfo, actual);
     }
 

diff --git a/test/PlcInterface.Ads.Tests/IValueSymbolExtensionsTests.cs b/test/PlcInterface.Ads.Tests/IValueSymbolExtensionsTests.cs
@@ -18,7 +18,7 @@ public void CastAndValidateReturnsSymbolInfo()
         var actual = symbolMock.Object.CastAndValidate();
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(IValueSymbol));
+        Assert.IsInstanceOfType<IValueSymbol>(actual);
         Assert.AreSame(symbolMock.Object, actual);
     }
 

diff --git a/test/PlcInterface.IntegrationTests/Extension/AssertObjectValue.cs b/test/PlcInterface.IntegrationTests/Extension/AssertObjectValue.cs
@@ -1,5 +1,6 @@
 using System.Collections;
 using System.Dynamic;
+using System.Globalization;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,8 +30,8 @@ private static object GetDynamicValue(dynamic o, string name)
             return expando[name];
         }
 
-        var arguments = new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) };
-        var binder = Microsoft.CSharp.RuntimeBinder.Binder.GetMember(CSharpBinderFlags.None, name, null, arguments);
+        var arguments = new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, name: null) };
+        var binder = Microsoft.CSharp.RuntimeBinder.Binder.GetMember(CSharpBinderFlags.None, name, context: null, arguments);
         var site = CallSite<Func<CallSite, object, object>>.Create(binder);
         return site.Target(site, o);
     }
@@ -62,11 +63,11 @@ private static void ValidateArray(Array expected, Array actual, string message,
         {
             var expectedDimensionLength = expected.GetLength(dimension);
             var actualDimensionLength = expected.GetLength(dimension);
-            Assert.AreEqual(expectedDimensionLength, actualDimensionLength, $"{message} -> dimension {dimension} have different lower bounds");
+            Assert.AreEqual(expectedDimensionLength, actualDimensionLength, string.Format(CultureInfo.InvariantCulture, "{0} -> dimension {1} have different lower bounds", message, dimension));
 
             var expectedDimensionLowerBound = expected.GetLength(dimension);
             var actualDimensionLowerBound = expected.GetLength(dimension);
-            Assert.AreEqual(expectedDimensionLowerBound, actualDimensionLowerBound, $"{message} -> dimension {dimension} have different lower bounds");
+            Assert.AreEqual(expectedDimensionLowerBound, actualDimensionLowerBound, string.Format(CultureInfo.InvariantCulture, "{0} -> dimension {1} have different lower bounds", message, dimension));
         }
 
         ValidateEnumerable(expected, actual, message, equals);
@@ -87,7 +88,7 @@ private static void ValidateEnumerable(IEnumerable expected, IEnumerable actual,
 
             var currentExpected = expectedEnumerator.Current;
             var currentActual = actualEnumerator.Current;
-            ValidateObject(currentExpected, currentActual, $"{message}[{index}]", equals);
+            ValidateObject(currentExpected, currentActual, string.Format(CultureInfo.InvariantCulture, "{0}[{1}]", message, index), equals);
             index++;
         }
 

diff --git a/test/PlcInterface.OpcUa.Tests/IServiceCollectionExtensionTest.cs b/test/PlcInterface.OpcUa.Tests/IServiceCollectionExtensionTest.cs
@@ -51,10 +51,10 @@ public void IfBaseInterfaceRegistrationIsOverwrittenSpecificStillResolvesCorrect
         var monitor = serviceProvider.GetService<IMonitor>();
 
         // Assert
-        Assert.IsInstanceOfType(opcPlcConnection, typeof(PlcConnection));
-        Assert.IsInstanceOfType(opcSymbolHandler, typeof(SymbolHandler));
-        Assert.IsInstanceOfType(opcReadWrite, typeof(ReadWrite));
-        Assert.IsInstanceOfType(opcMonitor, typeof(Monitor));
+        Assert.IsInstanceOfType<PlcConnection>(opcPlcConnection);
+        Assert.IsInstanceOfType<SymbolHandler>(opcSymbolHandler);
+        Assert.IsInstanceOfType<ReadWrite>(opcReadWrite);
+        Assert.IsInstanceOfType<Monitor>(opcMonitor);
         Assert.AreNotSame(opcPlcConnection, plcConnection);
         Assert.AreNotSame(opcSymbolHandler, symbolHandler);
         Assert.AreNotSame(opcReadWrite, readWrite);
@@ -72,7 +72,7 @@ public void MonitorIsRegisterCorrect()
 
         Assert.IsNull(concrete);
         Assert.AreSame(opcMonitor, monitor);
-        Assert.IsInstanceOfType(opcMonitor, typeof(Monitor));
+        Assert.IsInstanceOfType<Monitor>(opcMonitor);
     }
 
     [TestMethod]
@@ -86,7 +86,7 @@ public void OpcTypeConverterIsRegisteredCorrect()
 
         Assert.IsNull(concrete);
         Assert.IsNull(typeConverter);
-        Assert.IsInstanceOfType(opcTypeConverter, typeof(OpcTypeConverter));
+        Assert.IsInstanceOfType<OpcTypeConverter>(opcTypeConverter);
     }
 
     [TestMethod]
@@ -102,7 +102,7 @@ public void PlCConnectionIsRegisterCorrect()
         Assert.IsNull(concrete);
         Assert.AreSame(opcConnection, connection);
         Assert.AreSame(opcConnection, genericConnection);
-        Assert.IsInstanceOfType(opcConnection, typeof(PlcConnection));
+        Assert.IsInstanceOfType<PlcConnection>(opcConnection);
     }
 
     [TestMethod]
@@ -116,7 +116,7 @@ public void ReadWriteIsRegisterCorrect()
 
         Assert.IsNull(concrete);
         Assert.AreSame(opcReadWrite, readWrite);
-        Assert.IsInstanceOfType(opcReadWrite, typeof(ReadWrite));
+        Assert.IsInstanceOfType<ReadWrite>(opcReadWrite);
     }
 
     [TestMethod]
@@ -130,6 +130,6 @@ public void SymbolHandlerIsRegisterCorrect()
 
         Assert.IsNull(concrete);
         Assert.AreSame(opcSymbolHandler, symbolHandler);
-        Assert.IsInstanceOfType(opcSymbolHandler, typeof(SymbolHandler));
+        Assert.IsInstanceOfType<SymbolHandler>(opcSymbolHandler);
     }
 }
diff --git a/test/PlcInterface.OpcUa.Tests/ISymbolInfoExtensionTests.cs b/test/PlcInterface.OpcUa.Tests/ISymbolInfoExtensionTests.cs
@@ -16,8 +16,8 @@ public void CastAndValidateReturnsSymbolInfo()
         var actual = symbolInfo.ConvertAndValidate();
 
         // Assert
-        Assert.IsInstanceOfType(actual, typeof(IOpcSymbolInfo));
-        Assert.IsInstanceOfType(actual, typeof(ISymbolInfo));
+        Assert.IsInstanceOfType<IOpcSymbolInfo>(actual);
+        Assert.IsInstanceOfType<ISymbolInfo>(actual);
         Assert.AreSame(symbolInfo, actual);
     }