Added strong naming.

Fixed Guard.NotNull usage validation when type is not provided.

Author: Balint Nagy

LICENSE

@@ -38,6 +38,15 @@ public void AgainstNull_ShouldFail_WhenIncorrectlyInvoked2()
             Guard.AgainstNull(new { one = "anonymous argument", two = "has too many properties" });
         }
 
+        [TestMethod]
+        [DataRow("")]
+        [DataRow(" ")]
+        [DataRow("blah")]
+        public void AgainstNullT_ShouldSucceed_EvenIfTypeIsString(string goodValue)
+        {
+            Guard.AgainstNull(new { goodValue });
+        }
+
         [TestMethod]
         [DataRow("")]
         [DataRow(" ")]

YAGuard/YAGuard.Test/GuardTests.cs

@@ -38,7 +38,7 @@ internal static void AssertType(object arg, Type expectedType)
         internal static TValue GetProp0Value<TValue>(object arg)
         {
             Guard.AgainstNull(arg, nameof(arg));
-            AssertType(arg, typeof(TValue));
+            //AssertType(arg, typeof(TValue));
             return (TValue)arg.GetType().GetProperties()[0].GetValue(arg);
         }
 
@@ -61,8 +61,8 @@ internal static void CheckUsage<TValue>(object arg)
                 throw new ArgumentException($"Invalid use of SafeAssign.Assign(). The anonymous object argument should have a single property, containing the argument to test and return. Usage example:\n{usage}");
 
             // Check that the single property of arg is of type TValue
-            if (props[0].PropertyType != typeof(TValue))
-                throw new ArgumentException($"Invalid use of SafeAssign.Assign(). The anonymous object argument type {props[0].PropertyType.Name} doesn't match the expected result type {nameof(TValue)}. Usage example:\n{usage}");
+            //if (props[0].PropertyType != typeof(TValue))
+            //    throw new ArgumentException($"Invalid use of SafeAssign.Assign(). The anonymous object argument type {props[0].PropertyType.Name} doesn't match the expected result type {nameof(TValue)}. Usage example:\n{usage}");
         }
     }
 }

YAGuard/YAGuard/ArgHelper.cs

@@ -12,11 +12,11 @@ public static class Guard
     {
         #region Generic Checks
 
-        //public static void AgainstCondition(bool condition, string argName = null, string message = null)
-        //{
-        //    if (condition)
-        //        throw new ArgumentException(message ?? $"Argument {argName ?? ""} did not satisfy condition.");
-        //}
+        public static void AgainstCondition(bool condition, string argName = null, string message = null)
+        {
+            if (condition)
+                throw new ArgumentException(message ?? $"Argument {argName ?? ""} did not satisfy condition.");
+        }
 
         //public static void AgainstCondition(Func<bool> condition, string argName = null, string message = null)
         //{

YAGuard/YAGuard/Guard.cs

@@ -22,7 +22,20 @@ The alternative where you provide the argument nameis fast. The one without is c
     <RepositoryType>github</RepositoryType>
     <AssemblyVersion>0.0.0.0</AssemblyVersion>
     <FileVersion>0.0.0.0</FileVersion>
-    <Version>0.0.0</Version>
+    <Version>0.0.4</Version>
+    <PackageReleaseNotes>Yet Another Guard argument validation package.
+The need to provide the name of the argument was driving me mad - here we go, without that.
+Usage:
+public void MyFunc(string myArg)
+{
+    Guard.AgainstNull(myArg, nameof(myArg));
+    // OR
+    Guard.AgainstNull(new {myArg});
+}
+In case myArg is null, this will throw an ArgumentNullException with the correct argument name.
+The alternative where you provide the argument nameis fast. The one without is convenient (it uses reflection, so it's slower). You can decide which one you need in any case.</PackageReleaseNotes>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>StrongNamingKey.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Debug|netcoreapp2.2|AnyCPU'">