Use safe GetConstructor extension everywhere

Author: C0nquistadore

shared/Extensions/ReflectionExtensions.cs

@@ -40,15 +40,16 @@ public static MethodInfo SafeGetMethod(this Type type, string methodName, Bindin
             return method;
         }
 
-        public static ConstructorInfo GetConstructor(this Type implementationType, params Type[] constructorSignature)
+        public static ConstructorInfo GetConstructorSafe(this Type implementationType, params Type[] constructorSignature) => GetConstructorSafe(implementationType, BindingFlags.Instance | BindingFlags.Public, constructorSignature);
+        public static ConstructorInfo GetConstructorSafe(this Type implementationType, BindingFlags bindingFlags, params Type[] constructorSignature)
         {
-            foreach (ConstructorInfo constructor in implementationType.GetConstructors())
+            foreach (ConstructorInfo constructor in implementationType.GetConstructors(bindingFlags))
             {
                 if (constructorSignature.SequenceEqual(constructor.GetParameters().Select(x => x.ParameterType)))
                     return constructor;
             }
 
-            throw new InvalidOperationException($"Could not find constructor ({String.Join(", ", constructorSignature.Select(x => x.ToString()))}) on type: {implementationType}");
+            throw new InvalidOperationException($"Could not find constructor {implementationType.Name}({String.Join(", ", constructorSignature.Select(x => x.ToString()))}) [{bindingFlags}]");
         }
     }
 }

src/Dibix.Sdk.Cli/TaskRunner.cs

@@ -55,7 +55,7 @@ private static IEnumerable<TaskRegistration> CollectTasks()
                     throw new InvalidOperationException($"Type '{type}' is decorated with {nameof(TaskAttribute)}, but does not implement '{taskInterfaceType}'.");
 
                 bool supportsInputConfiguration = type.GetCustomAttributes<TaskPropertyAttribute>().Any(x => x.Source == TaskPropertySource.Core);
-                ConstructorInfo ctor = type.GetConstructor(ConstructorSignature);
+                ConstructorInfo ctor = type.GetConstructorSafe(ConstructorSignature);
 
                 ParameterExpression loggerParameter = Expression.Parameter(typeof(ILogger), "logger");
                 ParameterExpression inputConfigurationParameter = Expression.Parameter(typeof(InputConfiguration), "inputConfiguration");

src/Dibix.Sdk.CodeAnalysis/SqlCodeAnalysisRuleMap.cs

@@ -43,7 +43,7 @@ private static IEnumerable<RuleRegistration> ScanRules()
         private static Func<SqlCodeAnalysisContext, IEnumerable<SqlCodeAnalysisError>> CompileRuleInvoker(Type ruleType)
         {
             ParameterExpression contextParameter = Expression.Parameter(typeof(SqlCodeAnalysisContext), "context");
-            ConstructorInfo ctor = ruleType.GetConstructor(typeof(SqlCodeAnalysisContext));
+            ConstructorInfo ctor = ruleType.GetConstructorSafe(typeof(SqlCodeAnalysisContext));
             Expression ruleInstance = Expression.New(ctor, contextParameter);
             MethodInfo analyzeMethod = typeof(ISqlCodeAnalysisRule).SafeGetMethod(nameof(ISqlCodeAnalysisRule.Analyze));
             Expression fragment = Expression.Property(contextParameter, nameof(SqlCodeAnalysisContext.Fragment));

src/Dibix.Sdk.Sql/PublicSqlDataSchemaModelLoader.cs

@@ -122,7 +122,7 @@ private static LoadPublicDataSchemaModel CompileModelFactory()
             // TaskLoggingHelper loggingHelper = new TaskLoggingHelper(task);
             Type loggingHelperType = typeof(TaskLoggingHelper);
             ParameterExpression loggingHelperVariable = Expression.Variable(loggingHelperType, "loggingHelper");
-            ConstructorInfo loggingHelperCtor = loggingHelperType.GetConstructor(new[] { typeof(ITask) });
+            ConstructorInfo loggingHelperCtor = loggingHelperType.GetConstructorSafe(typeof(ITask));
             Expression loggingHelperValue = Expression.New(loggingHelperCtor, taskParameter);
             Expression loggingHelperAssign = Expression.Assign(loggingHelperVariable, loggingHelperValue);
 
@@ -173,7 +173,7 @@ private static LoadPublicDataSchemaModel CompileModelFactory()
             Expression loadedTaskHostProperty = Expression.Property(hostLoaderVariable, "LoadedTaskHost");
             MemberExpression modelProperty = Expression.Property(loadedTaskHostProperty, "Model");
             Type dataSchemaModelType = DacReflectionUtility.SchemaSqlAssembly.GetType("Microsoft.Data.Tools.Schema.SchemaModel.DataSchemaModel", true);
-            ConstructorInfo modelCtor = typeof(TSqlModel).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { dataSchemaModelType }, null);
+            ConstructorInfo modelCtor = typeof(TSqlModel).GetConstructorSafe(BindingFlags.NonPublic | BindingFlags.Instance, dataSchemaModelType);
             Expression modelValue = Expression.New(modelCtor, modelProperty);
 
 

