diff --git a/BinaryObjectScanner.Test/Data/StaticChecksTests.cs b/BinaryObjectScanner.Test/Data/StaticChecksTests.cs
index dafb7401..6901abd6 100644
--- a/BinaryObjectScanner.Test/Data/StaticChecksTests.cs
+++ b/BinaryObjectScanner.Test/Data/StaticChecksTests.cs
@@ -9,7 +9,7 @@ namespace BinaryObjectScanner.Test.Data
         public void ContentCheckClasses_Populated()
         {
             var actual = StaticChecks.ContentCheckClasses;
-            Assert.Equal(6, actual.Count);
+            Assert.Equal(6, actual.Length);
         }
 
         [Fact]
@@ -30,21 +30,21 @@ namespace BinaryObjectScanner.Test.Data
         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);
         }
     }
 }
\ No newline at end of file
diff --git a/BinaryObjectScanner/Data/StaticChecks.cs b/BinaryObjectScanner/Data/StaticChecks.cs
index c4ef4cb6..1e5afb31 100644
--- a/BinaryObjectScanner/Data/StaticChecks.cs
+++ b/BinaryObjectScanner/Data/StaticChecks.cs
@@ -13,72 +13,72 @@ namespace BinaryObjectScanner.Data
         /// <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 @@ namespace BinaryObjectScanner.Data
         /// <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 @@ namespace BinaryObjectScanner.Data
         /// <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 @@ namespace BinaryObjectScanner.Data
                     classTypes.Add(instance);
             }
 
-            return classTypes;
+            return [.. classTypes];
         }
 
         #endregion
diff --git a/BinaryObjectScanner/FileType/Executable.cs b/BinaryObjectScanner/FileType/Executable.cs
index b3cb1dd8..3868253e 100644
--- a/BinaryObjectScanner/FileType/Executable.cs
+++ b/BinaryObjectScanner/FileType/Executable.cs
@@ -79,7 +79,7 @@ namespace BinaryObjectScanner.FileType
         /// <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