private static void FindApplicableConstructor(
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type instanceType,
Type[] argumentTypes,
out ConstructorInfo matchingConstructor,
out int?[] matchingParameterMap)
{
ConstructorInfo?constructorInfo = null;
int?[]? parameterMap = null;
if (!TryFindPreferredConstructor(instanceType, argumentTypes, ref constructorInfo, ref parameterMap) &&
!TryFindMatchingConstructor(instanceType, argumentTypes, ref constructorInfo, ref parameterMap))
{
string?message = $"A suitable constructor for type '{instanceType}' could not be located. Ensure the type is concrete and all parameters of a public constructor are either registered as services or passed as arguments. Also ensure no extraneous arguments are provided.";
throw new InvalidOperationException(message);
}
matchingConstructor = constructorInfo;
matchingParameterMap = parameterMap;
}
private static ConstructorInfo CreateHandlerInternal <THandler, TRule>()
where THandler : class
{
ConstructorInfo?constructor = typeof(THandler).GetTypeInfo()
.DeclaredConstructors.SingleOrDefault(c =>
{
ParameterInfo[] parameters = c.GetParameters();
return(parameters.Length == 1 &&
parameters[0].ParameterType ==
typeof(TRule));
});
if (constructor == null)
{
throw new ArgumentException(StitchingResources
.SchemaMergerExtensions_NoValidConstructor);
}
return(constructor);
}
private JsonConverter GetConverterFromAttribute(JsonConverterAttribute converterAttribute, Type typeToConvert, Type classTypeAttributeIsOn, PropertyInfo?propertyInfo)
{
JsonConverter?converter;
Type?type = converterAttribute.ConverterType;
if (type == null)
{
// Allow the attribute to create the converter.
converter = converterAttribute.CreateConverter(typeToConvert);
if (converter == null)
{
ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeNotCompatible(classTypeAttributeIsOn, propertyInfo, typeToConvert);
}
}
else
{
ConstructorInfo?ctor = type.GetConstructor(Type.EmptyTypes);
if (!typeof(JsonConverter).IsAssignableFrom(type) || ctor == null || !ctor.IsPublic)
{
ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeInvalid(classTypeAttributeIsOn, propertyInfo);
}
converter = (JsonConverter)Activator.CreateInstance(type) !;
}
Debug.Assert(converter != null);
if (!converter.CanConvert(typeToConvert))
{
Type?underlyingType = Nullable.GetUnderlyingType(typeToConvert);
if (underlyingType != null && converter.CanConvert(underlyingType))
{
// Allow nullable handling to forward to the underlying type's converter.
return(NullableConverterFactory.CreateValueConverter(underlyingType, converter));
}
ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeNotCompatible(classTypeAttributeIsOn, propertyInfo, typeToConvert);
}
return(converter);
}
public DeputyBase GetOrCreateNativeReference(ByRefValue byRefValue)
{
if (!_references.ContainsKey(byRefValue.Value))
{
ConstructorInfo constructorInfo = GetByRefConstructor();
_references[byRefValue.Value] = (DeputyBase)constructorInfo.Invoke(new object[] { byRefValue });
}
var existing = _references[byRefValue.Value];
existing.Reference.Merge(byRefValue);
return(existing);
ConstructorInfo GetByRefConstructor()
{
Type type = _types.GetClassType(byRefValue.FullyQualifiedName);
// If type is an interface or abstract class
if (type == null || type.IsAbstract)
{
type = _types.GetProxyType(byRefValue.FullyQualifiedName);
}
if (type == null)
{
throw new ArgumentException(
$"Could not find type with fully qualified name '{byRefValue.FullyQualifiedName}'",
nameof(byRefValue)
);
}
BindingFlags constructorFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
ConstructorInfo?constructorInfo = type.GetConstructor(constructorFlags, null, new[] { typeof(ByRefValue) }, null);
if (constructorInfo == null)
{
throw new JsiiException($"Could not find constructor to initialize {type.FullName} with a {typeof(ByRefValue).FullName}");
}
return(constructorInfo);
}
}
/// <summary>
/// Caches the metadata.
/// </summary>
/// <param name="metadata">The metadata.</param>
protected override void CacheMetadata(CodeActivityMetadata metadata)
{
var foundError = false;
var oldConstructorInfo = this.constructorInfo;
// Loop through each argument, validate it, and if validation
// passed expose it to the metadata
var types = new Type?[this.Arguments.Count];
for (var i = 0; i < this.Arguments.Count; i++)
{
var argument = this.Arguments[i];
if (argument == null || argument.Expression == null)
{
metadata.AddValidationError(SR.ArgumentRequired("Arguments", typeof(New <TResult>)));
foundError = true;
}
else
{
var runtimeArgument = new RuntimeArgument("Argument" + i, this.arguments?[i].ArgumentType, this.arguments?[i].Direction, true);
metadata.Bind(this.arguments?[i], runtimeArgument);
metadata.AddArgument(runtimeArgument);
types[i] = this.Arguments[i].Direction == ArgumentDirection.In ? this.Arguments[i].ArgumentType : this.Arguments[i].ArgumentType?.MakeByRefType();
}
}
// If we didn't find any errors in the arguments then
// we can look for an appropriate constructor.
if (!foundError)
{
this.constructorInfo = typeof(TResult).GetConstructor(types);
if (this.constructorInfo == null && (!typeof(TResult).IsValueType || types.Length > 0))
{
metadata.AddValidationError(SR.ConstructorInfoNotFound(typeof(TResult).Name));
}
else if ((this.constructorInfo != oldConstructorInfo) || (this.function == null))
{
this.function = MethodCallExpressionHelper.GetFunc(metadata, this.constructorInfo, funcCache, locker);
}
}
}
/// <summary>
/// Converts the given object to another type. The most common types to convert
/// are to and from a string object. The default implementation will make a call
/// to ToString on the object if the object is valid and if the destination
/// type is string. If this cannot convert to the desitnation type, this will
/// throw a NotSupportedException.
/// </summary>
public override object?ConvertTo(ITypeDescriptorContext?context, CultureInfo?culture, object?value, Type destinationType)
{
ArgumentNullException.ThrowIfNull(destinationType);
if (value is Margins margins)
{
if (destinationType == typeof(string))
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string sep = culture.TextInfo.ListSeparator + " ";
TypeConverter intConverter = GetIntConverter();
string?[] args = new string[4];
int nArg = 0;
// Note: ConvertToString will raise exception if value cannot be converted.
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Left);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Right);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Top);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Bottom);
return(string.Join(sep, args));
}
if (destinationType == typeof(InstanceDescriptor))
{
ConstructorInfo?ctor = typeof(Margins).GetConstructor(new Type[] {
typeof(int), typeof(int), typeof(int), typeof(int)
});
if (ctor != null)
{
return(new InstanceDescriptor(ctor, new object[] {
margins.Left, margins.Right, margins.Top, margins.Bottom
}));
}
}
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public static ConstructorInfo?ResolveEnumerableCollectionConstructor(
Type collectionType,
Type collectionItemType,
Type constructorArgumentType
)
{
Type genericEnumerable = typeof(IEnumerable <>).MakeGenericType(collectionItemType);
ConstructorInfo?match = null;
foreach (
ConstructorInfo constructor in collectionType.GetConstructors(
BindingFlags.Public | BindingFlags.Instance
)
)
{
IList <ParameterInfo> parameters = constructor.GetParameters();
if (parameters.Count == 1)
{
Type parameterType = parameters[0].ParameterType;
if (genericEnumerable == parameterType)
{
// exact match
match = constructor;
break;
}
// in case we can't find an exact match, use first inexact
if (match == null)
{
if (parameterType.IsAssignableFrom(constructorArgumentType))
{
match = constructor;
}
}
}
}
return(match);
}
/// <summary>
/// Creates a <see cref="NewExpression"/> that represents calling the parameterless constructor of the specified type.
/// </summary>
/// <param name="type">A <see cref="Type"/> that has a constructor that takes no arguments.</param>
/// <returns>A <see cref="NewExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.New"/> and the <see cref="NewExpression.Constructor"/> property set to the <see cref="ConstructorInfo"/> that represents the parameterless constructor of the specified type.</returns>
public static NewExpression New(
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type type)
{
ContractUtils.RequiresNotNull(type, nameof(type));
if (type == typeof(void))
{
throw Error.ArgumentCannotBeOfTypeVoid(nameof(type));
}
TypeUtils.ValidateType(type, nameof(type));
if (!type.IsValueType)
{
ConstructorInfo?ci = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).SingleOrDefault(c => c.GetParametersCached().Length == 0);
if (ci == null)
{
throw Error.TypeMissingDefaultConstructor(type, nameof(type));
}
return(New(ci));
}
return(new NewValueTypeExpression(type, EmptyReadOnlyCollection <Expression> .Instance, null));
}
public void CanCreateReturnsFalseWhenNoPublicConstructorFoundAndStaticMethodContainsTypeParameter()
{
var type = typeof(NotFactoryItem);
ConstructorInfo?constructorInfo = null;
var configuration = Substitute.For <IBuildConfiguration>();
var typeResolver = Substitute.For <ITypeResolver>();
var constructorResolver = Substitute.For <IConstructorResolver>();
var buildChain = Substitute.For <IBuildChain>();
configuration.TypeResolver.Returns(typeResolver);
configuration.ConstructorResolver.Returns(constructorResolver);
typeResolver.GetBuildType(configuration, type).Returns(type);
constructorResolver.Resolve(type, Arg.Any <object?[]?>()).Returns(constructorInfo);
var sut = new FactoryTypeCreator(CacheLevel.PerInstance);
var actual = sut.CanCreate(configuration, buildChain, type);
actual.Should().BeFalse();
}
public void SetConstructor(ConstructorInfo? info, int parmCount)
{
BuilderFunc = null;
if (info == null) return;
var single = parmCount == 0;
if (parmCount == -1)
single = info.GetParameters().Length switch
{
0 => true,
1 => false,
_ => single
};
if (parmCount > 1) return;
if (single) BuilderFunc = o => info.Invoke(null);
else BuilderFunc = o => info.Invoke(new[] {o});
}
/// <summary>
/// Emits an array construction code.
/// The code assumes that bounds for all dimensions
/// are already emitted.
/// </summary>
internal static void EmitArray(this ILGenerator il, Type arrayType)
{
Debug.Assert(arrayType != null);
Debug.Assert(arrayType.IsArray);
if (arrayType.IsSZArray)
{
il.Emit(OpCodes.Newarr, arrayType.GetElementType() !);
}
else
{
Type[] types = new Type[arrayType.GetArrayRank()];
for (int i = 0; i < types.Length; i++)
{
types[i] = typeof(int);
}
ConstructorInfo?ci = arrayType.GetConstructor(types);
Debug.Assert(ci != null);
il.EmitNew(ci);
}
}
public void CanCreateReturnsFalseWhenNoPublicConstructorFound()
{
var type = typeof(FactoryItem);
ConstructorInfo?constructorInfo = null;
var configuration = Substitute.For <IBuildConfiguration>();
var typeResolver = Substitute.For <ITypeResolver>();
var constructorResolver = Substitute.For <IConstructorResolver>();
var buildChain = Substitute.For <IBuildChain>();
configuration.TypeResolver.Returns(typeResolver);
configuration.ConstructorResolver.Returns(constructorResolver);
typeResolver.GetBuildType(configuration, type).Returns(type);
constructorResolver.Resolve(type, Arg.Any <object?[]?>()).Returns(constructorInfo);
var sut = new DefaultTypeCreator();
var actual = sut.CanCreate(configuration, buildChain, type);
actual.Should().BeFalse();
}
public void CanCreateReturnsTrueWhenNoPublicConstructorAndStaticFactoryMethodExistsWithParameters()
{
var type = typeof(FactoryWithValue);
ConstructorInfo?constructorInfo = null;
var configuration = Substitute.For <IBuildConfiguration>();
var typeResolver = Substitute.For <ITypeResolver>();
var constructorResolver = Substitute.For <IConstructorResolver>();
var buildChain = Substitute.For <IBuildChain>();
configuration.TypeResolver.Returns(typeResolver);
configuration.ConstructorResolver.Returns(constructorResolver);
typeResolver.GetBuildType(configuration, type).Returns(type);
constructorResolver.Resolve(type, Arg.Any <object?[]?>()).Returns(constructorInfo);
var sut = new FactoryTypeCreator(CacheLevel.PerInstance);
var actual = sut.CanCreate(configuration, buildChain, type);
actual.Should().BeTrue();
}
internal static T Deserialize <T>(SerializationInfo info, TraceSource?traceSource)
where T : Exception
{
string?runtimeTypeName = info.GetString("ClassName");
if (runtimeTypeName is null)
{
throw new NotSupportedException("ClassName was not found in the serialized data.");
}
Type?runtimeType = Type.GetType(runtimeTypeName);
if (runtimeType is null)
{
if (traceSource?.Switch.ShouldTrace(TraceEventType.Warning) ?? false)
{
traceSource.TraceEvent(TraceEventType.Warning, (int)JsonRpc.TraceEvents.ExceptionTypeNotFound, "{0} type could not be loaded. Falling back to System.Exception.", runtimeTypeName);
}
// fallback to deserializing the base Exception type.
runtimeType = typeof(Exception);
}
// Sanity/security check: ensure the runtime type derives from the expected type.
if (!typeof(T).IsAssignableFrom(runtimeType))
{
throw new NotSupportedException($"{runtimeTypeName} does not derive from {typeof(T).FullName}.");
}
EnsureSerializableAttribute(runtimeType);
ConstructorInfo?ctor = FindDeserializingConstructor(runtimeType);
if (ctor is null)
{
throw new NotSupportedException($"{runtimeType.FullName} does not declare a deserializing constructor with signature ({string.Join(", ", DeserializingConstructorParameterTypes.Select(t => t.FullName))}).");
}
return((T)ctor.Invoke(new object?[] { info, Context }));
}
public override object?ConvertTo(ITypeDescriptorContext?context, CultureInfo?culture, object?value, Type destinationType)
{
ArgumentNullException.ThrowIfNull(destinationType);
if (value is Rectangle rect)
{
if (destinationType == typeof(string))
{
culture ??= CultureInfo.CurrentCulture;
string sep = culture.TextInfo.ListSeparator + " ";
TypeConverter intConverter = TypeDescriptor.GetConverterTrimUnsafe(typeof(int));
// Note: ConvertToString will raise exception if value cannot be converted.
var args = new string?[]
{
intConverter.ConvertToString(context, culture, rect.X),
intConverter.ConvertToString(context, culture, rect.Y),
intConverter.ConvertToString(context, culture, rect.Width),
intConverter.ConvertToString(context, culture, rect.Height)
};
return(string.Join(sep, args));
}
else if (destinationType == typeof(InstanceDescriptor))
{
ConstructorInfo?ctor = typeof(Rectangle).GetConstructor(new Type[] {
typeof(int), typeof(int), typeof(int), typeof(int)
});
if (ctor != null)
{
return(new InstanceDescriptor(ctor, new object[] {
rect.X, rect.Y, rect.Width, rect.Height
}));
}
}
}
return(base.ConvertTo(context, culture, value, destinationType));
}
private static ExitCode ExecuteTest(Type testClass, MethodInfo testMethod)
{
try
{
ConstructorInfo?ctorWithLogger = testClass.GetConstructors().FirstOrDefault(
ctor => ctor.GetParameters().Length == 1 && ctor.GetParameters()[0].ParameterType.IsAssignableFrom(typeof(TestOutputHelper)));
ConstructorInfo?ctorDefault = testClass.GetConstructor(Type.EmptyTypes);
object? testClassInstance =
ctorWithLogger?.Invoke(new object[] { new TestOutputHelper() }) ??
ctorDefault?.Invoke(Type.EmptyTypes);
if (testClassInstance is null)
{
return(ExitCode.TestNotSupported);
}
object result = testMethod.Invoke(testClassInstance, Type.EmptyTypes);
if (result is Task resultTask)
{
resultTask.GetAwaiter().GetResult();
}
if (testClassInstance is IDisposable disposableTestClass)
{
disposableTestClass.Dispose();
}
return(ExitCode.TestPassed);
}
catch (Exception ex)
{
if (ex.GetType().Name == "SkipException")
{
return(ExitCode.TestSkipped);
}
Console.Error.WriteLine("Test failed.");
Console.Error.WriteLine(ex);
return(ExitCode.TestFailed);
}
}
internal static bool TryGet_Constructor_GenericType([NotNullWhen(true)] out ConstructorInfo?constructorInfo,
Type openGenericType, Type[] typeTypeArguments, Type[] constructorArguments)
{
var key = Tuple.Create(openGenericType, typeTypeArguments, constructorArguments);
if (Constructors.TryGetValue(key, out constructorInfo))
{
return(true);
}
if (NoConstructors.Contains(key) == true)
{
return(false);
}
var typeToCreate = openGenericType;
if (typeTypeArguments.Length != 0)
{
typeToCreate = typeToCreate.MakeGenericType(typeTypeArguments);
}
constructorInfo = typeToCreate.GetConstructor(constructorArguments);
return(constructorInfo != default);
}
/// <summary>
/// Loads a native procedure from a DLL.
/// </summary>
/// <param name="dllPath">The path to the DLL.</param>
/// <param name="procName">The name of the procedure.</param>
/// <param name="returnType">The return type of the procedure.</param>
/// <param name="parameterTypes">The parameter types of the procedure.</param>
/// <param name="callConv">The <see cref="CallConv"/> of the native procedure.</param>
/// <returns>The <see cref="MethodInfo"/> of the procedure.</returns>
public static MethodInfo LoadNativeProcedure(
string dllPath,
string procName,
Type returnType,
Type[] parameterTypes,
CallConv callConv)
{
var asmName = new AssemblyName("TempAssembly");
var asmBuilder = AssemblyBuilder.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run);
var modBuilder = asmBuilder.DefineDynamicModule("TempModule");
var typeBuilder = modBuilder.DefineType("TempType", TypeAttributes.Class | TypeAttributes.Public);
// Optional: Use if you need to set properties on DllImportAttribute
ConstructorInfo?dllImportCtor = typeof(DllImportAttribute).GetConstructor(new Type[] { typeof(string) });
Debug.Assert(dllImportCtor != null);
var dllImportBuilder = new CustomAttributeBuilder(dllImportCtor, new object[] { dllPath });
var pinvokeBuilder = typeBuilder.DefinePInvokeMethod(
name: procName,
dllName: dllPath,
entryName: procName,
attributes: MethodAttributes.Static | MethodAttributes.Public,
callingConvention: CallingConventions.Standard,
returnType: returnType,
parameterTypes: parameterTypes,
nativeCallConv: ToCallingConvention(callConv),
nativeCharSet: CharSet.Unicode);
pinvokeBuilder.SetCustomAttribute(dllImportBuilder);
Type?tempType = typeBuilder.CreateType();
Debug.Assert(tempType != null);
MethodInfo?result = tempType.GetMethod(procName, BindingFlags.Static | BindingFlags.Public);
Debug.Assert(result != null);
return(result);
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
string data = bindingContext.HttpContext.Request.Form[bindingContext.FieldName];
if (string.IsNullOrEmpty(data))
{
return(Task.CompletedTask);
}
Type type = bindingContext.ModelType;
// 判断是否包含 string 构造，如果存在则调用构造转换
ConstructorInfo?constructor = type.GetConstructor(new[] { typeof(string) });
if (constructor != null)
{
bindingContext.Result = ModelBindingResult.Success(constructor.Invoke(new[] { data }));
}
else
{
bindingContext.Result = ModelBindingResult.Success(JsonConvert.DeserializeObject(data, type));
}
return(Task.CompletedTask);
}
private static bool TryFindConstructorWithSingleParameterOfType(
this Type type,
Type parameterType,
[NotNullWhen(true)] out ConstructorInfo?ctor)
{
var(x, y) = type.GetConstructors()
.Select(c => (ctor: c, parameters: c.GetParameters()))
.SingleOrDefault(tuple => tuple.ctor.IsPublic &&
tuple.parameters.Length == 1 &&
tuple.parameters[0].ParameterType == parameterType);
if (x != null)
{
ctor = x;
return(true);
}
else
{
ctor = null;
return(false);
}
}
public override object?ConvertTo(ITypeDescriptorContext?context, CultureInfo?culture, object?value, Type destinationType)
{
if (destinationType == null)
{
throw new ArgumentNullException(nameof(destinationType));
}
if (value is Point pt)
{
if (destinationType == typeof(string))
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string sep = culture.TextInfo.ListSeparator + " ";
TypeConverter intConverter = TypeDescriptor.GetConverterTrimUnsafe(typeof(int));
// Note: ConvertFromString will raise exception if value cannot be converted.
var args = new string?[]
{
intConverter.ConvertToString(context, culture, pt.X),
intConverter.ConvertToString(context, culture, pt.Y)
};
return(string.Join(sep, args));
}
else if (destinationType == typeof(InstanceDescriptor))
{
ConstructorInfo?ctor = typeof(Point).GetConstructor(new Type[] { typeof(int), typeof(int) });
if (ctor != null)
{
return(new InstanceDescriptor(ctor, new object[] { pt.X, pt.Y }));
}
}
}
return(base.ConvertTo(context, culture, value, destinationType));
}
private static ConstructorInfo GetGreediestConstructor(Type type)
{
ConstructorInfo?current = null;
var count = -1;
foreach (var constructor in type.GetTypeInfo().GetConstructors())
{
var parameters = constructor.GetParameters();
if (parameters.Length > count)
{
count = parameters.Length;
current = constructor;
}
}
if (current == null)
{
throw new InvalidOperationException($"Could not find a constructor for '{type.FullName}'.");
}
return(current);
}
/// <summary>
/// Retrieves the constructor of the given type based on the given delegate type
/// </summary>
/// <param name="type"></param>
/// <param name="delegateType"></param>
/// <returns></returns>
public static Delegate GetConstructorDelegate(this Type type, Type delegateType)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (delegateType == null)
{
throw new ArgumentNullException(nameof(delegateType));
}
Type[] genericArguments = delegateType.GetGenericArguments();
Type[] argTypes = genericArguments.Length > 1 ? genericArguments.Take(genericArguments.Length - 1).ToArray() : Type.EmptyTypes;
ConstructorInfo?constructor = type.GetConstructor(argTypes);
if (constructor == null)
{
if (argTypes.Length == 0)
{
throw new InvalidOperationException($"Type '{type.Name}' doesn't have a parameterless constructor.");
}
throw new InvalidOperationException($"Type '{type.Name}' doesn't have the requested constructor.");
}
var dynamicMethod = new DynamicMethod("DM$OBJ_FACTORY_" + type.Name, type, argTypes, type);
ILGenerator ilGen = dynamicMethod.GetILGenerator();
for (int i = 0; i < argTypes.Length; i++)
{
ilGen.Emit(OpCodes.Ldarg, i);
}
ilGen.Emit(OpCodes.Newobj, constructor);
ilGen.Emit(OpCodes.Ret);
return(dynamicMethod.CreateDelegate(delegateType));
}
public ObjectBuilder(Type? target)
{
if (target == null) return;
var count = -1;
ConstructorInfo? info = null;
foreach (var con in target.GetConstructors())
{
count = con.GetParameters().Count();
info = count switch
{
0 => con,
1 => con,
_ => info
};
}
if (info == null) return;
SetConstructor(info, count);
}
private static ConstructorInfo?GetCompatibleConstructor(
Type type,
IReadOnlyDictionary <string, PropertyInfo> properties)
{
ConstructorInfo[] constructors = type.GetConstructors(
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
ConstructorInfo?defaultConstructor = constructors.FirstOrDefault(
t => t.GetParameters().Length == 0);
if (properties.Values.All(t => t.CanWrite))
{
if (defaultConstructor is not null)
{
return(defaultConstructor);
}
else if (constructors.Length == 0)
{
return(null);
}
}
var required = new HashSet <string>();
foreach (ConstructorInfo constructor in
constructors.OrderByDescending(t => t.GetParameters().Length))
{
if (IsCompatibleConstructor(constructor, properties, required))
{
return(constructor);
}
}
throw new InvalidOperationException(
$"No compatible constructor found for input type type `{type.FullName}`.\r\n" +
"Either you have to provide a public constructor with settable properties or " +
"a public constructor that allows to pass in values for read-only properties." +
$"There was no way to set the following properties: {string.Join(", ", required)}.");
}
protected sealed override ConstructorInfo ComputeConstructor()
{
EntityHandle ctorHandle = CustomAttribute.Constructor;
switch (ctorHandle.Kind)
{
case HandleKind.MethodDefinition:
{
MethodDefinitionHandle mh = (MethodDefinitionHandle)ctorHandle;
EcmaDefinitionType declaringType = mh.GetMethodDefinition(Reader).GetDeclaringType().ResolveTypeDef(_module);
return(new RoDefinitionConstructor <EcmaMethodDecoder>(declaringType, new EcmaMethodDecoder(mh, _module)));
}
case HandleKind.MemberReference:
{
TypeContext typeContext = default;
MemberReference mr = ((MemberReferenceHandle)ctorHandle).GetMemberReference(Reader);
MethodSignature <RoType> sig = mr.DecodeMethodSignature(_module, typeContext);
Type[] parameterTypes = sig.ParameterTypes.ToArray();
Type declaringType = mr.Parent.ResolveTypeDefRefOrSpec(_module, typeContext);
const BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.ExactBinding;
ConstructorInfo? ci = declaringType.GetConstructor(bf, null, parameterTypes, null);
if (ci == null)
{
throw new MissingMethodException(SR.Format(SR.MissingCustomAttributeConstructor, declaringType));
}
return(ci);
}
// Constructors can not be generic methods so this should never occur. (Not to be confused with constructors on generic types and we do now
// support generic attributes. But that comes in as a MemberReference, not a MethodSpec.)
case HandleKind.MethodSpecification:
throw new BadImageFormatException();
default:
throw new BadImageFormatException();
}
}
private IEnumerable <ImportDefinition> GetImportDefinitions()
{
List <ImportDefinition> imports = new List <ImportDefinition>();
foreach (MemberInfo member in GetImportMembers(_type))
{
ReflectionMemberImportDefinition importDefinition = AttributedModelDiscovery.CreateMemberImportDefinition(member, this);
imports.Add(importDefinition);
}
ConstructorInfo?constructor = GetConstructor();
if (constructor != null)
{
foreach (ParameterInfo parameter in constructor.GetParameters())
{
ReflectionParameterImportDefinition importDefinition = AttributedModelDiscovery.CreateParameterImportDefinition(parameter, this);
imports.Add(importDefinition);
}
}
return(imports);
}
TestableTestClassRunner(
_ITestClass testClass,
_IReflectionTypeInfo @class,
IEnumerable <_ITestCase> testCases,
List <_MessageSinkMessage> diagnosticMessages,
IMessageBus messageBus,
ITestCaseOrderer testCaseOrderer,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource,
ConstructorInfo?constructor,
object[] availableArguments,
RunSummary result,
bool cancelInRunTestMethodAsync)
: base(testClass, @class, testCases, SpyMessageSink.Create(messages: diagnosticMessages), messageBus, testCaseOrderer, aggregator, cancellationTokenSource)
{
DiagnosticMessages = diagnosticMessages;
TokenSource = cancellationTokenSource;
this.constructor = constructor;
this.availableArguments = availableArguments;
this.result = result;
this.cancelInRunTestMethodAsync = cancelInRunTestMethodAsync;
}
public ConstructorInfo?GetConstructor()
{
if (_constructor == null)
{
ConstructorInfo[]? constructors = null;
constructors = GetImports()
.OfType <ReflectionParameterImportDefinition>()
.Select(parameterImport => parameterImport.ImportingLazyParameter.Value.Member)
.OfType <ConstructorInfo>()
.Distinct()
.ToArray();
if (constructors.Length == 1)
{
_constructor = constructors[0];
}
else if (constructors.Length == 0)
{
_constructor = GetPartType().GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
}
}
return(_constructor);
}
public override MethodBase?ProjectMethodBase(MethodBase?value)
{
if (value == null)
{
return(null);
}
MethodInfo?method = value as MethodInfo;
if (method != null)
{
return(ProjectMethod(method));
}
ConstructorInfo?constructor = value as ConstructorInfo;
if (constructor != null)
{
return(ProjectConstructor(constructor));
}
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_InvalidMethodType, value.GetType()));
}