/// <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); }
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); }
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); }
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(); }
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()); }
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 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 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()); } }
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> /// 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); }
/// <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); }
public Object ResolveRef(Assembly asm) { try { // Resolve the reference here and return a correct type library. if (m_bVerbose) { Console.WriteLine("ConversionEventHandler.ResolveRef() [assembly : {0:S}]", asm.FullName); } string strAssemblyDirectory = Path.GetDirectoryName(asm.Location); string strAssemblyFileNameWithoutExtension = Path.GetFileNameWithoutExtension(asm.Location); string strTypeLibFullPath = strAssemblyDirectory + "\\" + strAssemblyFileNameWithoutExtension + ".tlb"; TypeLibConverter converter = new TypeLibConverter(); ConversionEventHandler eventHandler = new ConversionEventHandler(m_bVerbose); TypeLibExporterFlags flags; if (Platform.Is32Bits()) { flags = TypeLibExporterFlags.ExportAs32Bit; } else if (Platform.Is64Bits()) { flags = TypeLibExporterFlags.ExportAs64Bit; } else { Console.WriteLine(string.Format("Unknown bit-ness.")); return(null); } ICreateTypeLib create_typeLib = null; try { create_typeLib = (ICreateTypeLib)(converter.ConvertAssemblyToTypeLib (asm, strTypeLibFullPath, flags, eventHandler)); } catch (Exception ex) { Console.WriteLine(string.Format("Unable to convert assembly [{0:S}] into a Type Lib. Exception description : [{1:S}]", strAssemblyFileNameWithoutExtension, ex.Message)); return(null); } try { // SaveAllChanges() will create the TypeLib physical file // based on strTargetTypeLibFullPath. create_typeLib.SaveAllChanges(); } catch (Exception ex) { Console.WriteLine(string.Format("Unable to save TypeLib File [{0:S}] registered. Exception description : [{1:S}]", strTypeLibFullPath, ex.Message)); return(null); } ITypeLib typelib = (ITypeLib)create_typeLib; UInt32 uiRetTemp = WindowsAPI.RegisterTypeLib(typelib, strTypeLibFullPath, null); if (uiRetTemp == 0) { Console.WriteLine(string.Format("TypeLib File [{0:S}] registered.", strTypeLibFullPath)); } else { Console.WriteLine(string.Format("Failed to register TypeLib File [{0:S}]. Error code : [{1:D}]", strTypeLibFullPath, uiRetTemp)); return(null); } return(typelib); } catch (Exception ex) { Console.WriteLine(string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message)); return(null); } }
//static bool PerformAssemblyRegistration(string strTargetAssemblyFilePath, bool bCodeBase) //{ // try // { // RegistrationServices registration_services = new RegistrationServices(); // Assembly assembly = Assembly.LoadFrom(strTargetAssemblyFilePath); // AssemblyRegistrationFlags flags; // bool bRet = false; // if (bCodeBase == true) // { // flags = AssemblyRegistrationFlags.SetCodeBase; // } // else // { // flags = AssemblyRegistrationFlags.None; // } // bRet = registration_services.RegisterAssembly(assembly, flags); // if (bRet) // { // Console.WriteLine(string.Format("Successfully registered assembly [{0:S}].", strTargetAssemblyFilePath)); // if (m_bVerbose) // { // Type[] types = registration_services.GetRegistrableTypesInAssembly(assembly); // Console.WriteLine(string.Format("Types Registered :")); // foreach (Type type in types) // { // Console.WriteLine(string.Format("GUID : [{0:S}] [{1:S}].", type.GUID.ToString(), type.FullName)); // } // } // } // else // { // Console.WriteLine(string.Format("Failed to register assembly [{0:S}].", strTargetAssemblyFilePath)); // } // return bRet; // } // catch (Exception ex) // { // Console.WriteLine(string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message)); // return false; // } //} #endregion public ExecuteResult Run(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 (Platform.Is32Bits()) { flags = TypeLibExporterFlags.ExportAs32Bit; } else if (Platform.Is64Bits()) { flags = TypeLibExporterFlags.ExportAs64Bit; } else { //Console.WriteLine(string.Format("Unknown bit-ness.")); //return false; return(new ExecuteResult() { IsSuccess = false, ErrorMsg = "Unknown bit-ness." }); } 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 = WindowsAPI.RegisterTypeLib(typelib, strTargetTypeLibFullPath, null); if (uiRetTemp == 0) { //Console.WriteLine(string.Format("TypeLib File [{0:S}] registered.", strTargetTypeLibFullPath)); return(new ExecuteResult() { IsSuccess = true }); } else { //Console.WriteLine(string.Format("Failed to register TypeLib File [{0:S}]. Error code : [{1:D}]", // strTargetTypeLibFullPath, uiRetTemp)); //return false; return(new ExecuteResult() { IsSuccess = false, ErrorMsg = string.Format("Failed to register TypeLib File [{0:S}]. Error code : [{1:D}]", strTargetTypeLibFullPath, uiRetTemp) }); } } catch (Exception ex) { //Console.WriteLine(string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message)); //return false; return(new ExecuteResult() { IsSuccess = false, ErrorMsg = string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message) }); } }