/// <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)
});
}
}