src/Dibix.Sdk.Sql/SchemaAnalyzer.cs

@@ -75,7 +75,7 @@ private static AnalyzeSchema CompileAnalyzer()
             Expression lazyExport = Expression.Field(null, typeof(SchemaAnalyzer), nameof(LazyExport));
             Type extensionDescriptorType = SchemaSqlAssembly.GetType("Microsoft.SqlServer.Dac.Extensibility.ExtensionDescriptor`2", true)
                                                             .MakeGenericType(typeof(SqlAnalysisRule), typeof(ISqlAnalysisRuleMetadata));
-            ConstructorInfo extensionDescriptorCtor = extensionDescriptorType.GetConstructor(new[] { lazyExport.Type });
+            ConstructorInfo extensionDescriptorCtor = extensionDescriptorType.GetConstructorSafe(lazyExport.Type);
             Guard.IsNotNull(extensionDescriptorCtor, nameof(extensionDescriptorCtor), "Could not find constructor on ExtensionDescriptor<,>");
             ParameterExpression extensionDescriptorVariable = Expression.Variable(extensionDescriptorType, "extensionDescriptor");
             Expression extensionDescriptorValue = Expression.New(extensionDescriptorCtor, lazyExport);
@@ -84,15 +84,15 @@ private static AnalyzeSchema CompileAnalyzer()
             // RuleDescriptor ruleDescriptor = new RuleDescriptorImpl(extensionDescriptor);
             Type ruleDescriptorType = DacExtensionsAssembly.GetType("Microsoft.SqlServer.Dac.CodeAnalysis.RuleDescriptor", true);
             Type ruleDescriptorImplType = DacExtensionsAssembly.GetType("Microsoft.SqlServer.Dac.CodeAnalysis.Engine.RuleDescriptorImpl", true);
-            ConstructorInfo ruleDescriptorImplCtor = ruleDescriptorImplType.GetConstructor(new[] { extensionDescriptorType });
+            ConstructorInfo ruleDescriptorImplCtor = ruleDescriptorImplType.GetConstructorSafe(extensionDescriptorType);
             Guard.IsNotNull(ruleDescriptorImplCtor, nameof(ruleDescriptorImplCtor), "Could not find constructor on RuleDescriptorImpl");
             ParameterExpression ruleDescriptorVariable = Expression.Variable(ruleDescriptorType, "ruleDescriptor");
             Expression ruleDescriptorValue = Expression.New(ruleDescriptorImplCtor, extensionDescriptorVariable);
             Expression ruleDescriptorAssign = Expression.Assign(ruleDescriptorVariable, ruleDescriptorValue);
 
             // NullableColumnSchemaAnalyzer nullableColumnSchemaAnalyzer = new NullableColumnSchemaAnalyzer(ruleDescriptor, dataSchemaModel, modelElement);
             Type nullableColumnSchemaAnalyzerType = DacExtensionsAssembly.GetType("Microsoft.SqlServer.Dac.CodeAnalysis.Rules.Performance.NullableColumnSchemaAnalyzer");
-            ConstructorInfo nullableColumnSchemaAnalyzerCtor = nullableColumnSchemaAnalyzerType.GetConstructor(new[] { ruleDescriptorType, TSqlModelType, TSqlObjectType });
+            ConstructorInfo nullableColumnSchemaAnalyzerCtor = nullableColumnSchemaAnalyzerType.GetConstructorSafe(ruleDescriptorType, TSqlModelType, TSqlObjectType);
             Guard.IsNotNull(nullableColumnSchemaAnalyzerCtor, nameof(nullableColumnSchemaAnalyzerCtor), "Could not find constructor on NullableColumnSchemaAnalyzer");
             ParameterExpression nullableColumnSchemaAnalyzerVariable = Expression.Variable(nullableColumnSchemaAnalyzerType, "nullableColumnSchemaAnalyzer");
             Expression nullableColumnSchemaAnalyzerValue = Expression.New(nullableColumnSchemaAnalyzerCtor, ruleDescriptorVariable, dataSchemaModelParameter, modelElementParameter);
