Remove some unnecessary null handling, use arrays

mnadareski · mnadareski · commit d969dd691b23 · 2025-09-20T17:24:25.000-04:00
diff --git a/BinaryObjectScanner.Test/Data/StaticChecksTests.cs b/BinaryObjectScanner.Test/Data/StaticChecksTests.cs
@@ -9,7 +9,7 @@ public class StaticChecksTests
         public void ContentCheckClasses_Populated()
         {
             var actual = StaticChecks.ContentCheckClasses;
-            Assert.Equal(6, actual.Count);
+            Assert.Equal(6, actual.Length);
         }
 
         [Fact]
@@ -30,21 +30,21 @@ public void MSDOSExecutableCheckClasses_Empty()
         public void NewExecutableCheckClasses_Populated()
         {
             var actual = StaticChecks.NewExecutableCheckClasses;
-            Assert.Equal(7, actual.Count);
+            Assert.Equal(7, actual.Length);
         }
 
         [Fact]
         public void PathCheckClasses_Populated()
         {
             var actual = StaticChecks.PathCheckClasses;
-            Assert.Equal(68, actual.Count);
+            Assert.Equal(68, actual.Length);
         }
 
         [Fact]
         public void PortableExecutableCheckClasses_Populated()
         {
             var actual = StaticChecks.PortableExecutableCheckClasses;
-            Assert.Equal(105, actual.Count);
+            Assert.Equal(105, actual.Length);
         }
     }
 }
diff --git a/BinaryObjectScanner/Data/StaticChecks.cs b/BinaryObjectScanner/Data/StaticChecks.cs
@@ -13,72 +13,72 @@ internal static class StaticChecks
         /// <summary>
         /// Cache for all IContentCheck types
         /// </summary>
-        public static List<IContentCheck> ContentCheckClasses
+        public static IContentCheck[] ContentCheckClasses
         {
             get
             {
                 contentCheckClasses ??= InitCheckClasses<IContentCheck>();
-                return contentCheckClasses ?? [];
+                return contentCheckClasses;
             }
         }
 
         /// <summary>
         /// Cache for all IExecutableCheck<LinearExecutable> types
         /// </summary>
-        public static List<IExecutableCheck<LinearExecutable>> LinearExecutableCheckClasses
+        public static IExecutableCheck<LinearExecutable>[] LinearExecutableCheckClasses
         {
             get
             {
                 linearExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<LinearExecutable>>();
-                return linearExecutableCheckClasses ?? [];
+                return linearExecutableCheckClasses;
             }
         }
 
         /// <summary>
         /// Cache for all IExecutableCheck<MSDOS> types
         /// </summary>
-        public static List<IExecutableCheck<MSDOS>> MSDOSExecutableCheckClasses
+        public static IExecutableCheck<MSDOS>[] MSDOSExecutableCheckClasses
         {
             get
             {
                 msdosExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<MSDOS>>();
-                return msdosExecutableCheckClasses ?? [];
+                return msdosExecutableCheckClasses;
             }
         }
 
         /// <summary>
         /// Cache for all IExecutableCheck<NewExecutable> types
         /// </summary>
-        public static List<IExecutableCheck<NewExecutable>> NewExecutableCheckClasses
+        public static IExecutableCheck<NewExecutable>[] NewExecutableCheckClasses
         {
             get
             {
                 newExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<NewExecutable>>();
-                return newExecutableCheckClasses ?? [];
+                return newExecutableCheckClasses;
             }
         }
 
         /// <summary>
         /// Cache for all IPathCheck types
         /// </summary>
-        public static List<IPathCheck> PathCheckClasses
+        public static IPathCheck[] PathCheckClasses
         {
             get
             {
                 pathCheckClasses ??= InitCheckClasses<IPathCheck>();
-                return pathCheckClasses ?? [];
+                return pathCheckClasses;
             }
         }
 
         /// <summary>
         /// Cache for all IExecutableCheck<PortableExecutable> types
         /// </summary>
-        public static List<IExecutableCheck<PortableExecutable>> PortableExecutableCheckClasses
+        public static IExecutableCheck<PortableExecutable>[] PortableExecutableCheckClasses
         {
             get
             {
                 portableExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<PortableExecutable>>();
-                return portableExecutableCheckClasses ?? [];
+                return portableExecutableCheckClasses;
             }
         }
 
@@ -89,32 +89,32 @@ public static List<IExecutableCheck<PortableExecutable>> PortableExecutableCheck
         /// <summary>
         /// Cache for all IContentCheck types
         /// </summary>
