/// <summary> /// Get the event delegate for specified method in the source interface. Create a new one if necessary /// </summary> /// <param name="index">Function index</param> /// <returns>The delegate type</returns> public Type GetEventDelegate(InterfaceMemberInfo memberInfo) { TypeInfo type = memberInfo.RefTypeInfo; using (TypeAttr attr = type.GetTypeAttr()) { // Create m_delegateTypes on demand if (m_delegateTypes == null) { m_delegateTypes = new Dictionary <InterfaceMemberInfo, Type>(); } // // Check if we already have a delegate type for method n // if (!m_delegateTypes.ContainsKey(memberInfo)) { // // If not, create a new delegate // FuncDesc func = type.GetFuncDesc(memberInfo.Index); string eventName = type.GetDocumentation(func.memid); string delegateName = m_info.GetRecommendedManagedName(m_convInterface.RefTypeInfo, ConvType.Interface, true) + "_" + type.GetDocumentation(func.memid) + "EventHandler"; // Deal with name collisions delegateName = m_info.GetUniqueManagedName(delegateName); TypeBuilder delegateTypeBuilder = m_info.ModuleBuilder.DefineType( delegateName, TypeAttributes.Public | TypeAttributes.Sealed, typeof(MulticastDelegate) ); // Create constructor for the delegate ConstructorBuilder delegateCtorBuilder = delegateTypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[] { typeof(Object), typeof(UIntPtr) }); delegateCtorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed); // Create methods for the delegate InterfaceInfo interfaceInfoForDelegate = new InterfaceInfo(m_info, delegateTypeBuilder, false, type, attr, false, true); interfaceInfoForDelegate.AllowNewEnum = !m_convInterface.ImplementsIEnumerable; ConvCommon.CreateMethodForDelegate(interfaceInfoForDelegate, func, memberInfo.Index); // Emit ComVisibleAttribute(false) delegateTypeBuilder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForComVisible(false)); // Emit TypeLibTypeAttribute(TypeLibTypeFlags.FHidden) to hide it from object browser in VB delegateTypeBuilder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForTypeLibType(TypeLibTypeFlags.FHidden)); // Create the delegate m_delegateTypes[memberInfo] = delegateTypeBuilder.CreateType(); } } return(m_delegateTypes[memberInfo]); }
/// <summary> /// Remember the InterfaceMemberInfo/MethodBuilder information for creating properties later /// </summary> public void SetPropertyInfo(InterfaceMemberInfo memberInfo, MethodBuilder method) { int dispId = memberInfo.MemId; ConvProperty property = null; if (!m_properties.TryGetValue(dispId, out property)) { property = new ConvProperty(memberInfo.PropertyInfo); m_properties.Add(dispId, property); } if (memberInfo.IsPropertyGet) { property.SetGetMethod(method); } if (memberInfo.IsPropertyPut) { property.SetPutMethod(method); } if (memberInfo.IsPropertyPutRef) { property.SetPutRefMethod(method); } }
/// <summary> /// Get the return type converter for the function /// </summary> public static TypeConverter GetReturnType(InterfaceInfo info, InterfaceMemberInfo memInfo, FuncDesc func, bool isNewEnumMember, TypeConverter returnConverterOverride, List<TypeConverter> parameterConverterOverrideList, out ReturnKind kind, out bool isStandardOleCall, out int returnArgId) { TypeConverter retType = null; returnArgId = -1; kind = ReturnKind.ReturnValue; isStandardOleCall = false; TypeDesc retTypeDesc = func.elemdescFunc.tdesc; // If /preservesig is specified, we perform the PreserveSig transformation, except for dispatch functions. // Because they are not affected by PreserveSig attribute. if ((!func.IsDispatch) && (info.ConverterInfo.Settings.m_isPreserveSig || IsPreserveSigOverride(info, memInfo.Index))) { if (returnConverterOverride != null) { retType = returnConverterOverride; kind = ReturnKind.ReturnValue; } else if (retTypeDesc.vt == (int)VarEnum.VT_VOID) { retType = s_voidTypeConverter; kind = ReturnKind.NoReturn; } else { retType = new TypeConverter(info.ConverterInfo, info.RefTypeInfo, func.elemdescFunc.tdesc, isNewEnumMember, ConversionType.ReturnValue); kind = ReturnKind.ReturnValue; } return retType; } // Inspect the return value // If the return is HRESULT and PreserveSig switch is not specified, we will do the HRESULT transformation // Otherwise, stick to the original return value and use PreserveSigAttribute if (retTypeDesc.vt == (int)VarEnum.VT_HRESULT) { isStandardOleCall = true; } else { if (retTypeDesc.vt != (int)VarEnum.VT_VOID && retTypeDesc.vt != (int)VarEnum.VT_HRESULT) { if (returnConverterOverride != null) retType = returnConverterOverride; else retType = new TypeConverter(info.ConverterInfo, info.RefTypeInfo, func.elemdescFunc.tdesc, isNewEnumMember, ConversionType.ReturnValue); kind = ReturnKind.ReturnValue; } } if (func.funckind == TypeLibTypes.Interop.FUNCKIND.FUNC_DISPATCH && (!info.ConverterInfo.TransformDispRetVal)) { // Skip RetVal => return value transformation for dispatch interface when TransformDispRetVal is not set } else { for (int i = 0; i < func.cParams; ++i) { ElemDesc ret = func.GetElemDesc(i); // In a COM type library, the return parameter is logical and is the last parameter // whereas it is an explicit separate item in managed. if (IsRetVal(info.ConverterInfo, ret.paramdesc, func)) { // Convert last parameter to return value if (retType == null) { returnArgId = i; if (parameterConverterOverrideList[returnArgId] != null) retType = parameterConverterOverrideList[returnArgId]; else retType = new TypeConverter(info.ConverterInfo, info.RefTypeInfo, ret.tdesc, isNewEnumMember, ConversionType.ParamRetVal); kind = ReturnKind.RetValParameter; } else { info.ConverterInfo.ReportEvent( WarningCode.Wrn_AmbiguousReturn, Resource.FormatString("Wrn_AmbiguousReturn", info.RefTypeInfo.GetDocumentation(), info.RefTypeInfo.GetDocumentation(func.memid))); } break; } } } if (retType == null) { if (returnConverterOverride != null) { retType = returnConverterOverride; kind = ReturnKind.ReturnValue; } else { retType = s_voidTypeConverter; kind = ReturnKind.NoReturn; } } return retType; }
public static void CreateMethodForInterface(InterfaceInfo info, InterfaceMemberInfo memberInfo) { CreateMethod(info, memberInfo, CreateMethodMode.InterfaceMethodMode); }
/// <summary> /// Figure out types for parameters and return a parameter array /// </summary> /// <returns>TypeConverter[] array for all parameters</returns> public static TypeConverter[] GenerateParameterTypes(InterfaceInfo info, InterfaceMemberInfo memInfo, FuncDesc func, bool isNewEnumMember, int vararg, out int lcidArg, out bool isStandardOleCall, out TypeConverter retTypeConverter, out ReturnKind kind, out int retArgId) { // // Check Lcid Parameter // lcidArg = -1; for (int i = 0; i < func.cParams; ++i) { if (func.GetElemDesc(i).paramdesc.IsLCID) { if (lcidArg >= 0) { info.ConverterInfo.ReportEvent( WarningCode.Wrn_MultipleLcids, Resource.FormatString("Wrn_MultipleLcids", info.RefTypeInfo.GetDocumentation(), info.RefTypeInfo.GetDocumentation(func.memid))); } lcidArg = i; } } // Pre-process for the rule engine // For return value TypeConverter convertToReturnConverter = null; GetRuledReturnTypeConverter(info, memInfo, func, out convertToReturnConverter); // For parameters List<TypeConverter> convertToParameterConverterList; GetRuledParameterTypeConverters(info, memInfo, func, out convertToParameterConverterList); retTypeConverter = GetReturnType(info, memInfo, func, isNewEnumMember, convertToReturnConverter, convertToParameterConverterList, out kind, out isStandardOleCall, out retArgId); if ((retTypeConverter == convertToReturnConverter || convertToParameterConverterList.Contains(retTypeConverter))) { // From convertTo Action. if ((retTypeConverter.ParameterAttributesOverride & ParameterAttributes.In) != ParameterAttributes.None) { Output.WriteWarning(Resource.FormatString("Wrn_ConvertReturnValueToNoneOut", info.RefTypeInfo.GetDocumentation(func.memid)), WarningCode.Wrn_ConvertReturnValueToNoneOut); } retTypeConverter.ParameterAttributesOverride = ParameterAttributes.None; } int cParams = func.cParams; var typeConverterList = new List<TypeConverter>(); short n; for (n = 0; n < cParams; ++n) { ElemDesc elem = func.GetElemDesc(n); ParamDesc paramDesc = elem.paramdesc; // Skip LCID if (paramDesc.IsLCID) continue; // Skip return parameter if (kind == ReturnKind.RetValParameter && n == retArgId) continue; try { ConversionType conversionType; if (n == vararg) conversionType = ConversionType.VarArgParameter; else conversionType = ConversionType.Parameter; if (convertToParameterConverterList[n] != null) { typeConverterList.Add(convertToParameterConverterList[n]); } else { typeConverterList.Add(new TypeConverter( info.ConverterInfo, info.RefTypeInfo, elem.tdesc, paramDesc, false, conversionType)); } } catch (COMException ex) { if ((uint)ex.ErrorCode == HResults.TYPE_E_CANTLOADLIBRARY) { string[] names = info.RefTypeInfo.GetNames(func.memid, func.cParams + 1); string name = names[n + 1]; if (name != String.Empty) { string msg = Resource.FormatString("Wrn_ParamErrorNamed", new object[] { info.RefTypeInfo.GetDocumentation(), name, memInfo.UniqueName }); info.ConverterInfo.ReportEvent(WarningCode.Wrn_ParamErrorNamed, msg); } else { string msg = Resource.FormatString("Wrn_ParamErrorUnnamed", new object[] { info.RefTypeInfo.GetDocumentation(), n, memInfo.UniqueName }); info.ConverterInfo.ReportEvent(WarningCode.Wrn_ParamErrorUnnamed, msg); } } throw; } } return typeConverterList.ToArray(); }
/// <summary> /// Process parameters and apply attributes /// </summary> private static void ProcessParam(InterfaceInfo info, InterfaceMemberInfo memInfo, ElemDesc desc, TypeConverter converter, MethodBuilder methodBuilder, int index, string strname, bool isVarArg, bool isOptionalArg) { ParamDesc param = desc.paramdesc; ParameterAttributes attributes = ParameterAttributes.None; if (converter.ParameterAttributesOverride != ParameterAttributes.None) { attributes = converter.ParameterAttributesOverride; } else { // // Determine in/out/opt // Don't emit [In], [Out] for return type // if (index != 0) { // Always emit in/out information according to type library if (param.IsIn) { attributes |= ParameterAttributes.In; } if (param.IsOut) { attributes |= ParameterAttributes.Out; } if (param.IsOpt || isOptionalArg) { attributes |= ParameterAttributes.Optional; } } } // // Define the parameter // ParameterBuilder parameterBuilder = methodBuilder.DefineParameter(index, attributes, strname); // // Apply MarshalAs attribute // converter.ApplyAttributes(parameterBuilder); // // Support for vararg // if (isVarArg) { parameterBuilder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForParamArray()); } // // Support for default value // if (desc.paramdesc.HasDefault && desc.paramdesc.lpVarValue != IntPtr.Zero) SetDefaultValue(desc, converter.ConvertedType, parameterBuilder); }
public static void CreateMethodForDelegate(InterfaceInfo info, FuncDesc funcDesc, int index) { InterfaceMemberInfo memberInfo = new InterfaceMemberInfo(info.ConverterInfo, info.RefTypeInfo, index, INVOKE_METHOD, INVOKE_METHOD, InterfaceMemberType.Method, TypeLibTypes.Interop.INVOKEKIND.INVOKE_FUNC, funcDesc.memid, funcDesc, null); CreateMethod(info, memberInfo, CreateMethodMode.EventDelegateMode); }
private static void GetRuledParameterTypeConverters(InterfaceInfo info, InterfaceMemberInfo memInfo, FuncDesc func, out List<TypeConverter> convertToParameterConverterList) { int cParams = func.cParams; convertToParameterConverterList = new List<TypeConverter>(); short n; for (n = 0; n < cParams; ++n) { ElemDesc elem = func.GetElemDesc(n); ParamDesc paramDesc = elem.paramdesc; // "ConvertTo" for basic types and array // Rule Engine Rule convertToRule = null; if (memInfo.Index != -1) { // Is not event delegate. SignatureInfoMatchTarget target = new SignatureInfoMatchTarget( info.RefTypeInfo, memInfo.Index, elem, n + 1); if (info.ConverterInfo.Settings.m_ruleSet != null) { ICategory signatureCategory = SignatureCategory.GetInstance(); AbstractActionManager actionManager = RuleEngine.GetActionManager(); List<Rule> convertToRules = info.ConverterInfo.Settings.m_ruleSet.GetRule( signatureCategory, ConvertToActionDef.GetInstance(), target); if (convertToRules.Count != 0) { if (convertToRules.Count > 1) { Output.WriteWarning( Resource.FormatString("Wrn_RuleMultipleMatch", ConvertToActionDef.GetInstance().GetActionName()), WarningCode.Wrn_RuleMultipleMatch); } convertToRule = convertToRules[convertToRules.Count - 1]; } } if (convertToRule != null) { var convertToAction = convertToRule.Action as ConvertToAction; Type typeReturn; CustomAttributeBuilder customAttribute; ParameterAttributes fixedParameterAttributes; GetTypeFromConvertToAction(target, convertToAction, info.ConverterInfo, info.RefTypeInfo, elem.tdesc, out typeReturn, out customAttribute, out fixedParameterAttributes); convertToParameterConverterList.Add( new TypeConverter(typeReturn, customAttribute, fixedParameterAttributes)); } else { convertToParameterConverterList.Add(null); } } else { convertToParameterConverterList.Add(null); } } }
private static void GetRuledReturnTypeConverter(InterfaceInfo info, InterfaceMemberInfo memInfo, FuncDesc func, out TypeConverter convertToReturnConverter) { convertToReturnConverter = null; Rule convertToRule = null; if (memInfo.Index != -1) { // Is not event delegate. SignatureInfoMatchTarget returnTarget = new SignatureInfoMatchTarget( info.RefTypeInfo, memInfo.Index, func.elemdescFunc, 0); if (info.ConverterInfo.Settings.m_ruleSet != null) { ICategory signatureCategory = SignatureCategory.GetInstance(); AbstractActionManager actionManager = RuleEngine.GetActionManager(); List<Rule> convertToRules = info.ConverterInfo.Settings.m_ruleSet.GetRule( signatureCategory, ConvertToActionDef.GetInstance(), returnTarget); if (convertToRules.Count != 0) { if (convertToRules.Count > 1) { Output.WriteWarning( Resource.FormatString("Wrn_RuleMultipleMatch", ConvertToActionDef.GetInstance().GetActionName()), WarningCode.Wrn_RuleMultipleMatch); } convertToRule = convertToRules[convertToRules.Count - 1]; } } if (convertToRule != null) { var convertToAction = convertToRule.Action as ConvertToAction; Type typeReturn; CustomAttributeBuilder customAttribute; ParameterAttributes fixedParameterAttributes; GetTypeFromConvertToAction(returnTarget, convertToAction, info.ConverterInfo, info.RefTypeInfo, func.elemdescFunc.tdesc, out typeReturn, out customAttribute, out fixedParameterAttributes); convertToReturnConverter = new TypeConverter(typeReturn, customAttribute, fixedParameterAttributes); } } }
private static MethodBuilder CreateMethodInternal(InterfaceInfo info, VarDesc var, InterfaceMemberInfo memberInfo, CreateMethodMode mode, ref bool isConversionLoss) { bool convertingNewEnumMember = IsNewEnumDispatchProperty(info.ConverterInfo, info.RefTypeInfo, var, memberInfo.Index); Type retType = null; Type[] paramTypes = null; TypeConverter propTypeConverter = new TypeConverter(info.ConverterInfo, info.RefTypeInfo, var.elemdescVar.tdesc, ConversionType.ReturnValue); isConversionLoss |= propTypeConverter.IsConversionLoss; Type propType = propTypeConverter.ConvertedType; int propTypeParamIndex = 0; // The index of the function parameter that represents the property type if (memberInfo.InvokeKind == TypeLibTypes.Interop.INVOKEKIND.INVOKE_PROPERTYGET) { retType = propType; paramTypes = new Type[] { }; propTypeParamIndex = 0; // for Type get_XXX(). Index = 0 } else if (memberInfo.InvokeKind == TypeLibTypes.Interop.INVOKEKIND.INVOKE_PROPERTYPUT) { retType = typeof(void); paramTypes = new Type[] { propType }; propTypeParamIndex = 1; // for void set_XXX(Type arg). Index = 1 } else { Debug.Assert(false, "Should not get here!"); } MethodBuilder methodBuilder = CreateMethodCore(info, memberInfo, convertingNewEnumMember, mode, true, retType, paramTypes); ProcessParam(info, memberInfo, var.elemdescVar, propTypeConverter, methodBuilder, propTypeParamIndex, "", false, false); return methodBuilder; }
private static MethodBuilder CreateMethodInternal(InterfaceInfo info, FuncDesc func, InterfaceMemberInfo memberInfo, CreateMethodMode mode, ref bool isConversionLoss) { bool isNewEnumMember = false; if (info.AllowNewEnum && IsNewEnumFunc(info.ConverterInfo, info.RefTypeInfo, func, memberInfo.Index)) { info.AllowNewEnum = false; isNewEnumMember = true; if (mode == CreateMethodMode.EventDelegateMode) { info.ConverterInfo.ReportEvent( WarningCode.Wrn_EventWithNewEnum, Resource.FormatString("Wrn_EventWithNewEnum", info.RefTypeInfo.GetDocumentation())); } } // // Optional Arguments // int varArg; // index of the vararg argument int firstOptArg; // index of the first optional argument int lastOptArg; // index of the last optional argument CheckForOptionalArguments(info.ConverterInfo, func, out varArg, out firstOptArg, out lastOptArg); // // Figure out types // ReturnKind returnKind; TypeConverter retTypeConverter; Type retType; bool isStandardOleCall; int lcidArg; int retArgId; TypeConverter[] paramTypeConverters = GenerateParameterTypes(info, memberInfo, func, isNewEnumMember, varArg, out lcidArg, out isStandardOleCall, out retTypeConverter, out returnKind, out retArgId); var paramTypes = new Type[paramTypeConverters.Length]; for (int i = 0; i < paramTypeConverters.Length; ++i) paramTypes[i] = paramTypeConverters[i].ConvertedType; if (retTypeConverter != null) retType = retTypeConverter.ConvertedType; else retType = null; MethodBuilder methodBuilder = CreateMethodCore(info, memberInfo, isNewEnumMember, mode, isStandardOleCall, retType, paramTypes); // // Emit LCIDConversionAttribute // if (lcidArg >= 0) methodBuilder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForLCIDConversion(lcidArg)); int cParams = func.cParams; int cParamsIter = cParams; // If there is a return value, skip the last param if (returnKind == ReturnKind.RetValParameter) { ProcessParam(info, memberInfo, func.GetElemDesc(retArgId), retTypeConverter, methodBuilder, 0, "", false, false); isConversionLoss |= retTypeConverter.IsConversionLoss; } else if (returnKind == ReturnKind.ReturnValue) { ProcessParam(info, memberInfo, func.elemdescFunc, retTypeConverter, methodBuilder, 0, "", false, false); isConversionLoss |= retTypeConverter.IsConversionLoss; } // First string is the method name so offset by one String[] saNames = info.RefTypeInfo.GetNames(func.memid, cParams + 1); // // Process parameters // int paramIndex = 0; for (int n = 0; n < cParamsIter; ++n) { ElemDesc elem = func.GetElemDesc(n); // Skip LCID if (elem.paramdesc.IsLCID) continue; // Skip the return parameter if (returnKind == ReturnKind.RetValParameter && n == retArgId) continue; bool isOptionalArg = (n >= firstOptArg && n <= lastOptArg); bool isVarArg = (n == varArg); ProcessParam(info, memberInfo, elem, paramTypeConverters[paramIndex], methodBuilder, paramIndex + 1, saNames[n + 1], isVarArg, isOptionalArg); isConversionLoss |= paramTypeConverters[paramIndex].IsConversionLoss; paramIndex++; } // // Emit TypeLibFuncAttribute if necessary // if (func.wFuncFlags != 0) methodBuilder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForTypeLibFunc((TypeLibFuncFlags)func.wFuncFlags)); // // Handle DefaultMemberAttribute // if (!memberInfo.IsProperty && memberInfo.DispId == WellKnownDispId.DISPID_VALUE) { // DIFF: TlbImpv1 use the type library name while we use the unique name info.ConverterInfo.SetDefaultMember(info.TypeBuilder, methodBuilder.Name); } return methodBuilder; }
private static MethodBuilder CreateMethodCore(InterfaceInfo info, InterfaceMemberInfo memberInfo, bool isNewEnumMember, CreateMethodMode mode, bool isStandardOleCall, Type retType, Type[] paramTypes) { // // vtbl gap support. We only emit vtbl gap for non dispinterfaces // if (!info.IsCoClass && !info.RefTypeAttr.IsDispatch && mode != CreateMethodMode.EventDelegateMode) { int pointerSize = GetPointerSize(info.RefTypeInfo); int slot = memberInfo.RefFuncDesc.oVft / pointerSize; if (slot != info.CurrentSlot) { // Make sure slot numbers are monotonically increasing. if (slot < info.CurrentSlot) { info.ConverterInfo.ReportEvent( WarningCode.Wrn_BadVTable, Resource.FormatString("Wrn_BadVTable", new object[] { memberInfo.UniqueName, info.TypeBuilder.FullName, info.ConverterInfo.ModuleBuilder.Name }) ); throw new TlbImpInvalidTypeConversionException(info.RefTypeInfo); } int gap = slot - info.CurrentSlot; string vtblGapFuncName; if (gap == 1) vtblGapFuncName = string.Format(VTBL_GAP_FORMAT_1, info.CurrentSlot); else vtblGapFuncName = string.Format(VTBL_GAP_FORMAT_N, info.CurrentSlot, gap); MethodBuilder vtblFunc = info.TypeBuilder.DefineMethod( vtblGapFuncName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.Abstract); vtblFunc.SetImplementationFlags(MethodImplAttributes.Runtime); info.CurrentSlot = slot; } ++info.CurrentSlot; } MethodAttributes attributes = MethodAttributes.Public | MethodAttributes.Virtual; string methodName; // Determine the name & attributes if (mode == CreateMethodMode.EventDelegateMode) { methodName = INVOKE_METHOD; } else { methodName = info.GenerateUniqueMemberName(memberInfo.RecommendedName, paramTypes, MemberTypes.Method); // Update the name so that we can know the unique member name in the interface later in override if (!info.IsCoClass) { memberInfo.UpdateUniqueName(methodName); } attributes |= System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.NewSlot; if (!info.IsCoClass) { attributes |= System.Reflection.MethodAttributes.Abstract; } } // Is property? If so, add SpecialName to attributes if (!isNewEnumMember && memberInfo.InvokeKind != TypeLibTypes.Interop.INVOKEKIND.INVOKE_FUNC) attributes |= MethodAttributes.SpecialName; MethodBuilder methodBuilder = info.TypeBuilder.DefineMethod( methodName, attributes, CallingConventions.ExplicitThis | CallingConventions.HasThis, retType, paramTypes); // Set implementation flags MethodImplAttributes implAttributes; if (mode == CreateMethodMode.EventDelegateMode) implAttributes = MethodImplAttributes.Managed | MethodImplAttributes.Runtime; else implAttributes = MethodImplAttributes.InternalCall | MethodImplAttributes.Runtime; if (!isStandardOleCall) implAttributes |= MethodImplAttributes.PreserveSig; methodBuilder.SetImplementationFlags(implAttributes); // Add handling for [id(...)] if necessary if (info.EmitDispId || memberInfo.DispIdIsOverridden) { if (info.IsCoClass && !info.IsDefaultInterface) { // Skip non-default interfaces in coclass } else { methodBuilder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForDispId(memberInfo.DispId)); } } if (memberInfo.PropertyInfo != null && memberInfo.PropertyInfo.HasInvalidGetter) { info.ConverterInfo.ReportEvent( WarningCode.Wrn_PropgetWithoutReturn, Resource.FormatString("Wrn_PropgetWithoutReturn", memberInfo.PropertyInfo.RecommendedName, info.TypeBuilder.FullName ) ); } if (memberInfo.IsProperty && !isNewEnumMember) { info.PropertyInfo.SetPropertyInfo(memberInfo, methodBuilder); } // Add a .override instruction for the method for coclass if (info.IsCoClass) { Debug.Assert(info.CurrentImplementingInterface != null); using (TypeAttr implementingInterfaceAttr = info.CurrentImplementingInterface.GetTypeAttr()) { IConvBase convBase = info.ConverterInfo.GetInterface(info.CurrentImplementingInterface, implementingInterfaceAttr); Type interfaceType = convBase.RealManagedType; // Type.GetMethod(Name, ParamList) actually requires all the parameters be loaded (thus created). // Type.GetMethod(Name) won't have this problem. // We can workaround this limitation by having the coclass created after all the other types // Must use UniqueName because it is the right name on the interface. // We should use exact match here. MethodInfo methodInfo = interfaceType.GetMethod(memberInfo.UniqueName, BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Instance, null, paramTypes, null); if (methodInfo == null) { string expectedPrototypeString = FormatMethodPrototype(retType, memberInfo.UniqueName, paramTypes); string msg = Resource.FormatString("Err_OverridedMethodNotFoundInImplementedInterface", new object[] { expectedPrototypeString, interfaceType.FullName, info.TypeBuilder.FullName, info.TypeBuilder.Assembly.FullName }); throw new TlbImpGeneralException(msg, ErrorCode.Err_OverridedMethodNotFoundInImplementedInterface); } info.TypeBuilder.DefineMethodOverride(methodBuilder, methodInfo); } } return methodBuilder; }
private static void CreateMethod(InterfaceInfo info, InterfaceMemberInfo memberInfo, CreateMethodMode mode) { MethodBuilder method = null; bool isConversionLoss = false; switch (memberInfo.MemberType) { // Handle normal methods as well as accesors for properties case InterfaceMemberType.Method: method = CreateMethodInternal(info, memberInfo.RefFuncDesc, memberInfo, mode, ref isConversionLoss); break; // Handle properties in dispatch interfaces defined as variables case InterfaceMemberType.Variable: method = CreateMethodInternal(info, memberInfo.RefVarDesc, memberInfo, mode, ref isConversionLoss); break; default: Debug.Assert(false); break; } if (method == null) return; if (isConversionLoss) { string msg = Resource.FormatString( "Wrn_UnconvertableArgs", info.TypeBuilder.FullName, method.Name); info.ConverterInfo.ReportEvent(WarningCode.Wrn_UnconvertableArgs, msg); } info.IsConversionLoss |= isConversionLoss; }
/// <summary> /// Get the event delegate for specified method in the source interface. Create a new one if necessary /// </summary> /// <param name="index">Function index</param> /// <returns>The delegate type</returns> public Type GetEventDelegate(InterfaceMemberInfo memberInfo) { TypeInfo type = memberInfo.RefTypeInfo; using (TypeAttr attr = type.GetTypeAttr()) { // Create m_delegateTypes on demand if (m_delegateTypes == null) { m_delegateTypes = new Dictionary<InterfaceMemberInfo, Type>(); } // // Check if we already have a delegate type for method n // if (!m_delegateTypes.ContainsKey(memberInfo)) { // // If not, create a new delegate // FuncDesc func = type.GetFuncDesc(memberInfo.Index); string eventName = type.GetDocumentation(func.memid); string delegateName = m_info.GetRecommendedManagedName(m_convInterface.RefTypeInfo, ConvType.Interface, true) + "_" + type.GetDocumentation(func.memid) + "EventHandler"; // Deal with name collisions delegateName = m_info.GetUniqueManagedName(delegateName); TypeBuilder delegateTypeBuilder = m_info.ModuleBuilder.DefineType( delegateName, TypeAttributes.Public | TypeAttributes.Sealed, typeof(MulticastDelegate) ); // Create constructor for the delegate ConstructorBuilder delegateCtorBuilder = delegateTypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[] { typeof(Object), typeof(UIntPtr) }); delegateCtorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed); // Create methods for the delegate InterfaceInfo interfaceInfoForDelegate = new InterfaceInfo(m_info, delegateTypeBuilder, false, type, attr, false, true); interfaceInfoForDelegate.AllowNewEnum = !m_convInterface.ImplementsIEnumerable; ConvCommon.CreateMethodForDelegate(interfaceInfoForDelegate, func, memberInfo.Index); // Emit ComVisibleAttribute(false) delegateTypeBuilder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForComVisible(false)); // Emit TypeLibTypeAttribute(TypeLibTypeFlags.FHidden) to hide it from object browser in VB delegateTypeBuilder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForTypeLibType(TypeLibTypeFlags.FHidden)); // Create the delegate m_delegateTypes[memberInfo] = delegateTypeBuilder.CreateType(); } } return m_delegateTypes[memberInfo]; }