public TypeLibViewModel(ITypeLib typeLib) { _typeLib = typeLib; TYPELIBATTR attr = COMUtil.GetTypeLibAttr(typeLib); CLSID = attr.guid.ToString(); MajorVersion = attr.wMajorVerNum; MinorVersion = attr.wMinorVerNum; LCID = attr.lcid; //Name = Marshal.GetTypeLibName(typeLib); string name, docString, helpFile; int helpContext; typeLib.GetDocumentation(-1, out name, out docString, out helpContext, out helpFile); Path = COMUtil.GetTypeLibPath(typeLib); Name = name; Description = docString; // Remove the null char HelpFilePath = helpFile == null ? string.Empty : helpFile.Substring(0, helpFile.Length - 1); string asmName, asmCodeBase; var converter = new TypeLibConverter(); converter.GetPrimaryInteropAssembly( attr.guid, MajorVersion, MinorVersion, LCID, out asmName, out asmCodeBase); PIAName = asmName; PIACodeBase = asmCodeBase; }
static int Main(string[] args) { if (args.Length < 2) { Console.WriteLine("Usage: tlb-convert <unmanaged COM DLL path> <managed wrapper path> [root namespace]"); return 2; } try { string srcDll = args[0]; string outDll = args[1]; string rootNamespace = args.Length == 3 ? args[2] : null; Object typeLib; LoadTypeLibEx(srcDll, RegKind.RegKind_None, out typeLib); TypeLibConverter tlbConv = new TypeLibConverter(); AssemblyBuilder asm = tlbConv.ConvertTypeLibToAssembly(typeLib, outDll, 0, new ConversionEventHandler(), null, null, rootNamespace, null); asm.Save(outDll); } catch (Exception e) { Console.WriteLine("Exception: {0}\n{1}", e.Message, e.StackTrace); return 1; } Console.WriteLine("\nConversion successful."); return 0; }
public Assembly ResolveEvent(object sender, ResolveEventArgs args) { try { TypeLibConverter.LoadInMemoryTypeByName(this.m_Module.GetNativeHandle(), args.Name); return(this.m_Module.Assembly); } catch (TypeLoadException ex) { if (ex.ResourceId != -2146233054) { throw; } } foreach (RuntimeAssembly runtimeAssembly in this.m_AsmList) { try { runtimeAssembly.GetType(args.Name, true, false); return(runtimeAssembly); } catch (TypeLoadException ex2) { if (ex2._HResult != -2146233054) { throw; } } } return(null); }
public AssemblyBuilder ConvertTypeLibToAssembly([MarshalAs(UnmanagedType.Interface)] object typeLib, string asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, byte[] publicKey, StrongNameKeyPair keyPair, string asmNamespace, Version asmVersion) { if (typeLib == null) { throw new ArgumentNullException("typeLib"); } if (asmFileName == null) { throw new ArgumentNullException("asmFileName"); } if (notifySink == null) { throw new ArgumentNullException("notifySink"); } if (string.Empty.Equals(asmFileName)) { throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileName"), "asmFileName"); } if (asmFileName.Length > 260) { throw new ArgumentException(Environment.GetResourceString("IO.PathTooLong"), asmFileName); } if ((flags & TypeLibImporterFlags.PrimaryInteropAssembly) != TypeLibImporterFlags.None && publicKey == null && keyPair == null) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_PIAMustBeStrongNamed")); } ArrayList arrayList = null; AssemblyNameFlags asmNameFlags = AssemblyNameFlags.None; AssemblyName assemblyNameFromTypelib = TypeLibConverter.GetAssemblyNameFromTypelib(typeLib, asmFileName, publicKey, keyPair, asmVersion, asmNameFlags); AssemblyBuilder assemblyBuilder = TypeLibConverter.CreateAssemblyForTypeLib(typeLib, asmFileName, assemblyNameFromTypelib, (flags & TypeLibImporterFlags.PrimaryInteropAssembly) > TypeLibImporterFlags.None, (flags & TypeLibImporterFlags.ReflectionOnlyLoading) > TypeLibImporterFlags.None, (flags & TypeLibImporterFlags.NoDefineVersionResource) > TypeLibImporterFlags.None); string fileName = Path.GetFileName(asmFileName); ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(fileName, fileName); if (asmNamespace == null) { asmNamespace = assemblyNameFromTypelib.Name; } TypeLibConverter.TypeResolveHandler typeResolveHandler = new TypeLibConverter.TypeResolveHandler(moduleBuilder, notifySink); AppDomain domain = Thread.GetDomain(); ResolveEventHandler value = new ResolveEventHandler(typeResolveHandler.ResolveEvent); ResolveEventHandler value2 = new ResolveEventHandler(typeResolveHandler.ResolveAsmEvent); ResolveEventHandler value3 = new ResolveEventHandler(typeResolveHandler.ResolveROAsmEvent); domain.TypeResolve += value; domain.AssemblyResolve += value2; domain.ReflectionOnlyAssemblyResolve += value3; TypeLibConverter.nConvertTypeLibToMetadata(typeLib, assemblyBuilder.InternalAssembly, moduleBuilder.InternalModule, asmNamespace, flags, typeResolveHandler, out arrayList); TypeLibConverter.UpdateComTypesInAssembly(assemblyBuilder, moduleBuilder); if (arrayList.Count > 0) { new TCEAdapterGenerator().Process(moduleBuilder, arrayList); } domain.TypeResolve -= value; domain.AssemblyResolve -= value2; domain.ReflectionOnlyAssemblyResolve -= value3; return(assemblyBuilder); }
public Assembly ResolveRef(object TypeLib) { try { ITypeLibConverter converter = new TypeLibConverter(); return converter.ConvertTypeLibToAssembly(TypeLib, Marshal.GetTypeLibName((ITypeLib) TypeLib) + ".dll", TypeLibImporterFlags.None, new ImporterCallback(), null, null, null, null); } catch (Exception) { return null; } }
public Assembly ResolveRef(object TypeLib) { try { ITypeLibConverter converter = new TypeLibConverter(); return(converter.ConvertTypeLibToAssembly(TypeLib, Marshal.GetTypeLibName((ITypeLib)TypeLib) + ".dll", TypeLibImporterFlags.None, new ImporterCallback(), null, null, null, null)); } catch (Exception) { return(null); } }
private static AssemblyBuilder CreateAssemblyForTypeLib(object typeLib, string asmFileName, AssemblyName asmName, bool bPrimaryInteropAssembly, bool bReflectionOnly, bool bNoDefineVersionResource) { AppDomain domain = Thread.GetDomain(); string text = null; if (asmFileName != null) { text = Path.GetDirectoryName(asmFileName); if (string.IsNullOrEmpty(text)) { text = null; } } AssemblyBuilderAccess access; if (bReflectionOnly) { access = AssemblyBuilderAccess.ReflectionOnly; } else { access = AssemblyBuilderAccess.RunAndSave; } List <CustomAttributeBuilder> list = new List <CustomAttributeBuilder>(); ConstructorInfo constructor = typeof(SecurityRulesAttribute).GetConstructor(new Type[] { typeof(SecurityRuleSet) }); CustomAttributeBuilder item = new CustomAttributeBuilder(constructor, new object[] { SecurityRuleSet.Level2 }); list.Add(item); AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(asmName, access, text, false, list); TypeLibConverter.SetGuidAttributeOnAssembly(assemblyBuilder, typeLib); TypeLibConverter.SetImportedFromTypeLibAttrOnAssembly(assemblyBuilder, typeLib); if (bNoDefineVersionResource) { TypeLibConverter.SetTypeLibVersionAttribute(assemblyBuilder, typeLib); } else { TypeLibConverter.SetVersionInformation(assemblyBuilder, typeLib, asmName); } if (bPrimaryInteropAssembly) { TypeLibConverter.SetPIAAttributeOnAssembly(assemblyBuilder, typeLib); } return(assemblyBuilder); }
private static void SetVersionInformation(AssemblyBuilder asmBldr, object typeLib, AssemblyName asmName) { string strName = (string)null; string strDocString = (string)null; int dwHelpContext = 0; string strHelpFile = (string)null; ((ITypeLib)typeLib).GetDocumentation(-1, out strName, out strDocString, out dwHelpContext, out strHelpFile); string product = string.Format((IFormatProvider)CultureInfo.InvariantCulture, Environment.GetResourceString("TypeLibConverter_ImportedTypeLibProductName"), (object)strName); asmBldr.DefineVersionInfoResource(product, asmName.Version.ToString(), (string)null, (string)null, (string)null); TypeLibConverter.SetTypeLibVersionAttribute(asmBldr, typeLib); }
public void BuildLib(string targetFolder) { NativeMethods.LoadTypeLibEx(VBoxWrapper.COMInterface.VBoxComUtils.GetVirtualBoxComTypeLib(), NativeMethods.RegKind.RegKind_None, out _typeLibInMemory); if (_typeLibInMemory == null) { throw new DllNotFoundException("Could not load Virtualbox-Typelibrary."); } TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler handler = new ConversionEventHandler(); AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(_typeLibInMemory, "Interop.VirtualBox.dll", TypeLibImporterFlags.SafeArrayAsSystemArray, handler, null, null, "VirtualBox", null); //using assembly name "VirtualBox" and SafeArrayAsSystemArray to be compatible to VisualStudio-Generated Interop-Assembly asm.Save("Interop.VirtualBox.dll"); }
private static void SetVersionInformation(AssemblyBuilder asmBldr, object typeLib, AssemblyName asmName) { string arg = null; string text = null; int num = 0; string text2 = null; ITypeLib typeLib2 = (ITypeLib)typeLib; typeLib2.GetDocumentation(-1, out arg, out text, out num, out text2); string product = string.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("TypeLibConverter_ImportedTypeLibProductName"), arg); asmBldr.DefineVersionInfoResource(product, asmName.Version.ToString(), null, null, null); TypeLibConverter.SetTypeLibVersionAttribute(asmBldr, typeLib); }
public object ConvertAssemblyToTypeLib(Assembly assembly, string strTypeLibName, TypeLibExporterFlags flags, ITypeLibExporterNotifySink notifySink) { AssemblyBuilder assemblyBuilder = assembly as AssemblyBuilder; RuntimeAssembly assembly2; if (assemblyBuilder != null) { assembly2 = assemblyBuilder.InternalAssembly; } else { assembly2 = (assembly as RuntimeAssembly); } return(TypeLibConverter.nConvertAssemblyToTypeLib(assembly2, strTypeLibName, flags, notifySink)); }
private static AssemblyBuilder CreateAssemblyForTypeLib(object typeLib, string asmFileName, AssemblyName asmName, bool bPrimaryInteropAssembly, bool bReflectionOnly, bool bNoDefineVersionResource) { AppDomain domain = Thread.GetDomain(); string dir = (string)null; if (asmFileName != null) { dir = Path.GetDirectoryName(asmFileName); if (string.IsNullOrEmpty(dir)) { dir = (string)null; } } AssemblyBuilderAccess access = !bReflectionOnly ? AssemblyBuilderAccess.RunAndSave : AssemblyBuilderAccess.ReflectionOnly; AssemblyBuilder asmBldr = domain.DefineDynamicAssembly(asmName, access, dir, false, (System.Collections.Generic.IEnumerable <CustomAttributeBuilder>) new List <CustomAttributeBuilder>() { new CustomAttributeBuilder(typeof(SecurityRulesAttribute).GetConstructor(new Type[1] { typeof(SecurityRuleSet) }), new object[1] { (object)SecurityRuleSet.Level2 }) }); TypeLibConverter.SetGuidAttributeOnAssembly(asmBldr, typeLib); TypeLibConverter.SetImportedFromTypeLibAttrOnAssembly(asmBldr, typeLib); if (bNoDefineVersionResource) { TypeLibConverter.SetTypeLibVersionAttribute(asmBldr, typeLib); } else { TypeLibConverter.SetVersionInformation(asmBldr, typeLib, asmName); } if (bPrimaryInteropAssembly) { TypeLibConverter.SetPIAAttributeOnAssembly(asmBldr, typeLib); } return(asmBldr); }
/* * Method: GenerateWrapper * * Generates a wrapper for this reference. */ internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo) { wrapperInfo = null; string rootNamespace = ReferenceInfo.typeLibName; string wrapperPath = GetWrapperPath(); bool generateWrapperSucceeded = true; if (ExecuteAsTool) { // delegate generation of the assembly to an instance of the TlbImp ToolTask. MUST // HAVE SET SDKTOOLSPATH TO THE TARGET SDK TO WORK var tlbImp = new ResolveComReference.TlbImp(); tlbImp.BuildEngine = BuildEngine; tlbImp.EnvironmentVariables = EnvironmentVariables; tlbImp.DelaySign = DelaySign; tlbImp.KeyContainer = KeyContainer; tlbImp.KeyFile = KeyFile; tlbImp.OutputAssembly = wrapperPath; tlbImp.ToolPath = ToolPath; tlbImp.TypeLibName = ReferenceInfo.fullTypeLibPath; tlbImp.AssemblyNamespace = rootNamespace; tlbImp.AssemblyVersion = null; tlbImp.PreventClassMembers = _noClassMembers; tlbImp.SafeArrayAsSystemArray = true; tlbImp.Silent = Silent; tlbImp.Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals; if (_referenceFiles != null) { // Issue is that there may be reference dependencies that need to be passed in. It is possible // that the set of references will also contain the file that is meant to be written here (when reference resolution // found the file in the output folder). We need to filter out this case. var fullPathToOutput = Path.GetFullPath(wrapperPath); // Current directory is the directory of the project file. tlbImp.ReferenceFiles = _referenceFiles.Where(rf => String.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0).ToArray(); } switch (_targetProcessorArchitecture) { case UtilitiesProcessorArchitecture.MSIL: tlbImp.Machine = "Agnostic"; break; case UtilitiesProcessorArchitecture.AMD64: tlbImp.Machine = "X64"; break; case UtilitiesProcessorArchitecture.IA64: tlbImp.Machine = "Itanium"; break; case UtilitiesProcessorArchitecture.X86: tlbImp.Machine = "X86"; break; case UtilitiesProcessorArchitecture.ARM: tlbImp.Machine = "ARM"; break; case null: break; default: // Transmit the flag directly from the .targets files and rely on tlbimp.exe to produce a good error message. tlbImp.Machine = _targetProcessorArchitecture; break; } generateWrapperSucceeded = tlbImp.Execute(); // store the wrapper info... wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath; // Changed to ReflectionOnlyLoadFrom, related to bug: // RCR: Bad COM-interop assemblies being generated when using 64-bit MSBuild to build a project that is targeting 32-bit platform // The original call to UnsafeLoadFrom loads the assembly in preparation for execution. If the assembly is x86 and this is x64 msbuild.exe then we // have problems (UnsafeLoadFrom will fail). We only use this assembly for reference resolution so we don't need to be ready to execute the code. // // Its actually not clear to me that we even need to load the assembly at all. Reference resoluton is only used in the !ExecuteAsTool which is not // where we are right now. // // If we really do need to load it then: // // wrapperInfo.assembly = Assembly.ReflectionOnlyLoadFrom(wrapperPath); } else { // use framework classes in-proc to generate the assembly TypeLibConverter converter = new TypeLibConverter(); AssemblyBuilder assemblyBuilder = null; StrongNameKeyPair keyPair; byte[] publicKey; GetAndValidateStrongNameKey(out keyPair, out publicKey); try { TypeLibImporterFlags flags = TypeLibImporterFlags.SafeArrayAsSystemArray | TypeLibImporterFlags.TransformDispRetVals; if (_noClassMembers) { flags |= TypeLibImporterFlags.PreventClassMembers; } switch (_targetProcessorArchitecture) { case UtilitiesProcessorArchitecture.MSIL: flags |= TypeLibImporterFlags.ImportAsAgnostic; break; case UtilitiesProcessorArchitecture.AMD64: flags |= TypeLibImporterFlags.ImportAsX64; break; case UtilitiesProcessorArchitecture.IA64: flags |= TypeLibImporterFlags.ImportAsItanium; break; case UtilitiesProcessorArchitecture.X86: flags |= TypeLibImporterFlags.ImportAsX86; break; case UtilitiesProcessorArchitecture.ARM: flags |= TypeLibImporterFlags.ImportAsArm; break; default: // Let the type importer decide. break; } // Start the conversion process. We'll get callbacks on ITypeLibImporterNotifySink to resolve dependent refs. assemblyBuilder = converter.ConvertTypeLibToAssembly(ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, rootNamespace, null); } catch (COMException ex) { if (!Silent) { Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", ItemName, ex.Message); } throw new ComReferenceResolutionException(ex); } // if we're done, and this is not a temporary wrapper, write it out to disk if (!HasTemporaryWrapper) { WriteWrapperToDisk(assemblyBuilder, wrapperPath); } // store the wrapper info... wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath; wrapperInfo.assembly = assemblyBuilder; } // ...and we're done! return generateWrapperSucceeded; }
public string GenerateFromTypeLibrary(UCOMITypeLib typeLib, Guid clsid) { string fileName = null; string axTypeFromAssembly = null; Assembly assem = null; fileName = this.GetAxReference((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib); if ((fileName != null) && (clsid != Guid.Empty)) { axTypeFromAssembly = this.GetAxTypeFromAssembly(fileName, clsid); } if (fileName == null) { string typeLibName = Marshal.GetTypeLibName((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib); string asmFileName = Path.Combine(this.options.outputDirectory, typeLibName + ".dll"); this.AddReferencedAssembly(this.GetManagedReference("System.Windows.Forms")); this.AddReferencedAssembly(this.GetManagedReference("System.Drawing")); this.AddReferencedAssembly(this.GetManagedReference("System")); string comReference = this.GetComReference((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib); if (comReference != null) { this.AddReferencedAssembly(comReference); assem = this.GetCopiedAssembly(comReference, false, false); this.AddDependentAssemblies(assem, comReference); } else { TypeLibConverter tlbConverter = new TypeLibConverter(); assem = this.GetPrimaryInteropAssembly((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib, tlbConverter); if (assem != null) { comReference = this.GetLocalPath(assem.EscapedCodeBase); this.AddDependentAssemblies(assem, comReference); } else { AssemblyBuilder asmBldr = tlbConverter.ConvertTypeLibToAssembly((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib, asmFileName, TypeLibImporterFlags.None, new ImporterCallback(this), this.options.publicKey, this.options.keyPair, null, null); if (comReference == null) { comReference = this.SaveAssemblyBuilder((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib, asmBldr, asmFileName); assem = asmBldr; } } } int num = 0; string[] refAssemblies = new string[this.refAssems.Count]; foreach (string str6 in this.refAssems) { string str7 = str6; str7 = str7.Replace("%20", " "); refAssemblies[num++] = str7; } if (axTypeFromAssembly == null) { string path = null; if (this.options.ignoreRegisteredOcx) { path = this.typeLibName; } else { path = GetFileOfTypeLib((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib); } DateTime tlbTimeStamp = (path == null) ? DateTime.Now : File.GetLastWriteTime(path); ResolveEventHandler handler = new ResolveEventHandler(this.OnAssemblyResolve); AppDomain.CurrentDomain.AssemblyResolve += handler; AppDomain.CurrentDomain.TypeResolve += new ResolveEventHandler(this.OnTypeResolve); try { if (this.options.genSources) { AxWrapperGen.GeneratedSources = new ArrayList(); } if (this.options.outputName == null) { this.options.outputName = "Ax" + typeLibName + ".dll"; } axTypeFromAssembly = AxWrapperGen.GenerateWrappers(this, clsid, assem, refAssemblies, tlbTimeStamp, this.options.ignoreRegisteredOcx, out fileName); if (this.options.genSources) { this.generatedSources = AxWrapperGen.GeneratedSources; } } finally { AppDomain.CurrentDomain.AssemblyResolve -= handler; AppDomain.CurrentDomain.TypeResolve -= new ResolveEventHandler(this.OnTypeResolve); } if (axTypeFromAssembly == null) { string message = System.Design.SR.GetString("AXNoActiveXControls", new object[] { (this.typeLibName != null) ? this.typeLibName : typeLibName }); if (this.options.msBuildErrors) { message = "AxImp: error aximp000: " + message; } throw new Exception(message); } } if (axTypeFromAssembly != null) { this.AddReferencedAssembly(fileName); this.AddTypeLibAttr((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib); this.AddGeneratedAssembly(fileName); } } return axTypeFromAssembly; }
private DLLModel convertDLLToManaged(DLLModel dLLModel) { Object typeLib; LoadTypeLibEx(dLLModel.getFullyQualifiedPath(), RegKind.RegKind_None, out typeLib); if (typeLib == null) { Console.WriteLine("LoadTypeLibEx failed."); } TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(); string newDllName = dLLModel.getDllFileName() + "_converted.dll"; AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(typeLib, newDllName, 0, eventHandler, null, null, null, null); asm.Save(newDllName); DLLModel newdLLModel = new DLLModel(AppDomain.CurrentDomain.BaseDirectory + newDllName); return newdLLModel; }
private static Assembly ConvertTypeLibToAssembly(ITypeLib typeLib) { if (m_typelibs == null) { LoadTypeLibAssemblies(); } if (m_typelibs.ContainsKey(Marshal.GetTypeLibGuid(typeLib))) { return m_typelibs[Marshal.GetTypeLibGuid(typeLib)]; } else { string strAssemblyPath = GetTypeLibDirectory(); strAssemblyPath = Path.Combine(strAssemblyPath, Marshal.GetTypeLibName(typeLib) + ".dll"); TypeLibConverter conv = new TypeLibConverter(); AssemblyBuilder asm = conv.ConvertTypeLibToAssembly(typeLib, strAssemblyPath, TypeLibImporterFlags.ReflectionOnlyLoading, new TypeLibCallback(), null, null, null, null); asm.Save(Path.GetFileName(strAssemblyPath)); Assembly a = Assembly.LoadFile(strAssemblyPath); m_typelibs[Marshal.GetTypeLibGuid(typeLib)] = a; RegisterTypeInterfaces(a); return a; } }
public void RegisterAsnetMmcAssembly(int doReg, string typeName, string binaryDirectory, out IntPtr exception) { exception = IntPtr.Zero; try { Assembly webAssembly = Assembly.GetAssembly(Type.GetType(typeName, true)); RegistrationServices rs = new RegistrationServices(); if (doReg != 0) { if (!rs.RegisterAssembly(webAssembly, AssemblyRegistrationFlags.None)) exception = Marshal.StringToBSTR((new Exception(SR.GetString(SR.Unable_To_Register_Assembly, webAssembly.FullName))).ToString()); TypeLibConverter converter = new TypeLibConverter(); ConversionEventSink eventHandler = new ConversionEventSink(); IRegisterCreateITypeLib typeLib = (IRegisterCreateITypeLib)converter.ConvertAssemblyToTypeLib(webAssembly, System.IO.Path.Combine(binaryDirectory, "AspNetMMCExt.tlb"), 0, eventHandler); typeLib.SaveAllChanges(); } else { // Consider deleting tlb file if (!rs.UnregisterAssembly(webAssembly)) exception = Marshal.StringToBSTR((new Exception(SR.GetString(SR.Unable_To_UnRegister_Assembly, webAssembly.FullName))).ToString()); try { File.Delete(System.IO.Path.Combine(binaryDirectory, "AspNetMMCExt.tlb")); } catch { } } } catch (Exception e) { exception = Marshal.StringToBSTR(e.ToString()); } }
Assembly ITypeLibImporterNotifySink.ResolveRef(object typeLib) { Assembly assembly2; try { string comReference = this.importer.GetComReference((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib); if (comReference != null) { this.importer.AddReferencedAssembly(comReference); } Assembly primaryInteropAssembly = this.importer.FindRCW((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib); if (primaryInteropAssembly != null) { assembly2 = primaryInteropAssembly; } else { try { string assemName = Path.Combine(this.options.outputDirectory, Marshal.GetTypeLibName((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib) + ".dll"); if (this.importer.GetReferencedAssembly(assemName) != null) { return this.importer.GetCopiedAssembly(assemName, false, false); } TypeLibConverter tlbConverter = new TypeLibConverter(); primaryInteropAssembly = this.importer.GetPrimaryInteropAssembly((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib, tlbConverter); if (primaryInteropAssembly != null) { return primaryInteropAssembly; } AssemblyBuilder asmBldr = tlbConverter.ConvertTypeLibToAssembly(typeLib, assemName, TypeLibImporterFlags.None, new AxImporter.ImporterCallback(this.importer), this.options.publicKey, this.options.keyPair, null, null); if (comReference == null) { this.importer.SaveAssemblyBuilder((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib, asmBldr, assemName); this.importer.AddRCW((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib, asmBldr); return asmBldr; } assembly2 = this.importer.GetCopiedAssembly(comReference, false, false); } catch { assembly2 = null; } } } finally { Marshal.ReleaseComObject(typeLib); } return assembly2; }
// This translates the type library into an assembly internal void TranslateTypeLib() { TraceUtil.WriteLineInfo(this, "TranslateTypeLib"); // Already associated with an assembly if (_assy != null) return; ReadTypeLibFile(); if (_iTypeLib == null) throw new Exception("Failed to open file: " + _fileName); // If this is present, we can't translate the assembly, // we just have to try and load it using this name. This // is the case for things like mscorlib.tlb if (_translatedAssyFullName != null) { Assembly assy = null; try { String fileName; // We will have the file name if we are coming through // here after the type library has been opened previously // (when it is being restored from the registry). if (_assyInfo._fileName != null) fileName = _assyInfo._fileName; else fileName = _translatedAssyFullName; TraceUtil.WriteLineInfo (null, "TypeLib - translated assy looking for: " + fileName); assy = Assembly.Load(fileName); } catch (FileNotFoundException) { // Don't ask the user if we have already asked // the user if (!_dontFindAssy) assy = FindAssemblyFile(); } TraceUtil.WriteLineInfo(null, "TypeLib - source assy is: " + assy + " for translated lib " + _translatedAssyFullName); RecordTranslatedAssy(assy); return; } CheckForPrimaryInteropAssy(); if (_primaryInteropAssyName != null) return; // Only create the versioned names if the primary interop assy // is not used, since that's not versioned. CreateAssyNames(); TraceUtil.WriteLineIf(null, TraceLevel.Info, "TypeLib - converting - url: " + _assyInfo._url + " file: " + _assyInfo._fileName); String dir = ComponentInspectorProperties.ConvertedAssemblyDirectory; Directory.CreateDirectory(dir); Directory.SetCurrentDirectory(dir); if (IsAssyCurrent(_assyInfo._fileName, _fileName)) { // See if there is a translated version already present. // We don't know if there should be an Ax version or not, // try the normal one and if it succeeds, try the Ax version. // If the normal version succeeds however, we can consider // that we are done. RecordTranslatedAssy(Assembly.LoadFrom(_assyInfo._url)); TraceUtil.WriteLineInfo(null, "TypeLib - found previous xlated " + _assyInfo._name); try { RecordTranslatedAssy(Assembly.LoadFrom(_axAssyInfo._url)); } catch { // Ignore } return; } // Convert the type library to an assembly // The assembly load event happens in here, it is going to // be unable to add the assembly to the registry since there // is no CodeBase associated with a dynamically created // assembly, but that's not a problem since we add it below // when adding the GUID for the typelib ProgressDialog progress = new ProgressDialog(); progress.Setup("Converting " + GetName() + " to .NET Assembly", "Please wait while I convert " + GetName() + " to a .NET Assembly", ProgressDialog.NO_PROGRESS_BAR, !ProgressDialog.HAS_PROGRESS_TEXT, ProgressDialog.FINAL); progress.ShowIfNotDone(); try { TypeLibConverter converter = new TypeLibConverter(); AssemblyBuilder asm = converter.ConvertTypeLibToAssembly (_iTypeLib, _assyInfo._fileName, // Can't do this because we can't strong name these //TypeLibImporterFlags.PrimaryInteropAssembly, 0, this, null, null, null, null); // For the problem associated with Q316653 //FixEventSinkHelpers(asm); asm.Save(_assyInfo._fileName); RecordTranslatedAssy(Assembly.LoadFrom(_assyInfo._url)); // Generate the ActiveX wrapper for the typelib, // if that's necessary AxImporter.Options impOptions = new AxImporter.Options(); impOptions.outputDirectory = dir; impOptions.outputName = _axAssyInfo._fileName; impOptions.references = this; impOptions.genSources = true; AxImporter axImport = new AxImporter(impOptions); try { // This converts the type library and generates the // wrapper for any ActiveX controls. It produces // a list of the assemblies that it created. If there // are no ActiveX controls this will throw. String wrapper = axImport. GenerateFromTypeLibrary(_iTypeLib); } catch (Exception ex) { if (ex.Message.StartsWith("Did not find a")) { TraceUtil.WriteLineInfo(this, "TypeLib - no controls found"); return; } TraceUtil.WriteLineWarning(this, "TypeLib - AxImporter error " + _assyInfo._url + " " + ex); throw new Exception("Error in AxImporter for: " + _assyInfo._url, ex); } foreach (String aname in axImport.GeneratedAssemblies) { TraceUtil.WriteLineInfo(this, "TypeLib - AX gen assy: " + aname); } foreach (String sname in axImport.GeneratedSources) { TraceUtil.WriteLineInfo(this, "TypeLib - AX gen source: " + sname); } RecordTranslatedAssy(Assembly.LoadFrom(_axAssyInfo._url)); TraceUtil.WriteLineIf(null, TraceLevel.Info, "TypeLib - conversion done: " + _assyInfo._url); } finally { progress.Finished(); } }
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo) { wrapperInfo = null; string typeLibName = this.ReferenceInfo.typeLibName; string wrapperPath = base.GetWrapperPath(); StrongNameKeyPair keyPair = null; byte[] publicKey = null; StrongNameUtils.GetStrongNameKey(base.Log, base.KeyFile, base.KeyContainer, out keyPair, out publicKey); if (base.DelaySign) { keyPair = null; if (publicKey == null) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "StrongNameUtils.NoPublicKeySpecified", new object[0]); throw new StrongNameException(); } } else { publicKey = null; if (keyPair == null) { if ((base.KeyContainer != null) && (base.KeyContainer.Length > 0)) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInContainer", new object[] { base.KeyContainer }); throw new StrongNameException(); } if ((base.KeyFile != null) && (base.KeyFile.Length > 0)) { base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInFile", new object[] { base.KeyFile }); throw new StrongNameException(); } } } bool flag = true; if (!base.ExecuteAsTool) { TypeLibConverter converter = new TypeLibConverter(); AssemblyBuilder assemblyBuilder = null; try { TypeLibImporterFlags flags = TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.SafeArrayAsSystemArray; if (this.noClassMembers) { flags |= TypeLibImporterFlags.PreventClassMembers; } string str4 = this.targetProcessorArchitecture; if (str4 != null) { if (!(str4 == "MSIL")) { if (str4 == "AMD64") { goto Label_0323; } if (str4 == "IA64") { goto Label_032F; } if (str4 == "x86") { goto Label_033B; } } else { flags |= TypeLibImporterFlags.ImportAsAgnostic; } } goto Label_0345; Label_0323: flags |= TypeLibImporterFlags.ImportAsX64; goto Label_0345; Label_032F: flags |= TypeLibImporterFlags.ImportAsItanium; goto Label_0345; Label_033B: flags |= TypeLibImporterFlags.ImportAsX86; Label_0345: assemblyBuilder = converter.ConvertTypeLibToAssembly(this.ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, typeLibName, null); } catch (COMException exception) { base.Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", new object[] { this.ItemName, exception.Message }); throw new ComReferenceResolutionException(exception); } if (!this.HasTemporaryWrapper) { this.WriteWrapperToDisk(assemblyBuilder, wrapperPath); } wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath; wrapperInfo.assembly = assemblyBuilder; return flag; } ResolveComReference.TlbImp imp = new ResolveComReference.TlbImp { BuildEngine = base.BuildEngine, EnvironmentVariables = base.EnvironmentVariables, DelaySign = base.DelaySign, KeyContainer = base.KeyContainer, KeyFile = base.KeyFile, OutputAssembly = wrapperPath, ToolPath = base.ToolPath, TypeLibName = this.ReferenceInfo.typeLibPath, AssemblyNamespace = typeLibName, AssemblyVersion = null, PreventClassMembers = this.noClassMembers, SafeArrayAsSystemArray = true, Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals }; if (this.referenceFiles != null) { string fullPathToOutput = Path.GetFullPath(wrapperPath); imp.ReferenceFiles = (from rf in this.referenceFiles where string.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0 select rf).ToArray<string>(); } string targetProcessorArchitecture = this.targetProcessorArchitecture; if (targetProcessorArchitecture != null) { if (!(targetProcessorArchitecture == "MSIL")) { if (targetProcessorArchitecture == "AMD64") { imp.Machine = "X64"; } else if (targetProcessorArchitecture == "IA64") { imp.Machine = "Itanium"; } else if (targetProcessorArchitecture == "x86") { imp.Machine = "X86"; } else { imp.Machine = this.targetProcessorArchitecture; } } else { imp.Machine = "Agnostic"; } } flag = imp.Execute(); wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath; return flag; }
public object ConvertAssemblyToTypeLib(Assembly assembly, string strTypeLibName, TypeLibExporterFlags flags, ITypeLibExporterNotifySink notifySink) { AssemblyBuilder assemblyBuilder = assembly as AssemblyBuilder; return(TypeLibConverter.nConvertAssemblyToTypeLib(!((Assembly)assemblyBuilder != (Assembly)null) ? assembly as RuntimeAssembly : (RuntimeAssembly)assemblyBuilder.InternalAssembly, strTypeLibName, flags, notifySink)); }
/// <summary> /// This method creates (and saves) a COM type library given a .NET /// assembly. /// </summary> public static UCOMITypeLib GenerateTLBFromAsm(string pathToAssmebly) { UCOMITypeLib managedITypeLib = null; ExporterNotiferSink sink = new ExporterNotiferSink(); // Load the assembly to convert. Assembly asm = Assembly.LoadFrom(pathToAssmebly); if (asm != null) { try { // Create name of type library based on .NET assembly. string tlbname = asm.GetName().Name + ".tlb"; // Convert the assembly. ITypeLibConverter TLBConv = new TypeLibConverter(); managedITypeLib = (UCOMITypeLib)TLBConv.ConvertAssemblyToTypeLib(asm, tlbname, 0, sink); try { UCOMICreateTypeLib managedICreateITypeLib = (UCOMICreateTypeLib)managedITypeLib; managedICreateITypeLib.SaveAllChanges(); } catch (COMException e) { throw new Exception("Error saving the typeLib : " + e.ErrorCode.ToString("x")); } } catch (Exception e) { throw new Exception("Error Converting assembly" + e); } } return managedITypeLib; }
public static string GenerateAssemblyFromTypeLib(UCOMITypeLib typLib) { // Need a sink for the TypeLibConverter. var sink = new ImporterNotiferSink(); #region Notes on Strong Name... /* Don't need a *.snk file if you are not building a primary interop asm. * Just send in nulls to the ConvertTypeLibToAssembly() method. * But if you have a valid *.snk file, you can use it as so: * * // Object representation of *.snk file. * FileStream fs = File.Open(@"D:\APress Books\InteropBook\MyTypeLibImporter\bin\Debug\theKey.snk", * FileMode.Open); * System.Reflection.StrongNameKeyPair keyPair = new StrongNameKeyPair(fs); */ #endregion // This class will covert COM type info into // .NET metadata and vice-versa. var tlc = new TypeLibConverter(); // Generate name of the assembly. var typeLibName = Marshal.GetTypeLibName(typLib); var asmName = "Interop." + typeLibName + ".dll"; // Now make the assembly based on COM type information. var asmBuilder = tlc.ConvertTypeLibToAssembly(typLib, asmName, TypeLibImporterFlags.SafeArrayAsSystemArray, sink, null, // If you have a strong name: keyPair.PublicKey, null, // If you have a strong name: keyPair typeLibName, // Namespace name is same as file name. null); // null = (typeLibMajor.typeLibMinor.0.0) // Save the assembly in the app directory! asmBuilder.Save(asmName); // return Assembly ref to call. return asmName; }
internal Assembly GetPrimaryInteropAssembly(System.Runtime.InteropServices.ComTypes.ITypeLib typeLib, TypeLibConverter tlbConverter) { Assembly assem = this.FindRCW(typeLib); if (assem == null) { IntPtr invalidIntPtr = System.Design.NativeMethods.InvalidIntPtr; typeLib.GetLibAttr(out invalidIntPtr); if (!(invalidIntPtr != System.Design.NativeMethods.InvalidIntPtr)) { return assem; } System.Runtime.InteropServices.TYPELIBATTR typelibattr = (System.Runtime.InteropServices.TYPELIBATTR) Marshal.PtrToStructure(invalidIntPtr, typeof(System.Runtime.InteropServices.TYPELIBATTR)); string asmName = null; string asmCodeBase = null; try { tlbConverter.GetPrimaryInteropAssembly(typelibattr.guid, typelibattr.wMajorVerNum, typelibattr.wMinorVerNum, typelibattr.lcid, out asmName, out asmCodeBase); if ((asmName != null) && (asmCodeBase == null)) { try { assem = Assembly.ReflectionOnlyLoad(asmName); asmCodeBase = this.GetLocalPath(assem.EscapedCodeBase); } catch (Exception) { } } else if (asmCodeBase != null) { asmCodeBase = this.GetLocalPath(asmCodeBase); assem = Assembly.ReflectionOnlyLoadFrom(asmCodeBase); } if (assem != null) { this.AddRCW(typeLib, assem); this.AddReferencedAssembly(asmCodeBase); } } finally { typeLib.ReleaseTLibAttr(invalidIntPtr); } } return assem; }
/// <summary> /// Helper method - exports a type library for an assembly. Returns true if succeeded. /// </summary> private bool ExportTypeLib(Assembly asm, string typeLibFileName) { _typeLibExportFailed = false; ITypeLib convertedTypeLib = null; try { // Create a converter and run the conversion ITypeLibConverter tlbConverter = new TypeLibConverter(); convertedTypeLib = (ITypeLib)tlbConverter.ConvertAssemblyToTypeLib(asm, typeLibFileName, 0, this); if (convertedTypeLib == null || _typeLibExportFailed) return false; // Persist the type library UCOMICreateITypeLib createTypeLib = (UCOMICreateITypeLib)convertedTypeLib; createTypeLib.SaveAllChanges(); } finally { if (convertedTypeLib != null) Marshal.ReleaseComObject((ITypeLib)convertedTypeLib); } return !_typeLibExportFailed; }
internal static object GenerateTypeLibrary(Assembly asm, string tlb, Report report) { object obj3; try { TypeLibConverter converter = new TypeLibConverter(); RegistrationExporterNotifySink notifySink = new RegistrationExporterNotifySink(tlb, report); object obj2 = converter.ConvertAssemblyToTypeLib(asm, tlb, TypeLibExporterFlags.OnlyReferenceRegistered, notifySink); ((ICreateTypeLib) obj2).SaveAllChanges(); RegisterTypeLibrary(tlb); obj3 = obj2; } catch (Exception exception) { if ((exception is NullReferenceException) || (exception is SEHException)) { throw; } throw new RegistrationException(Resource.FormatString("Reg_TypeLibGenErr", tlb, asm), exception); } return obj3; }
private bool ExportTypeLib(Assembly asm, string typeLibFileName) { this.typeLibExportFailed = false; ITypeLib o = null; try { ITypeLibConverter converter = new TypeLibConverter(); o = (ITypeLib) converter.ConvertAssemblyToTypeLib(asm, typeLibFileName, TypeLibExporterFlags.None, this); if ((o == null) || this.typeLibExportFailed) { return false; } ((UCOMICreateITypeLib) o).SaveAllChanges(); } finally { if (o != null) { Marshal.ReleaseComObject(o); } } return !this.typeLibExportFailed; }
private static Type GetInterfaceForTypeInfo(ICallerContext context, IntPtr typeInfoPtr) { Debug.Assert(typeInfoPtr != IntPtr.Zero); ComTypes.TYPEATTR typeInfoAttr = GetITypeInfoAttr(typeInfoPtr); Guid typeInfoGuid = typeInfoAttr.guid; // Have we seen the GUID before in a previously-loaded assembly? Type interfaceType = null; if (ComTypeCache.TryGetValue(typeInfoGuid, out interfaceType)) return interfaceType; // Try to find a registered Primary Interop Assembly (PIA) TypeLibConverter tlc = new TypeLibConverter(); string asmName = null, asmCodeBase = null; if (tlc.GetPrimaryInteropAssembly( typeInfoGuid, typeInfoAttr.wMajorVerNum, typeInfoAttr.wMinorVerNum, 0, out asmName, out asmCodeBase)) { try { Assembly interopAssembly = Assembly.Load(asmName); context.SystemState.TopPackage.LoadAssembly(context.SystemState, interopAssembly, true); Debug.Assert(ComTypeCache.ContainsKey(typeInfoGuid)); if (!ComTypeCache.ContainsKey(typeInfoGuid)) throw new COMException("TypeLib " + asmName + " does not contain COM interface + " + typeInfoGuid); return ComTypeCache[typeInfoGuid]; } catch (FileNotFoundException) { } } #if COM_GAC_CRAWLER Assembly interopAssembly = SearchForInteropAssemblyInGAC(typeInfoGuid, typeInfoAttr.wMajorVerNum, typeInfoAttr.wMinorVerNum); if (interopAssembly != null) { context.SystemState.TopPackage.LoadAssembly(context.SystemState, interopAssembly, false); Debug.Assert(ComTypeCache.ContainsKey(typeInfoGuid)); if (!ComTypeCache.ContainsKey(typeInfoGuid)) throw new COMException("TypeLib " + interopAssebly + " does not contain COM interface + " + typeInfoGuid); return ComTypeCache[typeInfoGuid]; } #endif // Try creating an Interop assembly on the fly return ConvertTypeLibToAssembly(context, typeInfoPtr, typeInfoGuid); }
public string Import(ProjectReference refinfo, Project project) { RegistryKey root = Registry.ClassesRoot; RegistryKey typelibsKey = root.OpenSubKey("TypeLib"); int index = refinfo.Reference.LastIndexOf("{"); if (index < 0) { return null; } RegistryKey typelibKey = typelibsKey.OpenSubKey(refinfo.Reference.Substring(index, refinfo.Reference.Length - index)); if (typelibKey == null) { return null; } string[] versions = typelibKey.GetSubKeyNames(); if (versions.Length <= 0) { return null; } // Use the last version string version = versions[versions.Length - 1]; RegistryKey versionKey = typelibKey.OpenSubKey(version); string tlbname = (string)versionKey.GetValue(null); string tlpath = GetTypelibPath(versionKey); if (tlpath == null) { return null; } string proxyfilename = "Interop." + Path.GetFileNameWithoutExtension(tlpath) + ".dll"; AbstractProjectConfiguration ac = (AbstractProjectConfiguration)project.ActiveConfiguration; string fullpath = Path.Combine(ac.OutputDirectory,proxyfilename); if (!File.Exists(fullpath)) { string saveCurrDir = Directory.GetCurrentDirectory(); if (!Directory.Exists(ac.OutputDirectory)) { Directory.CreateDirectory(ac.OutputDirectory); } Directory.SetCurrentDirectory(ac.OutputDirectory); if (!ImportTypelibUsingTlbImpCode(tlpath, ac.OutputDirectory, proxyfilename)) { MessageBox.Show("Cannot import type library using .Net SDK 1.0. Some, but not all type libraries can succesfully be imported without it. ", ".Net SDK 1.0 not present ?", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1); Object typeLib; LoadTypeLibEx(tlpath, RegKind.RegKind_None, out typeLib); if( typeLib == null ) { throw new System.Exception("LoadTypeLibEx failed."); } TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(); AssemblyBuilder asm = converter.ConvertTypeLibToAssembly( typeLib, proxyfilename, 0, eventHandler, null, null, Marshal.GetTypeLibName((UCOMITypeLib)typeLib), null ); asm.Save( proxyfilename ); } Directory.SetCurrentDirectory(saveCurrDir); } return fullpath; }
/* * Method: Resolve * * Gets the resolved assembly path for the typelib wrapper. */ internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp) { wrapperInfo = null; // Let NDP do the dirty work... TypeLibConverter converter = new TypeLibConverter(); string asmName, asmCodeBase; if (!converter.GetPrimaryInteropAssembly(ReferenceInfo.attr.guid, ReferenceInfo.attr.wMajorVerNum, ReferenceInfo.attr.wMinorVerNum, ReferenceInfo.attr.lcid, out asmName, out asmCodeBase)) { return false; } // let's try to load the assembly to determine its path and if it's there try { if (asmCodeBase != null && asmCodeBase.Length > 0) { Uri uri = new Uri(asmCodeBase); // make sure the PIA can be loaded Assembly assembly = Assembly.UnsafeLoadFrom(uri.LocalPath); // got here? then assembly must have been loaded successfully. wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = uri.LocalPath; wrapperInfo.assembly = assembly; // We need to remember the original assembly name of this PIA in case it gets redirected to a newer // version and other COM components use that name to reference the PIA. assembly.FullName wouldn't // work here since we'd get the redirected assembly name. wrapperInfo.originalPiaName = new AssemblyNameExtension(AssemblyName.GetAssemblyName(uri.LocalPath)); } else { Assembly assembly = Assembly.Load(asmName); // got here? then assembly must have been loaded successfully. wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = assembly.Location; wrapperInfo.assembly = assembly; // We need to remember the original assembly name of this PIA in case it gets redirected to a newer // version and other COM components use that name to reference the PIA. wrapperInfo.originalPiaName = new AssemblyNameExtension(asmName, true); } } catch (FileNotFoundException) { // This means that assembly file cannot be found. // We don't need to do anything here; wrapperInfo is not set // and we'll assume that the assembly doesn't exist. } catch (BadImageFormatException) { // Similar case as above, except we should additionally warn the user that the assembly file // is not really a valid assembly file. if (!Silent) { Log.LogWarningWithCodeFromResources("ResolveComReference.BadAssemblyImage", asmName); } } // have we found the wrapper? if (wrapperInfo != null) { return true; } return false; }
public void RegisterAsnetMmcAssembly(int doReg, string typeName, string binaryDirectory, out IntPtr exception) { exception = IntPtr.Zero; try { Assembly assembly = Assembly.GetAssembly(Type.GetType(typeName, true)); RegistrationServices services = new RegistrationServices(); if (doReg != 0) { if (!services.RegisterAssembly(assembly, AssemblyRegistrationFlags.None)) { exception = Marshal.StringToBSTR(new Exception(System.Web.SR.GetString("Unable_To_Register_Assembly", new object[] { assembly.FullName })).ToString()); } TypeLibConverter converter = new TypeLibConverter(); ConversionEventSink notifySink = new ConversionEventSink(); ((IRegisterCreateITypeLib) converter.ConvertAssemblyToTypeLib(assembly, Path.Combine(binaryDirectory, "AspNetMMCExt.tlb"), TypeLibExporterFlags.None, notifySink)).SaveAllChanges(); } else { if (!services.UnregisterAssembly(assembly)) { exception = Marshal.StringToBSTR(new Exception(System.Web.SR.GetString("Unable_To_UnRegister_Assembly", new object[] { assembly.FullName })).ToString()); } try { File.Delete(Path.Combine(binaryDirectory, "AspNetMMCExt.tlb")); } catch { } } } catch (Exception exception2) { exception = Marshal.StringToBSTR(exception2.ToString()); } }
private ProjectElement GetProjectElementBasedOnInputFromComponentSelectorData() { ProjectElement element = new ProjectElement(this.ProjectMgr, this.typeName, ProjectFileConstants.COMReference); // Set the basic information regarding this COM component element.SetMetadata(ProjectFileConstants.Guid, this.typeGuid.ToString("B")); element.SetMetadata(ProjectFileConstants.VersionMajor, this.majorVersionNumber); element.SetMetadata(ProjectFileConstants.VersionMinor, this.minorVersionNumber); element.SetMetadata(ProjectFileConstants.Lcid, this.lcid); element.SetMetadata(ProjectFileConstants.Isolated, false.ToString()); // See if a PIA exist for this component TypeLibConverter typelib = new TypeLibConverter(); string assemblyName; string assemblyCodeBase; if (typelib.GetPrimaryInteropAssembly(this.typeGuid, Int32.Parse(this.majorVersionNumber, CultureInfo.InvariantCulture), Int32.Parse(this.minorVersionNumber, CultureInfo.InvariantCulture), Int32.Parse(this.lcid, CultureInfo.InvariantCulture), out assemblyName, out assemblyCodeBase)) { element.SetMetadata(ProjectFileConstants.WrapperTool, WrapperToolAttributeValue.Primary.ToString().ToLowerInvariant()); } else { // MSBuild will have to generate an interop assembly element.SetMetadata(ProjectFileConstants.WrapperTool, WrapperToolAttributeValue.TlbImp.ToString().ToLowerInvariant()); element.SetMetadata(ProjectFileConstants.Private, true.ToString()); } return element; }
private Assembly loadComAssembly(string fileName) { string strPath = Path.GetDirectoryName(fileName) + "\\"; if (Path.GetDirectoryName(fileName).Length <= 0) strPath = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName) + @"\"; //if (Path.GetDirectoryName(fileName).Length <= 0) // strPath = string.Empty; string strSrcFileName = strPath + Path.GetFileName(fileName); if (!File.Exists(strSrcFileName)) return null; //RegComDll(m_mapComAssembly[assembly.FullName].ToString()); RegComDll(strSrcFileName); //每次自动注册com dll string strDstFileName = "interop." + Path.GetFileName(fileName); string strDetFullFileName = strPath + strDstFileName; string strNameSpace = Path.GetFileNameWithoutExtension(fileName);//文件名作为命名空间 //如果interop.dll的时间比dll时间早,则需要重新生成 bool bNeedGenrate = false; if (File.Exists(strDetFullFileName)) { DateTime dtInteropTime = File.GetLastWriteTime(strDetFullFileName); DateTime dtSrcTime = File.GetLastWriteTime(strSrcFileName); if (dtSrcTime >= dtInteropTime) bNeedGenrate = true; } else bNeedGenrate = true; if (bNeedGenrate) { Object typeLib; LoadTypeLibEx(fileName, RegKind.RegKind_None, out typeLib); if (typeLib == null) { //throw new Exception("载入失败!"); return null; } TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(); AssemblyBuilder ab = converter.ConvertTypeLibToAssembly(typeLib, strDetFullFileName, 0, eventHandler, null, null, strNameSpace, null); ab.Save(strDstFileName); } Assembly asm = Assembly.LoadFile(strDetFullFileName);//Application.StartupPath + @"\" + strDstFileName); //Type t = asm.GetType("interop.test.tcls1"); //old //Type t = asm.GetType("Prj2.tcls1"); //new, comdll=Prj2.dll if (asm != null) m_mapComAssembly[asm.FullName] = strSrcFileName; return asm; }