@@ -208,7 +208,7 @@ private static void CompileSchemaAnalyzerResultsIterator(Expression resultVariab
 
             // ElementLocation location = new ElementLocation(offset, elementDescriptor.Identifiers, elementAccessor);
             Type elementLocationType = typeof(ElementLocation);
-            ConstructorInfo elementLocationCtor = elementLocationType.GetConstructor(new[] { typeof(int), typeof(IEnumerable<string>), elementAccessorType });
+            ConstructorInfo elementLocationCtor = elementLocationType.GetConstructorSafe(typeof(int), typeof(IEnumerable<string>), elementAccessorType);
             Guard.IsNotNull(elementLocationCtor, nameof(elementLocationCtor), "Could not find constructor on ElementLocation");
             Expression identifiersProperty = Expression.Property(elementDescriptorVariable, "Identifiers");
             ParameterExpression locationVariable = Expression.Variable(elementLocationType, "location");

src/Dibix.Testing/Configuration/ConfigurationProxyBuilder.cs

@@ -9,7 +9,7 @@ namespace Dibix.Testing
     internal static class ConfigurationProxyBuilder
     {
         private static readonly Type PropertyInitializationTrackerType = typeof(ConfigurationPropertyInitializationTracker);
-        private static readonly ConstructorInfo PropertyInitializationTrackerCtor = PropertyInitializationTrackerType.GetConstructor(new[] { typeof(ConfigurationInitializationToken) });
+        private static readonly ConstructorInfo PropertyInitializationTrackerCtor = PropertyInitializationTrackerType.GetConstructorSafe(typeof(ConfigurationInitializationToken));
         private static readonly MethodInfo PropertyInitializationTrackerEnterSectionMethod = PropertyInitializationTrackerType.SafeGetMethod(nameof(ConfigurationPropertyInitializationTracker.EnterSection), new[] { typeof(string) });
         private static readonly MethodInfo PropertyInitializationTrackerVerifyMethod = PropertyInitializationTrackerType.SafeGetMethod(nameof(ConfigurationPropertyInitializationTracker.Verify));
         private static readonly MethodInfo PropertyInitializationTrackerInitializeMethod = PropertyInitializationTrackerType.SafeGetMethod(nameof(ConfigurationPropertyInitializationTracker.Initialize));
@@ -64,7 +64,7 @@ private static Type BuildProxyType(Type type, ModuleBuilder moduleBuilder = null
 
             // Call base ctor
             ctorIL.Emit(OpCodes.Ldarg_0); // this
-            ctorIL.Emit(OpCodes.Call, type.GetConstructor(Type.EmptyTypes)); // this
+            ctorIL.Emit(OpCodes.Call, type.GetConstructorSafe(Type.EmptyTypes)); // this
             ctorIL.Emit(OpCodes.Nop);
 
             ctorIL.Emit(OpCodes.Nop);
@@ -151,7 +151,7 @@ private static void DefineComplexProperty(PropertyInfo property, ModuleBuilder m
             // this.Property = new ConfigurationProxy(initializationToken);
             ctorIL.Emit(OpCodes.Ldarg_0); // this
             ctorIL.Emit(OpCodes.Ldarg_1); // 'initializationToken'
-            ctorIL.Emit(OpCodes.Newobj, proxyType.GetConstructor(new[] { typeof(ConfigurationInitializationToken) }));
+            ctorIL.Emit(OpCodes.Newobj, proxyType.GetConstructorSafe(typeof(ConfigurationInitializationToken)));
             ctorIL.Emit(OpCodes.Stfld, underlyingInstanceField);
 
             void GetterBody(ILGenerator getterIL)

src/Dibix.Testing/Http/HttpOfflineServiceFactory.cs

@@ -59,14 +59,11 @@ private static MethodBuilder BuildDelegatedMethod(TypeBuilder typeBuilder, Metho
             foreach (ParameterInfo parameter in targetMethod.GetParameters())
                 parameters.Add(Expression.Parameter(parameter.ParameterType, parameter.Name));
 
-            ConstructorInfo httpClientFactoryConstructor = typeof(DefaultHttpClientFactory).GetConstructor(new[] { typeof(HttpClientConfiguration[]) });
-            if (httpClientFactoryConstructor == null)
-                throw new InvalidOperationException($"Could not find constructor {typeof(DefaultHttpClientFactory)}({typeof(HttpClientConfiguration)}[])");
-
+            ConstructorInfo httpClientFactoryConstructor = typeof(DefaultHttpClientFactory).GetConstructorSafe(typeof(HttpClientConfiguration[]));
             Expression offlineClientConfiguration = Expression.New(typeof(OfflineHttpClientConfiguration));
             Expression httpClientFactory = Expression.New(httpClientFactoryConstructor, Expression.NewArrayInit(typeof(HttpClientConfiguration), offlineClientConfiguration));
             Expression httpAuthorizationProvider = Expression.New(typeof(EmptyHttpAuthorizationProvider));
-            ConstructorInfo constructor = targetMethod.DeclaringType.GetConstructor(ConstructorSignature);
+            ConstructorInfo constructor = targetMethod.DeclaringType.GetConstructorSafe(ConstructorSignature);
             Expression instance = Expression.New(constructor, httpClientFactory, httpAuthorizationProvider);
             Expression call = Expression.Call(instance, targetMethod, parameters);
             LambdaExpression lambda = Expression.Lambda(call, parameters);
@@ -96,13 +93,10 @@ private static void BuildDelegatedMethodImplementation(TypeBuilder typeBuilder,
 
         private static void BuildEmptyMethodImplementation(TypeBuilder typeBuilder, MethodInfo methodToImplement)
         {
-            BuildMethodImplementation(typeBuilder, methodToImplement, (parameterTypes, ilGenerator) =>
+            BuildMethodImplementation(typeBuilder, methodToImplement, (_, ilGenerator) =>
             {
                 Type exceptionType = typeof(NotImplementedException);
-                ConstructorInfo exceptionCtor = exceptionType.GetConstructor(Type.EmptyTypes);
-                if (exceptionCtor == null)
-                    throw new InvalidOperationException($"Could not find a parameterless constructor on type: '{exceptionType}'");
-
+                ConstructorInfo exceptionCtor = exceptionType.GetConstructorSafe(Type.EmptyTypes);
                 ilGenerator.Emit(OpCodes.Newobj, exceptionCtor);
                 ilGenerator.Emit(OpCodes.Throw);
             });

src/Dibix.Testing/Http/HttpServiceFactory.cs

@@ -24,7 +24,7 @@ private static TService CreateServiceInstance<TService>(params KeyValuePair<Type
             Type contractType = typeof(TService);
             Type implementationType = ResolveImplementationType(contractType);
             Type[] constructorSignature = normalizedArgs.Select(x => x.Key).ToArray();
-            ConstructorInfo constructor = implementationType.GetConstructor(constructorSignature);
+            ConstructorInfo constructor = implementationType.GetConstructorSafe(constructorSignature);
             object[] ctorArgs = normalizedArgs.Select(x => x.Value).ToArray();
             TService service = (TService)constructor.Invoke(ctorArgs);
             return service;

tests/Dibix.Http.Server.Tests/SqlExceptionFactory.cs

@@ -30,17 +30,18 @@ private static CreateSqlException CompileFactory()
             ParameterExpression lineNumberParameter = Expression.Parameter(typeof(int), "lineNumber");
             Expression exceptionParameter = Expression.Constant(null, typeof(Exception));
 
-            ConstructorInfo sqlErrorConstructor = sqlErrorType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new[]
-            {
-                infoNumberParameter.Type
+            ConstructorInfo sqlErrorConstructor = sqlErrorType.GetConstructorSafe
+            (
+                BindingFlags.NonPublic | BindingFlags.Instance
+              , infoNumberParameter.Type
               , errorStateParameter.Type
               , errorClassParameter.Type
               , serverParameter.Type
               , errorMessageParameter.Type
               , procedureParameter.Type
               , lineNumberParameter.Type
               , exceptionParameter.Type
-            }, null);
+            );
 
             if (sqlErrorConstructor == null)
                 throw new InvalidOperationException($"Could not find ctor on type '{sqlErrorType}'");