✏️ Change param includeNestedClass to nested

DrSensor · DrSensor · commit c5745b55c1de · 2018-04-25T03:04:12.000+07:00
- Release 1.2.0 🔖
diff --git a/Framework/AspNetCore/IServiceCollectionExtensions.cs b/Framework/AspNetCore/IServiceCollectionExtensions.cs
@@ -9,68 +9,68 @@ public static class IServiceCollectionExtensions
     {
         public static IServiceCollection BatchInject(
             this IServiceCollection services, Action<Type, Type> injector, dynamic filter,
-            dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)
+            dynamic blacklist = null, bool parallel = false, bool nested = true)
         {
-            BatchDI.BatchInject(injector, filter, blacklist, parallel, includeNestedClass);
+            BatchDI.BatchInject(injector, filter, blacklist, parallel, nested);
             return services;
         }
 
         public static IServiceCollection BatchInject(
             this IServiceCollection services, Action<Type> injector, dynamic filter,
-            dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)
+            dynamic blacklist = null, bool parallel = false, bool nested = true)
         {
-            BatchDI.BatchInject(injector, filter, blacklist, parallel, includeNestedClass);
+            BatchDI.BatchInject(injector, filter, blacklist, parallel, nested);
             return services;
         }
 
         public static IServiceCollection BatchSingleton(
             this IServiceCollection services, dynamic filter,
-            dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)
+            dynamic blacklist = null, bool parallel = false, bool nested = true)
         {
 
             if (BatchDI.filterHasInterface(filter))
             {
                 Action<Type, Type> caller = (_interface, _implementation) => services.AddSingleton(_interface, _implementation);
-                BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);
+                BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);
             }
             else
             {
                 Action<Type> caller = (_implementation) => services.AddSingleton(_implementation);
-                BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);
+                BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);
             }
             return services;
         }
 
         public static IServiceCollection BatchTransient(
             this IServiceCollection services, string filter,
-            dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)
+            dynamic blacklist = null, bool parallel = false, bool nested = true)
         {
             if (BatchDI.filterHasInterface(filter))
             {
                 Action<Type, Type> caller = (_interface, _implementation) => services.AddTransient(_interface, _implementation);
-                BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);
+                BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);
             }
             else
             {
                 Action<Type> caller = (_implementation) => services.AddTransient(_implementation);
-                BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);
+                BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);
             }
             return services;
         }
 
         public static IServiceCollection BatchScoped(
             this IServiceCollection services, string filter,
-            dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)
+            dynamic blacklist = null, bool parallel = false, bool nested = true)
         {
             if (BatchDI.filterHasInterface(filter))
             {
                 Action<Type, Type> caller = (_interface, _implementation) => services.AddScoped(_interface, _implementation);
-                BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);
+                BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);
             }
             else
             {
                 Action<Type> caller = (_implementation) => services.AddScoped(_implementation);
-                BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);
+                BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);
             }
             return services;
         }
diff --git a/Library/BatchDI.cs b/Library/BatchDI.cs
@@ -16,7 +16,7 @@ public static bool filterHasInterface(string filter)
                     (filter.StartsWith("*") && filter.EndsWith("*"));
         }
 
