/// <inheritdoc /> public object CreateProxy (Type baseType, Type[] implementedInterfaces, object[] constructorArguments) { if (baseType.IsInterface) { // TODO: should Moq.Core do this work? It's the same for // Castle and LinFu and presumably other (future?) libraries var fixedInterfaces = new Type[implementedInterfaces.Length + 1]; fixedInterfaces[0] = baseType; implementedInterfaces.CopyTo (fixedInterfaces, 1); implementedInterfaces = fixedInterfaces; baseType = typeof (object); } if (!implementedInterfaces.Contains(typeof(IProxy))) { var fixedInterfaces = new Type[implementedInterfaces.Length + 1]; fixedInterfaces[0] = typeof(IProxy); implementedInterfaces.CopyTo (fixedInterfaces, 1); implementedInterfaces = fixedInterfaces; } // TODO: the proxy factory should automatically detect requests to proxy // delegates and generate an interface on the fly for them, without Moq // having to know about it at all. return generator.CreateClassProxy (baseType, implementedInterfaces, proxyOptions, constructorArguments, new Interceptor ()); }
public object CreateProxy (Type baseType, Type[] implementedInterfaces, object[] constructorArguments) { if (baseType.IsInterface) { // TODO: should Moq.Core do this work? It's the same for // Castle and LinFu and presumably other (future?) libraries var fixedInterfaces = new Type[implementedInterfaces.Length + 1]; fixedInterfaces[0] = baseType; implementedInterfaces.CopyTo (fixedInterfaces, 1); implementedInterfaces = fixedInterfaces; baseType = typeof (object); } // TODO: this code is duplicated exactly from the Castle proxy factory. if (!implementedInterfaces.Contains (typeof (IProxy))) { var fixedInterfaces = new Type[implementedInterfaces.Length + 1]; fixedInterfaces[0] = typeof (IProxy); implementedInterfaces.CopyTo (fixedInterfaces, 1); implementedInterfaces = fixedInterfaces; } // TODO: the proxy factory should automatically detect requests to proxy // delegates and generate an interface on the fly for them, without Moq // having to know about it at all. // NOTE: LinFu doesn't support passing ctor args??!?!?! if (constructorArguments.Length != 0) throw new NotSupportedException (); return factory.CreateProxy(baseType, new Interceptor (), implementedInterfaces); }
/// <summary> /// Creates the func delegate, that handles call with N arguments and call Action<object[]> with this arguments /// </summary> /// <returns>The converter to arguments array action.</returns> /// <param name="action">Action.</param> /// <param name="argTypes">Argument types.</param> public static Delegate CreateConverterToArgsArrayFunc(Func<object[], object> func,Type returnType, Type[] argTypes) { Type t = null; switch (argTypes.Length){ case 0: t = typeof(FuncCallConverterSubFactory<>); break; case 1: t = typeof(FuncCallConverterSubFactory<,>); break; case 2: t = typeof(FuncCallConverterSubFactory<,,>); break; case 3: t = typeof(FuncCallConverterSubFactory<,,,>); break; case 4: t = typeof(FuncCallConverterSubFactory<,,,,>); break; case 5: t = typeof(FuncCallConverterSubFactory<,,,,,>); break; case 6: t = typeof(FuncCallConverterSubFactory<,,,,,,>); break; case 7: t = typeof(FuncCallConverterSubFactory<,,,,,,,>); break; case 8: t = typeof(FuncCallConverterSubFactory<,,,,,,,,>); break; case 9: t = typeof(FuncCallConverterSubFactory<,,,,,,,,,>); break; case 10: t = typeof(FuncCallConverterSubFactory<,,,,,,,,,,>); break; case 11: t = typeof(FuncCallConverterSubFactory<,,,,,,,,,,,>); break; case 12: t = typeof(FuncCallConverterSubFactory<,,,,,,,,,,,,>); break; default: throw new ArgumentException("Arguments number should be less or equal 12"); // case 13: t = typeof(FuncCallConverterSubFactory<,,,,,,,,,,,,,>); break; // case 14: t = typeof(FuncCallConverterSubFactory<,,,,,,,,,,,,,,>); break; // case 15: t = typeof(FuncCallConverterSubFactory<,,,,,,,,,,,,,,,>); break; // case 16: t = typeof(FuncCallConverterSubFactory<,,,,,,,,,,,,,,,,>); break; } var FuncTypes = new Type[argTypes.Length + 1]; argTypes.CopyTo (FuncTypes, 0); FuncTypes [argTypes.Length] = returnType; var gt = t.MakeGenericType (FuncTypes); var gen = Activator.CreateInstance (gt) as IFuncCallConverterSubFactory; return gen.GetFuncConverter (func); }
internal MethodOnTypeBuilderInst (MethodOnTypeBuilderInst gmd, Type[] typeArguments) { this.instantiation = gmd.instantiation; this.mb = gmd.mb; this.method_arguments = new Type [typeArguments.Length]; typeArguments.CopyTo (this.method_arguments, 0); this.generic_method_definition = gmd; }
internal MethodOnTypeBuilderInst (MethodInfo method, Type[] typeArguments) { this.instantiation = method.DeclaringType; this.base_method = ExtractBaseMethod (method); this.method_arguments = new Type [typeArguments.Length]; typeArguments.CopyTo (this.method_arguments, 0); if (base_method != method) this.generic_method_definition = method; }
internal static Type GetGeneratorFactoryTarget(Type[] parameterTypes) { Type[] typeArgs = new Type[parameterTypes.Length + 2]; typeArgs[0] = typeof(DebugFrame); parameterTypes.CopyTo(typeArgs, 1); typeArgs[parameterTypes.Length + 1] = typeof(IEnumerator); if (typeArgs.Length <= 16) { return Ast.GetFuncType(typeArgs); } else { return DelegateHelpers.MakeNewCustomDelegateType(typeArgs); } }
private Type[] BuildAdditionalTypeArrayForProxyType(Type[] additionalTypes) { var allAdditionalTypes = new Type[additionalTypes.Length + 1]; allAdditionalTypes[0] = typeof(IMockObject); if (additionalTypes.Length > 0) { additionalTypes.CopyTo(allAdditionalTypes, 1); } return allAdditionalTypes; }
internal static Type GetGeneratorFactoryTarget(Type[] parameterTypes) { Type[] typeArgs = new Type[parameterTypes.Length + 2]; typeArgs[0] = typeof(DebugFrame); parameterTypes.CopyTo(typeArgs, 1); typeArgs[parameterTypes.Length + 1] = typeof(IEnumerator); if (typeArgs.Length <= 16) { return Ast.GetFuncType(typeArgs); } else { #if FEATURE_REFEMIT return DelegateHelpers.MakeNewCustomDelegateType(typeArgs); #else throw new NotSupportedException("Signature not supported on this platform."); #endif } }
private static Type[] CombineAttributeIdEnumDefiningTypes(Type[] attributeIdEnumDefiningTypes, Type[] recordSpecificAttributeIdEnumDefiningTypes) { Type[] allAttributeIdEnumDefiningTypes; if (attributeIdEnumDefiningTypes == null) { attributeIdEnumDefiningTypes = new Type[0]; } allAttributeIdEnumDefiningTypes = new Type[1 + attributeIdEnumDefiningTypes.Length + recordSpecificAttributeIdEnumDefiningTypes.Length]; // allAttributeIdEnumDefiningTypes[0] = typeof(AttributeIds.UniversalAttributeId); attributeIdEnumDefiningTypes.CopyTo(allAttributeIdEnumDefiningTypes, 1); recordSpecificAttributeIdEnumDefiningTypes.CopyTo(allAttributeIdEnumDefiningTypes, 1 + attributeIdEnumDefiningTypes.Length); return allAttributeIdEnumDefiningTypes; }
protected Type[] CollectInterfaces(Type[] interfaces, ComponentModel model) { var modelInterfaces = model.Implementation.FindInterfaces(EmptyTypeFilter, model.Service); if (interfaces == null || interfaces.Length == 0) { interfaces = modelInterfaces; } else if (modelInterfaces.Length > 0) { var allInterfaces = new Type[interfaces.Length + modelInterfaces.Length]; interfaces.CopyTo(allInterfaces, 0); modelInterfaces.CopyTo(allInterfaces, interfaces.Length); interfaces = allInterfaces; } return interfaces; }
public MethodBase ResolvePlug(Type aTargetType, List<Type> aImpls, MethodBase aMethod, Type[] aParamTypes) { //TODO: This method is "reversed" from old - remember that when porting MethodBase xResult = null; // Setup param types for search Type[] xParamTypes; if (aMethod.IsStatic) { xParamTypes = aParamTypes; } else { // If its an instance method, we have to add this to the ParamTypes to search xParamTypes = new Type[aParamTypes.Length + 1]; if (aParamTypes.Length > 0) { aParamTypes.CopyTo(xParamTypes, 1); } xParamTypes[0] = aTargetType; } PlugMethodAttribute xAttrib = null; foreach (var xImpl in aImpls) { // TODO: cleanup this loop, next statement shouldnt be neccessary if (xResult != null) { break; } // Plugs methods must be static, and public // Search for non signature matches first since signature searches are slower xResult = xImpl.GetMethod(aMethod.Name, BindingFlags.Static | BindingFlags.Public , null, xParamTypes, null); if (xResult == null && aMethod.Name == ".ctor") { xResult = xImpl.GetMethod("Ctor", BindingFlags.Static | BindingFlags.Public , null, xParamTypes, null); } if (xResult == null && aMethod.Name == ".cctor") { xResult = xImpl.GetMethod("CCtor", BindingFlags.Static | BindingFlags.Public , null, xParamTypes, null); } if (xResult == null) { // Search by signature foreach (var xSigMethod in xImpl.GetMethods(BindingFlags.Static | BindingFlags.Public)) { // TODO: Only allow one, but this code for now takes the last one // if there is more than one xAttrib = null; foreach (PlugMethodAttribute x in xSigMethod.GetCustomAttributes(typeof(PlugMethodAttribute), false)) { xAttrib = x; } if (xAttrib != null && (xAttrib.IsWildcard && !xAttrib.WildcardMatchParameters)) { MethodBase xTargetMethod = null; if (String.Compare(xSigMethod.Name, "Ctor", true) == 0 || String.Compare(xSigMethod.Name, "Cctor", true) == 0) { xTargetMethod = aTargetType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance).SingleOrDefault(); } else { xTargetMethod = (from item in aTargetType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance) where item.Name == xSigMethod.Name select item).SingleOrDefault(); } if (xTargetMethod == aMethod) { xResult = xSigMethod; } } else { var xParams = xSigMethod.GetParameters(); //TODO: Static method plugs dont seem to be separated // from instance ones, so the only way seems to be to try // to match instance first, and if no match try static. // I really don't like this and feel we need to find // an explicit way to determine or mark the method // implementations. // // Plug implementations take "this" as first argument // so when matching we don't include it in the search Type[] xTypesInst = null; var xActualParamCount = xParams.Length; foreach (var xParam in xParams) { if (xParam.GetCustomAttributes(typeof(FieldAccessAttribute), false).Length > 0) { xActualParamCount--; } } Type[] xTypesStatic = new Type[xActualParamCount]; // If 0 params, has to be a static plug so we skip // any copying and leave xTypesInst = null // If 1 params, xTypesInst must be converted to Type[0] if (xActualParamCount == 1) { xTypesInst = new Type[0]; var xReplaceType = xParams[0].GetCustomAttributes(typeof(FieldTypeAttribute), false); if (xReplaceType.Length == 1) xTypesStatic[0] = Type.GetType(((FieldTypeAttribute)xReplaceType[0]).Name, true); else xTypesStatic[0] = xParams[0].ParameterType; } else if (xActualParamCount > 1) { xTypesInst = new Type[xActualParamCount - 1]; var xCurIdx = 0; foreach (var xParam in xParams.Skip(1)) { if (xParam.GetCustomAttributes(typeof(FieldAccessAttribute), false).Length > 0) { continue; } var xReplaceType = xParam.GetCustomAttributes(typeof(FieldTypeAttribute), false); if (xReplaceType.Length == 1) xTypesInst[xCurIdx] = Type.GetType(((FieldTypeAttribute)xReplaceType[0]).Name, true); else xTypesInst[xCurIdx] = xParam.ParameterType; xCurIdx++; } xCurIdx = 0; foreach (var xParam in xParams) { if (xParam.GetCustomAttributes(typeof(FieldAccessAttribute), false).Length > 0) { xCurIdx++; continue; } if (xCurIdx >= xTypesStatic.Length) { break; } xTypesStatic[xCurIdx] = xParam.ParameterType; xCurIdx++; } } SysReflection.MethodBase xTargetMethod = null; // TODO: In future make rule that all ctor plugs are called // ctor by name, or use a new attrib //TODO: Document all the plug stuff in a document on website //TODO: To make inclusion of plugs easy, we can make a plugs master // that references the other default plugs so user exes only // need to reference that one. // TODO: Skip FieldAccessAttribute if in impl if (xTypesInst != null) { if (string.Compare(xSigMethod.Name, "ctor", true) == 0) { xTargetMethod = aTargetType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, xTypesInst, null); } else { xTargetMethod = aTargetType.GetMethod(xSigMethod.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, xTypesInst, null); } } // Not an instance method, try static if (xTargetMethod == null) { if (string.Compare(xSigMethod.Name, "cctor", true) == 0 || string.Compare(xSigMethod.Name, "ctor", true) == 0) { xTargetMethod = aTargetType.GetConstructor(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, xTypesStatic, null); } else { xTargetMethod = aTargetType.GetMethod(xSigMethod.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, xTypesStatic, null); } } if (xTargetMethod == aMethod) { xResult = xSigMethod; break; } if (xAttrib != null && xAttrib.Signature != null) { var xName = DataMember.FilterStringForIncorrectChars(LabelName.GenerateFullName(aMethod)); if (string.Compare(xName, xAttrib.Signature, true) == 0) { xResult = xSigMethod; break; } } xAttrib = null; } } } else { // check if signatur is equal var xResPara = xResult.GetParameters(); var xAMethodPara = aMethod.GetParameters(); if (aMethod.IsStatic) { if (xResPara.Length != xAMethodPara.Length) return null; } else { if (xResPara.Length - 1 != xAMethodPara.Length) return null; } for (int i = 0; i < xAMethodPara.Length; i++) { int correctIndex = aMethod.IsStatic ? i : i + 1; if (xResPara[correctIndex].ParameterType != xAMethodPara[i].ParameterType) return null; } if (xResult.Name == "Ctor" && aMethod.Name == ".ctor") { } else if (xResult.Name == "CCtor" && aMethod.Name == ".cctor") { } else if (xResult.Name != aMethod.Name) return null; } } if (xResult == null) return null; // If we found a matching method, check for attributes // that might disable it. //TODO: For signature ones, we could cache the attrib. Thats // why we check for null here if (xAttrib == null) { // TODO: Only allow one, but this code for now takes the last one // if there is more than one foreach (PlugMethodAttribute x in xResult.GetCustomAttributes(typeof(PlugMethodAttribute), false)) { xAttrib = x; } } // See if we need to disable this plug if (xAttrib != null) { if (!xAttrib.Enabled) { //xResult = null; return null; } else if (xAttrib.IsMonoOnly) { //TODO: Check this against build options //TODO: Two exclusive IsOnly's dont make sense // refactor these as a positive rather than negative // Same thing at type plug level //xResult = null; return null; } //else if (xAttrib.Signature != null) { // var xName = DataMember.FilterStringForIncorrectChars(MethodInfoLabelGenerator.GenerateFullName(xResult)); // if (string.Compare(xName, xAttrib.Signature, true) != 0) { // xResult = null; // } //} } InlineAttribute xInlineAttrib = null; foreach (InlineAttribute inli in xResult.GetCustomAttributes(typeof(InlineAttribute), false)) { xInlineAttrib = inli; } if (xInlineAttrib == null) { if (Queue != null) { CompilerHelpers.Debug("Queueing Plug:", xResult.DeclaringType, "::", xResult.Name); Queue(xResult, null, "Plug Method"); } } //if (xAttrib != null && xAttrib.Signature != null) //{ // var xTargetMethods = aTargetType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); // //System_Void__Indy_IL2CPU_Assembler_Assembler__cctor__ // //If signature exists, the search is slow. Signatures // //are infrequent though, so for now we just go slow method // //and have not optimized or cached this info. When we // //redo the plugs, we can fix this. // bool xEnabled=true; // foreach (var xTargetMethod in xTargetMethods) // { // string sName = DataMember.FilterStringForIncorrectChars(MethodInfoLabelGenerator.GenerateFullName(xTargetMethod)); // if (string.Compare(sName, xAttrib.Signature, true) == 0) // { // //uint xUID = QueueMethod(xPlugImpl.Plug, "Plug", xMethod, true); // //mMethodPlugs.Add(xTargetMethod, new PlugInfo(xUID, xAttrib.Assembler)); // // Mark as disabled, because we already handled it // xEnabled = false; // break; // } // } // // if still enabled, we didn't find our method // if (xEnabled) // { // // todo: more precise error: imagine having a 100K line project, and this error happens... // throw new Exception("Plug target method not found."); // } //} return xResult; }
ParametersCollection (IParameterData [] parameters, Type [] types, MethodBase method, bool hasParams) { this.parameters = parameters; this.types = types; has_arglist = (method.CallingConvention & CallingConventions.VarArgs) != 0; if (has_arglist) { this.parameters = new IParameterData [parameters.Length + 1]; parameters.CopyTo (this.parameters, 0); this.parameters [parameters.Length] = new ArglistParameter (Location.Null); this.types = new Type [types.Length + 1]; types.CopyTo (this.types, 0); this.types [types.Length] = TypeManager.arg_iterator_type; } has_params = hasParams; }
IMessager CreateMessager(MethodInfo methodInfo, Type[] parameterTypes) { Type actionType; Type messagerType; Type[] genericArguments = new Type[parameterTypes.Length + 1]; genericArguments[0] = methodInfo.DeclaringType; parameterTypes.CopyTo(genericArguments, 1); if (parameterTypes.Length == 0) { actionType = typeof(Action<>).MakeGenericType(genericArguments); messagerType = typeof(Messager<>).MakeGenericType(genericArguments); } else { actionType = typeof(Action<,>).MakeGenericType(genericArguments); messagerType = typeof(Messager<,>).MakeGenericType(genericArguments); } Delegate action = Delegate.CreateDelegate(actionType, methodInfo); return (IMessager)Activator.CreateInstance(messagerType, action); }
public List<PropertyNode> ReadProperties(Type type, Type[] parents, AssemblyNode assembly, string version) { var newParents = new Type[parents.Length + 1]; parents.CopyTo(newParents, 0); newParents[parents.Length] = type; return type.GetProperties() .Where(propertyInfo => !IsIgnored(propertyInfo)) .Select(propertyInfo => ReadProperty(propertyInfo, newParents, assembly, version)) .ToList(); }