-        private static List<IContentCheck>? contentCheckClasses;
+        private static IContentCheck[]? contentCheckClasses;
 
         /// <summary>
         /// Cache for all IExecutableCheck<LinearExecutable> types
         /// </summary>
-        private static List<IExecutableCheck<LinearExecutable>>? linearExecutableCheckClasses;
+        private static IExecutableCheck<LinearExecutable>[]? linearExecutableCheckClasses;
 
         /// <summary>
         /// Cache for all IExecutableCheck<MSDOS> types
         /// </summary>
-        private static List<IExecutableCheck<MSDOS>>? msdosExecutableCheckClasses;
+        private static IExecutableCheck<MSDOS>[]? msdosExecutableCheckClasses;
 
         /// <summary>
         /// Cache for all IExecutableCheck<NewExecutable> types
         /// </summary>
-        private static List<IExecutableCheck<NewExecutable>>? newExecutableCheckClasses;
+        private static IExecutableCheck<NewExecutable>[]? newExecutableCheckClasses;
 
         /// <summary>
         /// Cache for all IPathCheck types
         /// </summary>
-        private static List<IPathCheck>? pathCheckClasses;
+        private static IPathCheck[]? pathCheckClasses;
 
         /// <summary>
         /// Cache for all IExecutableCheck<PortableExecutable> types
         /// </summary>
-        private static List<IExecutableCheck<PortableExecutable>>? portableExecutableCheckClasses;
+        private static IExecutableCheck<PortableExecutable>[]? portableExecutableCheckClasses;
 
         #endregion
 
@@ -123,13 +123,13 @@ public static List<IExecutableCheck<PortableExecutable>> PortableExecutableCheck
         /// <summary>
         /// Initialize all implementations of a type
         /// </summary>
-        private static List<T>? InitCheckClasses<T>()
-            => InitCheckClasses<T>(Assembly.GetExecutingAssembly()) ?? [];
+        private static T[] InitCheckClasses<T>()
+            => InitCheckClasses<T>(Assembly.GetExecutingAssembly());
 
         /// <summary>
         /// Initialize all implementations of a type
         /// </summary>
-        private static List<T> InitCheckClasses<T>(Assembly assembly)
+        private static T[] InitCheckClasses<T>(Assembly assembly)
         {
             // Get information from the type param
             string? interfaceName = typeof(T).FullName;
@@ -174,7 +174,7 @@ private static List<T> InitCheckClasses<T>(Assembly assembly)
                     classTypes.Add(instance);
             }
 
-            return classTypes;
+            return [.. classTypes];
         }
 
         #endregion