-        private static void BatchInjector(Delegate injector, string filter, dynamic blacklist, bool parallel, bool includeNestedClass)
+        private static void BatchInjector(Delegate injector, string filter, dynamic blacklist, bool parallel, bool nested)
         {
             // Filter based on namespace and provided pattern
             var types = from a in EntryAssembly.GetReferencedAssemblies().Select(Assembly.Load)
@@ -62,7 +62,7 @@ void invoke(Type implementation)
             #region Helper
             void nestedInvoke(Type i) // WARN: recursive function
             {
-                if (i.GetNestedTypes().Length < 1 && !includeNestedClass) return; // stop if empty
+                if (i.GetNestedTypes().Length < 1 && !nested) return; // stop if empty
                 void invoke(Type g)
                 {
                     injector.DynamicInvoke(g);
diff --git a/Library/BatchDI_API.cs b/Library/BatchDI_API.cs
@@ -9,28 +9,28 @@ public partial class BatchDI
         public static void BatchInject(Action<Type, Type> injector, dynamic filter,
                                         dynamic blacklist = null,
                                         bool parallel = false,
-                                        bool includeNestedClass = true
+                                        bool nested = true
                                         )
         {
-            inject(injector, filter, blacklist, parallel, includeNestedClass);
+            inject(injector, filter, blacklist, parallel, nested);
         }
 
         // only class
         public static void BatchInject(Action<Type> injector, dynamic filter,
                                         dynamic blacklist = null,
                                         bool parallel = false,
-                                        bool includeNestedClass = true
+                                        bool nested = true
                                         )
         {
-            inject(injector, filter, blacklist, parallel, includeNestedClass);
+            inject(injector, filter, blacklist, parallel, nested);
         }
 
         public static void SetEntryAssembly(Assembly assembly) => EntryAssembly = assembly;
 
-        private static void inject(dynamic caller, dynamic filter, dynamic blacklist, bool parallel, bool includeNestedClass)
+        private static void inject(dynamic caller, dynamic filter, dynamic blacklist, bool parallel, bool nested)
         {
-            if (filter is string) BatchInjector(caller, filter, blacklist, parallel, includeNestedClass);
-            else if (filter is string[]) foreach (var f in filter) BatchInjector(caller, f, blacklist, parallel, includeNestedClass);
+            if (filter is string) BatchInjector(caller, filter, blacklist, parallel, nested);
+            else if (filter is string[]) foreach (var f in filter) BatchInjector(caller, f, blacklist, parallel, nested);
             else throw new System.ArgumentException($"{nameof(filter)} must be `string` or `string[]`");
         }
     }
diff --git a/README.md b/README.md
@@ -196,15 +196,15 @@ _server = new TestServer(new WebHostBuilder().SetBatchDIEntryPoint<Startup>().Us
 | `filter`                        | list or glob pattern for specify which class name to inject              | `string`, <br>`string[]`                 |
 | `blacklist` (optional)          | list or glob pattern for specify which class name **not** to be injected | `string`, <br>`string[]`                 |
 | `parallel` (optional)           | if the startup time become slower, try to set this `true`                | `bool`                                   | `false`       |
-| `includeNestedClass` (optional) | choose if also to inject nested class                                    | `bool`                                   | `true`        |
+| `nested` (optional) | choose if also to inject nested class                                    | `bool`                                   | `true`        |
 
 </details>
 
 ### BatchDI
 
 | Method                                                                           | Description                                                                 | Return |
 | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------ |
-| `BatchInject(injector =>{}, filter, blacklist?, parallel?, includeNestedClass?)` | implement custom dependency injection based on filter pattern and blacklist |
+| `BatchInject(injector =>{}, filter, blacklist?, parallel?, nested?)` | implement custom dependency injection based on filter pattern and blacklist |
 | `SetEntryAssembly(Assembly assembly)`                                            | Try to set this this in case there is an error                              |
 
 ### BatchDI.AspNetCore
@@ -213,9 +213,9 @@ This library extend `IServiceCollection` usage by adding additional method for b
 
 | Method                                                               | Description                                 | Return               |
 | -------------------------------------------------------------------- | ------------------------------------------- | -------------------- |
-| `BatchSingleton(filter, blacklist?, parallel?, includeNestedClass?)` | Batch/MultipleAdd version of `AddSingleton` | `IServiceCollection` |
-| `BatchTransient(filter, blacklist?, parallel?, includeNestedClass?)` | Batch/MultipleAdd version of `AddTransient` | `IServiceCollection` |
-| `BatchScoped(filter, blacklist?, parallel?, includeNestedClass?)`    | Batch/MultipleAdd version of `AddScoped`    | `IServiceCollection` |
+| `BatchSingleton(filter, blacklist?, parallel?, nested?)` | Batch/MultipleAdd version of `AddSingleton` | `IServiceCollection` |
+| `BatchTransient(filter, blacklist?, parallel?, nested?)` | Batch/MultipleAdd version of `AddTransient` | `IServiceCollection` |
+| `BatchScoped(filter, blacklist?, parallel?, nested?)`    | Batch/MultipleAdd version of `AddScoped`    | `IServiceCollection` |
 
 ---
 
diff --git a/appveyor.yml b/appveyor.yml
@@ -1,4 +1,4 @@
-version: 1.1.{build}
+version: 1.2.{build}
 
 # NOTE .NET Core SDK is already installed in the build worker image Visual Studio 2017
 # so the `install` section is not required

Original file line number	Diff line number	Diff line change
`@@ -9,68 +9,68 @@ public static class IServiceCollectionExtensions`
`9`	`9`	`{`
`10`	`10`	`public static IServiceCollection BatchInject(`
`11`	`11`	`this IServiceCollection services, Action<Type, Type> injector, dynamic filter,`
`12`		`- dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)`
	`12`	`+ dynamic blacklist = null, bool parallel = false, bool nested = true)`
`13`	`13`	`{`
`14`		`- BatchDI.BatchInject(injector, filter, blacklist, parallel, includeNestedClass);`
	`14`	`+ BatchDI.BatchInject(injector, filter, blacklist, parallel, nested);`
`15`	`15`	`return services;`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public static IServiceCollection BatchInject(`
`19`	`19`	`this IServiceCollection services, Action<Type> injector, dynamic filter,`
`20`		`- dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)`
	`20`	`+ dynamic blacklist = null, bool parallel = false, bool nested = true)`
`21`	`21`	`{`
`22`		`- BatchDI.BatchInject(injector, filter, blacklist, parallel, includeNestedClass);`
	`22`	`+ BatchDI.BatchInject(injector, filter, blacklist, parallel, nested);`
`23`	`23`	`return services;`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public static IServiceCollection BatchSingleton(`
`27`	`27`	`this IServiceCollection services, dynamic filter,`
`28`		`- dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)`
	`28`	`+ dynamic blacklist = null, bool parallel = false, bool nested = true)`
`29`	`29`	`{`
`30`	`30`
`31`	`31`	`if (BatchDI.filterHasInterface(filter))`
`32`	`32`	`{`
`33`	`33`	`Action<Type, Type> caller = (_interface, _implementation) => services.AddSingleton(_interface, _implementation);`
`34`		`- BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);`
	`34`	`+ BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);`
`35`	`35`	`}`
`36`	`36`	`else`
`37`	`37`	`{`
`38`	`38`	`Action<Type> caller = (_implementation) => services.AddSingleton(_implementation);`
`39`		`- BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);`
	`39`	`+ BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);`
`40`	`40`	`}`
`41`	`41`	`return services;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public static IServiceCollection BatchTransient(`
`45`	`45`	`this IServiceCollection services, string filter,`
`46`		`- dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)`
	`46`	`+ dynamic blacklist = null, bool parallel = false, bool nested = true)`
`47`	`47`	`{`
`48`	`48`	`if (BatchDI.filterHasInterface(filter))`
`49`	`49`	`{`
`50`	`50`	`Action<Type, Type> caller = (_interface, _implementation) => services.AddTransient(_interface, _implementation);`
`51`		`- BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);`
	`51`	`+ BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);`
`52`	`52`	`}`
`53`	`53`	`else`
`54`	`54`	`{`
`55`	`55`	`Action<Type> caller = (_implementation) => services.AddTransient(_implementation);`
`56`		`- BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);`
	`56`	`+ BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);`
`57`	`57`	`}`
`58`	`58`	`return services;`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`public static IServiceCollection BatchScoped(`
`62`	`62`	`this IServiceCollection services, string filter,`
`63`		`- dynamic blacklist = null, bool parallel = false, bool includeNestedClass = true)`
	`63`	`+ dynamic blacklist = null, bool parallel = false, bool nested = true)`
`64`	`64`	`{`
`65`	`65`	`if (BatchDI.filterHasInterface(filter))`
`66`	`66`	`{`
`67`	`67`	`Action<Type, Type> caller = (_interface, _implementation) => services.AddScoped(_interface, _implementation);`
`68`		`- BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);`
	`68`	`+ BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);`
`69`	`69`	`}`
`70`	`70`	`else`
`71`	`71`	`{`
`72`	`72`	`Action<Type> caller = (_implementation) => services.AddScoped(_implementation);`
`73`		`- BatchDI.BatchInject(caller, filter, blacklist, parallel, includeNestedClass);`
	`73`	`+ BatchDI.BatchInject(caller, filter, blacklist, parallel, nested);`
`74`	`74`	`}`
`75`	`75`	`return services;`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public static bool filterHasInterface(string filter)`
`16`	`16`	`(filter.StartsWith("") && filter.EndsWith(""));`
`17`	`17`	`}`
`18`	`18`
`19`		`- private static void BatchInjector(Delegate injector, string filter, dynamic blacklist, bool parallel, bool includeNestedClass)`
	`19`	`+ private static void BatchInjector(Delegate injector, string filter, dynamic blacklist, bool parallel, bool nested)`
`20`	`20`	`{`
`21`	`21`	`// Filter based on namespace and provided pattern`
`22`	`22`	`var types = from a in EntryAssembly.GetReferencedAssemblies().Select(Assembly.Load)`
`@@ -62,7 +62,7 @@ void invoke(Type implementation)`
`62`	`62`	`#region Helper`
`63`	`63`	`void nestedInvoke(Type i) // WARN: recursive function`
`64`	`64`	`{`
`65`		`- if (i.GetNestedTypes().Length < 1 && !includeNestedClass) return; // stop if empty`
	`65`	`+ if (i.GetNestedTypes().Length < 1 && !nested) return; // stop if empty`
`66`	`66`	`void invoke(Type g)`
`67`	`67`	`{`
`68`	`68`	`injector.DynamicInvoke(g);`
Original file line number	Diff line number	Diff line change
`@@ -9,28 +9,28 @@ public partial class BatchDI`
`9`	`9`	`public static void BatchInject(Action<Type, Type> injector, dynamic filter,`
`10`	`10`	`dynamic blacklist = null,`
`11`	`11`	`bool parallel = false,`
`12`		`- bool includeNestedClass = true`
	`12`	`+ bool nested = true`
`13`	`13`	`)`
`14`	`14`	`{`
`15`		`- inject(injector, filter, blacklist, parallel, includeNestedClass);`
	`15`	`+ inject(injector, filter, blacklist, parallel, nested);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`// only class`
`19`	`19`	`public static void BatchInject(Action<Type> injector, dynamic filter,`
`20`	`20`	`dynamic blacklist = null,`
`21`	`21`	`bool parallel = false,`
`22`		`- bool includeNestedClass = true`
	`22`	`+ bool nested = true`
`23`	`23`	`)`
`24`	`24`	`{`
`25`		`- inject(injector, filter, blacklist, parallel, includeNestedClass);`
	`25`	`+ inject(injector, filter, blacklist, parallel, nested);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`public static void SetEntryAssembly(Assembly assembly) => EntryAssembly = assembly;`
`29`	`29`
`30`		`- private static void inject(dynamic caller, dynamic filter, dynamic blacklist, bool parallel, bool includeNestedClass)`
	`30`	`+ private static void inject(dynamic caller, dynamic filter, dynamic blacklist, bool parallel, bool nested)`
`31`	`31`	`{`
`32`		`- if (filter is string) BatchInjector(caller, filter, blacklist, parallel, includeNestedClass);`
`33`		`- else if (filter is string[]) foreach (var f in filter) BatchInjector(caller, f, blacklist, parallel, includeNestedClass);`
	`32`	`+ if (filter is string) BatchInjector(caller, filter, blacklist, parallel, nested);`
	`33`	`+ else if (filter is string[]) foreach (var f in filter) BatchInjector(caller, f, blacklist, parallel, nested);`
`34`	`34`	else throw new System.ArgumentException($"{nameof(filter)} must be `string` or `string[]`");
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-version: 1.1.{build}`
	`1`	`+version: 1.2.{build}`
`2`	`2`
`3`	`3`	`# NOTE .NET Core SDK is already installed in the build worker image Visual Studio 2017`
`4`	`4`	# so the `install` section is not required