/// <summary> /// This is an helper method to convert the VSCOMPONENTSELECTORDATA recieved by the /// implementer of IVsComponentUser into a ProjectElement that can be used to create /// an instance of this class. /// This should not be called for project reference or reference to managed assemblies. /// </summary> /// <returns>ProjectElement corresponding to the COM component passed in</returns> 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().ToLower()); } else { // MSBuild will have to generate an interop assembly element.SetMetadata(ProjectFileConstants.WrapperTool, WrapperToolAttributeValue.TlbImp.ToString().ToLower()); element.SetMetadata(ProjectFileConstants.Private, true.ToString()); } return(element); }
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 Convert(ITypeLib tl) { tl.GetLibAttr(out IntPtr ipta); var ta = *(_TYPELIBATTR *)ipta; tl.ReleaseTLibAttr(ipta); var hash = Fnv1((byte *)&ta, sizeof(_TYPELIBATTR) - 2).ToString("x"); tl.GetDocumentation(-1, out var tlName, out var tlDescription, out var _, out var _); var fileName = $"{tlName} {ta.wMajorVerNum}.{ta.wMinorVerNum} #{hash}.dll"; var netPath = saveDir + fileName; if (!s_converted.TryGetValue(fileName, out var asm) || !File.Exists(netPath)) { Print($"Converted: {tlName} ({tlDescription}) to \"{fileName}\"."); var converter = new TypeLibConverter(); asm = converter.ConvertTypeLibToAssembly(tl, netPath, TypeLibImporterFlags.ReflectionOnlyLoading | TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.UnsafeInterfaces, this, null, null, tlName, null); asm.Save(fileName); s_converted[fileName] = asm; } return(asm); }
private static ITypeLib DoExportAndRegister(Assembly asm, string strTypeLibName) { ITypeLibConverter typeLibConverter = new TypeLibConverter(); ExporterCallback notifySink = new ExporterCallback(); //RegAsm'ом используется только флаг OnlyReferenceRegistered если установлен registered //поскольку у нас это нигде не использовалось, параметр опущен ITypeLib typeLib = (ITypeLib)typeLibConverter.ConvertAssemblyToTypeLib(asm, strTypeLibName, TypeLibExporterFlags.None, notifySink); ICreateITypeLib createITypeLib = null; try { createITypeLib = (ICreateITypeLib)typeLib; createITypeLib.SaveAllChanges(); } catch { throw; } finally { Marshal.FinalReleaseComObject(createITypeLib); } return(typeLib); }
internal static UCOMITypeLib DoExportAndRegister(Assembly asm, String strTypeLibName) { // Create the TypeLibConverter. ITypeLibConverter TLBConv = new TypeLibConverter(); // Convert the assembly. ExporterCallback callback = new ExporterCallback(); UCOMITypeLib Tlb = (UCOMITypeLib)TLBConv.ConvertAssemblyToTypeLib(asm, strTypeLibName, s_Options.m_Flags, callback); // Persist the typelib. try { UCOMICreateITypeLib CreateTlb = (UCOMICreateITypeLib)Tlb; CreateTlb.SaveAllChanges(); } catch (Exception e) { ThrowAppException(Resource.FormatString("Err_TypelibSaveFailed"), e); } // Register the typelib. try { RegisterTypeLib(Tlb, strTypeLibName, Path.GetDirectoryName(strTypeLibName)); } catch (Exception e) { ThrowAppException(Resource.FormatString("Err_TypelibRegisterFailed"), e); } return(Tlb); }
private Assembly ConvertTypeLib(NativeMethods.ITypeLib typeLib, string assemblyPath, string assemblyFile, string assemblyNamespace, Version assemblyVersion, TypeLibImporterFlags flags, byte[] publicKey, StrongNameKeyPair keyPair) { try { this.RaiseMessage(string.Format("Converting '{0}'.", GetTypeLibName(typeLib))); TypeLibConverter converter = new TypeLibConverter(); AssemblyBuilder assemblyBuilder = converter.ConvertTypeLibToAssembly(typeLib, Path.Combine(assemblyPath, assemblyFile), flags, this, publicKey, keyPair, assemblyNamespace, assemblyVersion); this.RaiseMessage(string.Format("Saving '{0}'.", assemblyFile)); string currentDirectory = Environment.CurrentDirectory; Environment.CurrentDirectory = assemblyPath; assemblyBuilder.Save(assemblyFile); Environment.CurrentDirectory = currentDirectory; return(assemblyBuilder); } catch (COMException exception) { this.RaiseError(exception.Message); } return(null); }
/// <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); }
public object ResolveRef(Assembly assembly) { var converter = new TypeLibConverter(); var lib = converter.ConvertAssemblyToTypeLib(assembly, assembly.GetName().Name, TypeLibExporterFlags.None, this); return(lib); }
internal static ITypeLib GenerateTypeLib(Assembly asm, ref string strTlbName) { ITypeLibConverter converter = new TypeLibConverter(); ExporterCallback notifySink = new ExporterCallback(); ITypeLib lib = (ITypeLib)converter.ConvertAssemblyToTypeLib(asm, strTlbName, TypeLibExporterFlags.None, notifySink); ((ICreateITypeLib)lib).SaveAllChanges(); return(lib); }
internal Assembly GetPrimaryInteropAssembly(UCOMITypeLib typeLib, TypeLibConverter tlbConverter) { Assembly pia = FindRCW(typeLib); if (pia != null) { return(pia); } IntPtr typeLibAttr = NativeMethods.InvalidIntPtr; typeLib.GetLibAttr(out typeLibAttr); if (typeLibAttr != NativeMethods.InvalidIntPtr) { // Marshal the returned int as a TLibAttr structure // TYPELIBATTR tlbAttr = (TYPELIBATTR)Marshal.PtrToStructure(typeLibAttr, typeof(TYPELIBATTR)); string asmName = null; string asmCodeBase = null; try { tlbConverter.GetPrimaryInteropAssembly(tlbAttr.guid, tlbAttr.wMajorVerNum, tlbAttr.wMinorVerNum, tlbAttr.lcid, out asmName, out asmCodeBase); if (asmName != null && asmCodeBase == null) { // We found the PIA in the GAC... we need a codebase for this // so we can pass this to the compiler. // try { pia = Assembly.Load(asmName); asmCodeBase = GetLocalPath(pia.EscapedCodeBase); } catch (Exception e) { Debug.WriteLineIf(AxWrapperGen.AxWrapper.Enabled, "Could load assembly from GAC " + asmName + " Exception " + e.Message); } } else if (asmCodeBase != null) { asmCodeBase = GetLocalPath(asmCodeBase); pia = Assembly.LoadFrom(asmCodeBase); } if (pia != null) { AddRCW(typeLib, pia); AddReferencedAssembly(asmCodeBase); } } finally { typeLib.ReleaseTLibAttr(typeLibAttr); } } return(pia); }
static bool PerformTypeLibCreationAndRegistration(string strTargetAssemblyFilePath) { try { string strTargetAssemblyDirectory = Path.GetDirectoryName(strTargetAssemblyFilePath); string strTargetAssemblyFileNameWithoutExtension = Path.GetFileNameWithoutExtension(strTargetAssemblyFilePath); string strTargetTypeLibFullPath = strTargetAssemblyDirectory + "\\" + strTargetAssemblyFileNameWithoutExtension + ".tlb"; TypeLibConverter converter = new TypeLibConverter(); Assembly assembly = Assembly.LoadFrom(strTargetAssemblyFilePath); TypeLibExporterFlags flags; if (Is32Bits()) { flags = TypeLibExporterFlags.ExportAs32Bit; } else if (Is64Bits()) { flags = TypeLibExporterFlags.ExportAs64Bit; } else { Console.WriteLine(string.Format("Unknown bit-ness.")); return(false); } ICreateTypeLib create_typeLib = (ICreateTypeLib)(converter.ConvertAssemblyToTypeLib (assembly, strTargetTypeLibFullPath, flags, m_pITypeLibExporterNotifySink)); // SaveAllChanges() will create the TypeLib physical file // based on strTargetTypeLibFullPath. create_typeLib.SaveAllChanges(); ITypeLib typelib = (ITypeLib)create_typeLib; UInt32 uiRetTemp = RegisterTypeLib(typelib, strTargetTypeLibFullPath, null); if (uiRetTemp == 0) { Console.WriteLine(string.Format("TypeLib File [{0:S}] registered.", strTargetTypeLibFullPath)); } else { Console.WriteLine(string.Format("Failed to register TypeLib File [{0:S}]. Error code : [{1:D}]", strTargetTypeLibFullPath, uiRetTemp)); return(false); } return(true); } catch (Exception ex) { Console.WriteLine(string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message)); return(false); } }
public static void Main() { Assembly asm = Assembly.LoadFrom("MyAssembly.dll"); TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(); UCOMICreateITypeLib typeLib = (UCOMICreateITypeLib)converter.ConvertAssemblyToTypeLib(asm, "MyTypeLib.dll", 0, eventHandler); typeLib.SaveAllChanges(); }
/// <summary> /// Try to search the GAC for an assembly that seems to match the given type GUID /// </summary> private static Assembly SearchForInteropAssembly(Guid typeInfoGuid) { Assembly assembly = null; try { string typelibPath = @"Interface\{" + typeInfoGuid + @"}\TypeLib"; RegistryKey typelibKey = Registry.ClassesRoot.OpenSubKey(typelibPath); if (typelibKey == null) { return(null); } // Read HKCR\Interface\{<typeInfoGuid>}\TypeLib\(Default)" Guid typelibGuid = new Guid(typelibKey.GetValue(null, null) as string); // Read HKCR\Interface\{<typeInfoGuid>}\TypeLib\Version" string typelibVersion = typelibKey.GetValue("Version") as String; if (typelibVersion == null) { return(null); } string[] versionSplit = typelibVersion.Split('.'); int major = int.Parse(versionSplit[0]); int minor = int.Parse(versionSplit[1]); // Try using TypeLibConverter TypeLibConverter tlc = new TypeLibConverter(); string asmName = null, asmCodeBase = null; tlc.GetPrimaryInteropAssembly(typelibGuid, major, minor, 0, out asmName, out asmCodeBase); if (asmName != null) { assembly = Assembly.Load(asmName); } if (assembly != null) { return(assembly); } // Next, try looking up the GAC assembly = SearchForInteropAssemblyInGAC(typeInfoGuid, major, minor); } catch (Exception e) { if (IronPython.Hosting.PythonEngine.options.EngineDebug) { throw e; } } return(assembly); }
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); }
internal static UCOMITypeLib GenerateTypeLib(Assembly asm, ref String strTlbName) { ITypeLibConverter tlbConv = new TypeLibConverter(); ExporterCallback callback = new ExporterCallback(); UCOMITypeLib tlb = (UCOMITypeLib)tlbConv.ConvertAssemblyToTypeLib(asm, strTlbName, 0, callback); // Persist the typelib. UCOMICreateITypeLib createTlb = (UCOMICreateITypeLib)tlb; createTlb.SaveAllChanges(); return(tlb); }
public string GenerateIdl(Assembly assembly) { var converter = new TypeLibConverter(); var sink = new TypeLibExporterNotifySink(); var lib = (ITypeLib)converter.ConvertAssemblyToTypeLib(assembly, assembly.GetName().Name, TypeLibExporterFlags.None, sink); var formatter = new PlainIDLFormatter(); var owLib = new OWTypeLib(lib); owLib.Listeners.Add(new IdlListener()); owLib.BuildIDLInto(formatter); return(formatter.ToString()); }
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"); }
/// <summary> /// Gets an assembly used to interop with the objects defined in the type /// library. /// </summary> /// <param name="typeLibraryName"> /// Name of the type library such as SHDocVw.dll /// </param> /// <returns> /// Returns the assembly if found/created otherwise null. /// </returns> public static Assembly GetAssemblyForTypeLib(string typeLibraryName) { object typeLib = null; LoadTypeLibEx(typeLibraryName, RegKind.RegKind_None, out typeLib); if (typeLib == null) { return(null); } TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(); AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(typeLib, "Interop." + typeLibraryName, 0, eventHandler, null, null, null, null); return(asm); }
public static void Main() { Object typeLib; LoadTypeLibEx("SHDocVw.dll", RegKind.RegKind_None, out typeLib); if (typeLib == null) { Console.WriteLine("LoadTypeLibEx failed."); return; } TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(); AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(typeLib, "ExplorerLib.dll", 0, eventHandler, null, null, null, null); asm.Save("ExplorerLib.dll"); }
public static string GenerateAssemblyFromTypeLib(UCOMITypeLib typLib) { // Need a sink for the TypeLibConverter. ImporterNotiferSink 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. TypeLibConverter tlc = new TypeLibConverter(); // Generate name of the assembly. string typeLibName = Marshal.GetTypeLibName(typLib); string asmName = "interop." + typeLibName + ".dll"; // Now make the assembly based on COM type information. AssemblyBuilder asmBuilder = tlc.ConvertTypeLibToAssembly((UCOMITypeLib)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 override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp) { string str; string str2; wrapperInfo = null; TypeLibConverter converter = new TypeLibConverter(); if (!converter.GetPrimaryInteropAssembly(this.ReferenceInfo.attr.guid, this.ReferenceInfo.attr.wMajorVerNum, this.ReferenceInfo.attr.wMinorVerNum, this.ReferenceInfo.attr.lcid, out str, out str2)) { return(false); } try { if ((str2 != null) && (str2.Length > 0)) { Uri uri = new Uri(str2); Assembly assembly = Assembly.UnsafeLoadFrom(uri.LocalPath); wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = uri.LocalPath; wrapperInfo.assembly = assembly; wrapperInfo.originalPiaName = new AssemblyNameExtension(AssemblyName.GetAssemblyName(uri.LocalPath)); } else { Assembly assembly2 = Assembly.Load(str); wrapperInfo = new ComReferenceWrapperInfo(); wrapperInfo.path = assembly2.Location; wrapperInfo.assembly = assembly2; wrapperInfo.originalPiaName = new AssemblyNameExtension(str, true); } } catch (FileNotFoundException) { } catch (BadImageFormatException) { base.Log.LogWarningWithCodeFromResources("ResolveComReference.BadAssemblyImage", new object[] { str }); } return(wrapperInfo != null); }
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()); } }
public Assembly Import(string InteropFileName, string path, string name, TlbImp parent) { ITypeLib typeLib; AsmPath = Path.GetDirectoryName(InteropFileName); LoadTypeLibEx(path, RegKind.RegKind_None, out typeLib); if (typeLib == null) { return(null); } TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(parent == null?this:parent); AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(typeLib, Path.GetFileName(InteropFileName), TypeLibImporterFlags.None, eventHandler, null, null, name, null); string outputFolder = Path.GetDirectoryName(InteropFileName); string interopFName = Path.Combine(outputFolder, String.Concat("Interop.", name, ".dll")); asm.Save(Path.GetFileName(interopFName)); Marshal.ReleaseComObject(typeLib); return(asm as Assembly); }
public static UCOMITypeLib DoExport(Assembly asm, String strTypeLibName) { // Create the TypeLibConverter. ITypeLibConverter TLBConv = new TypeLibConverter(); // Convert the assembly. ExporterCallback callback = new ExporterCallback(); UCOMITypeLib Tlb = (UCOMITypeLib)TLBConv.ConvertAssemblyToTypeLib(asm, strTypeLibName, 0, callback); // Persist the typelib. try { UCOMICreateITypeLib CreateTlb = (UCOMICreateITypeLib)Tlb; CreateTlb.SaveAllChanges(); } catch (Exception e) { ThrowAppException(Resource.FormatString("Err_ErrorSavingTypeLib"), e); } return(Tlb); }
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); }
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()); } }
public 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; lock (m_typelibsname) { m_typelibsname[a.FullName] = a; } RegisterTypeInterfaces(a); return(a); } }
/// <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); }
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); }
/// <summary> /// Exports the type library of the given assembly to the given path. /// Will recursively export and register TLBs of referenced assemblies /// as needed. /// </summary> /// <param name="assembly"><see cref="System.Reflection.Assembly"/> /// to export. Cannot be <c>null</c>.</param> /// <param name="typeLibName">Full path to type library to export. /// Cannot be <c>null</c>, empty or equal to the path of /// <paramref name="assembly"/>.</param> /// <returns>Type library reference.</returns> /// <exception cref="CLRegAsmException">Failed to save type library /// <paramref name="typeLibName"/> to disk.</exception> private ITypeLib ExportTypeLibrary(Assembly assembly, string typeLibName) { Debug.Assert(assembly != null); Debug.Assert(!String.IsNullOrEmpty(typeLibName)); Debug.Assert(String.Compare(AssemblyTools.GetAssemblyPath(assembly), typeLibName, true) != 0); // Create type lib converter and export the type lib. // This will call us back recursively if referenced assemblies' // type libs need to be exported and registered also. TypeLibConverter tlbConverter = new TypeLibConverter(); ITypeLib tlb = (ITypeLib)tlbConverter.ConvertAssemblyToTypeLib(assembly, typeLibName, flags, new ConverterCallback(this)); // Save all changes, which will save the data to disk. try { (tlb as ICreateTypeLib).SaveAllChanges(); } catch (Exception e) { throw new CLRegAsmException(String.Format("Could not save type library \"{0}\" to disk", typeLibName), e); } Debug.Assert(tlb != null); return(tlb); }
private bool InitializeTDxInputWrapper() { bool bReturn = false; Object typeLib = null; try { //get Com-Server from Registry RegistryKey regKey = Registry.LocalMachine.OpenSubKey("Software\\Classes\\CLSID\\{82C5AB54-C92C-4D52-AAC5-27E25E22604C}\\InprocServer32", false); if (regKey != null) { string strTypeLibName = regKey.GetValue("").ToString(); regKey.Close(); LoadTypeLibEx(strTypeLibName , RegKind.RegKind_None , out typeLib); } else { // --- No registry set, there must be no 3DConnexion --- return false; } } catch (Exception) { } if (typeLib == null) { Console.WriteLine("LoadTypeLibEx failed."); throw new NotSupportedException("Com- Server not found."); } TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(); m_Assembly = converter.ConvertTypeLibToAssembly(typeLib, "Import3DxInputAssembly.dll", 0, eventHandler, null, null, null, null); //Type[] ExpTypes = m_Assembly.GetTypes(); try { m_OSimpleDevice = m_Assembly.CreateInstance("Import3DxInputAssembly.DeviceClass"); } catch { //int nTest; } if (m_OSimpleDevice != null) { Type TheType = m_OSimpleDevice.GetType(); //MethodInfo[] TheMethods = TheType.GetMethods(); MethodInfo method = TheType.GetMethod("get_Sensor"); m_OSensor = method.Invoke(m_OSimpleDevice, null); // kein Parameter method = TheType.GetMethod("get_Keyboard"); m_OKeyboard = method.Invoke(m_OSimpleDevice, null); TheType = m_OKeyboard.GetType(); //TheMethods = TheType.GetMethods(); bReturn = true; } return bReturn; }