diff --git a/BinaryObjectScanner/FileType/Executable.cs b/BinaryObjectScanner/FileType/Executable.cs
@@ -79,7 +79,7 @@ protected IDictionary<IContentCheck, string> RunContentChecks(string? file, Stre
         /// <param name="scanner">Scanner for handling recursive protections</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
         /// <returns>Set of protections in file, empty on error</returns>
-        protected IDictionary<U, string> RunExecutableChecks<U>(string file, T exe, List<U> checks, bool includeDebug)
+        protected IDictionary<U, string> RunExecutableChecks<U>(string file, T exe, U[] checks, bool includeDebug)
             where U : IExecutableCheck<T>
         {
             // Create the output dictionary

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public class StaticChecksTests`
`9`	`9`	`public void ContentCheckClasses_Populated()`
`10`	`10`	`{`
`11`	`11`	`var actual = StaticChecks.ContentCheckClasses;`
`12`		`- Assert.Equal(6, actual.Count);`
	`12`	`+ Assert.Equal(6, actual.Length);`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`[Fact]`
`@@ -30,21 +30,21 @@ public void MSDOSExecutableCheckClasses_Empty()`
`30`	`30`	`public void NewExecutableCheckClasses_Populated()`
`31`	`31`	`{`
`32`	`32`	`var actual = StaticChecks.NewExecutableCheckClasses;`
`33`		`- Assert.Equal(7, actual.Count);`
	`33`	`+ Assert.Equal(7, actual.Length);`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`[Fact]`
`37`	`37`	`public void PathCheckClasses_Populated()`
`38`	`38`	`{`
`39`	`39`	`var actual = StaticChecks.PathCheckClasses;`
`40`		`- Assert.Equal(68, actual.Count);`
	`40`	`+ Assert.Equal(68, actual.Length);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`[Fact]`
`44`	`44`	`public void PortableExecutableCheckClasses_Populated()`
`45`	`45`	`{`
`46`	`46`	`var actual = StaticChecks.PortableExecutableCheckClasses;`
`47`		`- Assert.Equal(105, actual.Count);`
	`47`	`+ Assert.Equal(105, actual.Length);`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,72 +13,72 @@ internal static class StaticChecks`
`13`	`13`	`/// <summary>`
`14`	`14`	`/// Cache for all IContentCheck types`
`15`	`15`	`/// </summary>`
`16`		`- public static List<IContentCheck> ContentCheckClasses`
	`16`	`+ public static IContentCheck[] ContentCheckClasses`
`17`	`17`	`{`
`18`	`18`	`get`
`19`	`19`	`{`
`20`	`20`	`contentCheckClasses ??= InitCheckClasses<IContentCheck>();`
`21`		`- return contentCheckClasses ?? [];`
	`21`	`+ return contentCheckClasses;`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`/// <summary>`
`26`	`26`	`/// Cache for all IExecutableCheck<LinearExecutable> types`
`27`	`27`	`/// </summary>`
`28`		`- public static List<IExecutableCheck<LinearExecutable>> LinearExecutableCheckClasses`
	`28`	`+ public static IExecutableCheck<LinearExecutable>[] LinearExecutableCheckClasses`
`29`	`29`	`{`
`30`	`30`	`get`
`31`	`31`	`{`
`32`	`32`	`linearExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<LinearExecutable>>();`
`33`		`- return linearExecutableCheckClasses ?? [];`
	`33`	`+ return linearExecutableCheckClasses;`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`/// <summary>`
`38`	`38`	`/// Cache for all IExecutableCheck<MSDOS> types`
`39`	`39`	`/// </summary>`
`40`		`- public static List<IExecutableCheck<MSDOS>> MSDOSExecutableCheckClasses`
	`40`	`+ public static IExecutableCheck<MSDOS>[] MSDOSExecutableCheckClasses`
`41`	`41`	`{`
`42`	`42`	`get`
`43`	`43`	`{`
`44`	`44`	`msdosExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<MSDOS>>();`
`45`		`- return msdosExecutableCheckClasses ?? [];`
	`45`	`+ return msdosExecutableCheckClasses;`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`/// <summary>`
`50`	`50`	`/// Cache for all IExecutableCheck<NewExecutable> types`
`51`	`51`	`/// </summary>`
`52`		`- public static List<IExecutableCheck<NewExecutable>> NewExecutableCheckClasses`
	`52`	`+ public static IExecutableCheck<NewExecutable>[] NewExecutableCheckClasses`
`53`	`53`	`{`
`54`	`54`	`get`
`55`	`55`	`{`
`56`	`56`	`newExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<NewExecutable>>();`
`57`		`- return newExecutableCheckClasses ?? [];`
	`57`	`+ return newExecutableCheckClasses;`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`/// <summary>`
`62`	`62`	`/// Cache for all IPathCheck types`
`63`	`63`	`/// </summary>`
`64`		`- public static List<IPathCheck> PathCheckClasses`
	`64`	`+ public static IPathCheck[] PathCheckClasses`
`65`	`65`	`{`
`66`	`66`	`get`
`67`	`67`	`{`
`68`	`68`	`pathCheckClasses ??= InitCheckClasses<IPathCheck>();`
`69`		`- return pathCheckClasses ?? [];`
	`69`	`+ return pathCheckClasses;`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/// <summary>`
`74`	`74`	`/// Cache for all IExecutableCheck<PortableExecutable> types`
`75`	`75`	`/// </summary>`
`76`		`- public static List<IExecutableCheck<PortableExecutable>> PortableExecutableCheckClasses`
	`76`	`+ public static IExecutableCheck<PortableExecutable>[] PortableExecutableCheckClasses`
`77`	`77`	`{`
`78`	`78`	`get`
`79`	`79`	`{`
`80`	`80`	`portableExecutableCheckClasses ??= InitCheckClasses<IExecutableCheck<PortableExecutable>>();`
`81`		`- return portableExecutableCheckClasses ?? [];`
	`81`	`+ return portableExecutableCheckClasses;`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`@@ -89,32 +89,32 @@ public static List<IExecutableCheck<PortableExecutable>> PortableExecutableCheck`
`89`	`89`	`/// <summary>`
`90`	`90`	`/// Cache for all IContentCheck types`
`91`	`91`	`/// </summary>`
`92`		`- private static List<IContentCheck>? contentCheckClasses;`
	`92`	`+ private static IContentCheck[]? contentCheckClasses;`
`93`	`93`
`94`	`94`	`/// <summary>`
`95`	`95`	`/// Cache for all IExecutableCheck<LinearExecutable> types`
`96`	`96`	`/// </summary>`
`97`		`- private static List<IExecutableCheck<LinearExecutable>>? linearExecutableCheckClasses;`
	`97`	`+ private static IExecutableCheck<LinearExecutable>[]? linearExecutableCheckClasses;`
`98`	`98`
`99`	`99`	`/// <summary>`
`100`	`100`	`/// Cache for all IExecutableCheck<MSDOS> types`
`101`	`101`	`/// </summary>`
`102`		`- private static List<IExecutableCheck<MSDOS>>? msdosExecutableCheckClasses;`
	`102`	`+ private static IExecutableCheck<MSDOS>[]? msdosExecutableCheckClasses;`
`103`	`103`
`104`	`104`	`/// <summary>`
`105`	`105`	`/// Cache for all IExecutableCheck<NewExecutable> types`
`106`	`106`	`/// </summary>`
`107`		`- private static List<IExecutableCheck<NewExecutable>>? newExecutableCheckClasses;`
	`107`	`+ private static IExecutableCheck<NewExecutable>[]? newExecutableCheckClasses;`
`108`	`108`
`109`	`109`	`/// <summary>`
`110`	`110`	`/// Cache for all IPathCheck types`
`111`	`111`	`/// </summary>`
`112`		`- private static List<IPathCheck>? pathCheckClasses;`
	`112`	`+ private static IPathCheck[]? pathCheckClasses;`
`113`	`113`
`114`	`114`	`/// <summary>`
`115`	`115`	`/// Cache for all IExecutableCheck<PortableExecutable> types`
`116`	`116`	`/// </summary>`
`117`		`- private static List<IExecutableCheck<PortableExecutable>>? portableExecutableCheckClasses;`
	`117`	`+ private static IExecutableCheck<PortableExecutable>[]? portableExecutableCheckClasses;`
`118`	`118`
`119`	`119`	`#endregion`
`120`	`120`
`@@ -123,13 +123,13 @@ public static List<IExecutableCheck<PortableExecutable>> PortableExecutableCheck`
`123`	`123`	`/// <summary>`
`124`	`124`	`/// Initialize all implementations of a type`
`125`	`125`	`/// </summary>`
`126`		`- private static List<T>? InitCheckClasses<T>()`
`127`		`- => InitCheckClasses<T>(Assembly.GetExecutingAssembly()) ?? [];`
	`126`	`+ private static T[] InitCheckClasses<T>()`
	`127`	`+ => InitCheckClasses<T>(Assembly.GetExecutingAssembly());`
`128`	`128`
`129`	`129`	`/// <summary>`
`130`	`130`	`/// Initialize all implementations of a type`
`131`	`131`	`/// </summary>`
`132`		`- private static List<T> InitCheckClasses<T>(Assembly assembly)`
	`132`	`+ private static T[] InitCheckClasses<T>(Assembly assembly)`
`133`	`133`	`{`
`134`	`134`	`// Get information from the type param`
`135`	`135`	`string? interfaceName = typeof(T).FullName;`
`@@ -174,7 +174,7 @@ private static List<T> InitCheckClasses<T>(Assembly assembly)`
`174`	`174`	`classTypes.Add(instance);`
`175`	`175`	`}`
`176`	`176`
`177`		`- return classTypes;`
	`177`	`+ return [.. classTypes];`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ protected IDictionary<IContentCheck, string> RunContentChecks(string? file, Stre`
`79`	`79`	`/// <param name="scanner">Scanner for handling recursive protections</param>`
`80`	`80`	`/// <param name="includeDebug">True to include debug data, false otherwise</param>`
`81`	`81`	`/// <returns>Set of protections in file, empty on error</returns>`
`82`		`- protected IDictionary<U, string> RunExecutableChecks<U>(string file, T exe, List<U> checks, bool includeDebug)`
	`82`	`+ protected IDictionary<U, string> RunExecutableChecks<U>(string file, T exe, U[] checks, bool includeDebug)`
`83`	`83`	`where U : IExecutableCheck<T>`
`84`	`84`	`{`
`85`	`85`	`// Create the output dictionary`