[转]Programmatically Register Assemblies in C#.
1. Introduction.
1.1 After publishing Programmatically Register COM Dlls in
C# back in 2011, I received a number of requests for
advise on how to register managed assemblies as COM servers.
1.2 In this blog, I will present the reader with a
sample C# program that will perform such registration.
1.3 The sample assembly COM-registration source codes
can be used to target 32-bit and 64-bit assemblies.
1.4 I will also provide 2 sets of programs (one 32-bit
and the other 64-bit) for testing.
2. The Assembly Registration
Program.
2.1 The full source codes for this article can be found
here in CodePlex.
2.1 Shown below is a partial listing of the source codes
for the program :
// Program.cs
// Main control source codes.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Collections;
using System.Collections.Specialized;
using System.Reflection;
using System.IO; namespace RegisterAssembly
{ // The managed definition of the ICreateTypeLib interface. [ComImport()] [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] [Guid("00020406-0000-0000-C000-000000000046")] public interface ICreateTypeLib { IntPtr CreateTypeInfo(string szName, System.Runtime.InteropServices.ComTypes.TYPEKIND tkind); void SetName(string szName); void SetVersion(short wMajorVerNum, short wMinorVerNum); void SetGuid(ref Guid guid); void SetDocString(string szDoc); void SetHelpFileName(string szHelpFileName); void SetHelpContext(int dwHelpContext); void SetLcid(int lcid); void SetLibFlags(uint uLibFlags); void SaveAllChanges(); } partial class Program { // Command line options. const string TYPELIB = "TYPELIB"; const string CODE_BASE = "CODE_BASE"; const string VERBOSE = "VERBOSE"; const string UNREGISTER = "UNREGISTER"; // Windows API to register a COM type library. [DllImport("Oleaut32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] public extern static UInt32 RegisterTypeLib(ITypeLib tlib, string szFullPath, string szHelpDir); [DllImport("Oleaut32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] public extern static UInt32 UnRegisterTypeLib(ref Guid libID, UInt16 wVerMajor, UInt16 wVerMinor,
int lcid, System.Runtime.InteropServices.ComTypes.SYSKIND syskind); public static bool Is32Bits() { if (IntPtr.Size == 4) { // 32-bit return true; } return false; } public static bool Is64Bits() { if (IntPtr.Size == 8) { // 64-bit return true; } return false; } static void DisplayUsage() { Console.WriteLine("Usage :"); Console.WriteLine("RegisterAssembly [CODE_BASE] [CREATE_TYPELIB] [VERBOSE] [UNREGISTER] <path to managed assembly file>"); Console.WriteLine("where CODE_BASE, CREATE_TYPELIB, VERBOSE, UNREGISTER are optional parameters"); Console.WriteLine("Note that the UNREGISTER parameter cannot be used with the CODE_BASE or the CREATE_TYPELIB parameters."); Console.WriteLine(); } static bool ProcessArguments(string[] args) { const int iCountMinimumParametersRequired = 1; if (args == null) { Console.WriteLine(string.Format("Invalid number of parameters.")); return false; } if (args.Length < iCountMinimumParametersRequired) { Console.WriteLine(string.Format("Invalid number of parameters (minimum parameters : [{0:D}]).", iCountMinimumParametersRequired)); return false; } for (int i = 0; i < args.Length; i++) { switch (args[i].Trim()) { case TYPELIB: { m_bTypeLib = true; break; } case CODE_BASE: { m_bCodeBase = true; break; } case VERBOSE: { m_bVerbose = true; break; } case UNREGISTER: { m_bUnregister = true; break; } default: { if (string.IsNullOrEmpty(m_strTargetAssemblyFilePath)) { m_strTargetAssemblyFilePath = args[i].Trim(); break; } else { Console.WriteLine(string.Format("Invalid parameter : [{0:S}].", args[i])); return false; } } } } if (m_bUnregister) { if (m_bCodeBase) { Console.WriteLine(string.Format("UNEGISTER flag cannot be used with the CODE_BASE flag.")); return false; } } return true; } static bool DoWork() { try { if (m_bVerbose) { Console.WriteLine(string.Format("Target Assembly File : [{0:S}].", m_strTargetAssemblyFilePath)); } if (m_bUnregister) { if (PerformAssemblyUnregistration(m_strTargetAssemblyFilePath) == false) { return false; } if (m_bTypeLib == true) { return PerformTypeLibUnRegistration(m_strTargetAssemblyFilePath); } else { return true; } } else { if (PerformAssemblyRegistration(m_strTargetAssemblyFilePath, m_bCodeBase) == false) { return false; } if (m_bTypeLib == true) { return PerformTypeLibCreationAndRegistration(m_strTargetAssemblyFilePath); } else { return true; } } } catch (Exception ex) { Console.WriteLine(string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message)); return false; } } static void Main(string[] args) { if (ProcessArguments(args) == false) { DisplayUsage(); return; } if (ReadConfigSettings() == false) { return; } DoWork(); } public static bool m_bVerbose = false; private static bool m_bTypeLib = false; private static bool m_bCodeBase = false; private static bool m_bUnregister = false; private static string m_strTargetAssemblyFilePath = null; private static ITypeLibExporterNotifySink m_pITypeLibExporterNotifySink = null; }
}
- The program begins by inspecting its arguments (in
ProcessArguments()). - Member variables are set according to the
arguments. - If there is any error discovered inside
ProcessArguments(), the program will display instructions on the program
arguments and then the program will stop. - Next, via ReadConfigSettings(), the configuration file
of the program is examined to check for the type to be created for the
ITypeLibExporterNotifySink object (more on this later). - If ReadConfigSettings() encounters an error, a false
will be returned and the program will end. - Otherwise,the DoWork() method will be called to perform
the registration task.
The sections that follow will provide more details on
the running process of the program.
2. The Arguments to the Program.
2.1 The program takes at minimum one parameter (i.e. the
path to the assembly to be registered).
2.2 VERBOSE , UNREGISTER, CODE_BASE and TYPELIB are
optional parameters which can be used in combination.
2.3 The VERBOSE option indicates to the program to
display additional useful information at runtime.
2.4 Unless the UNREGISTER parameter is used, it is
assumed that the program is to perform assembly un-registration.
2.3 The CODE_BASE parameter indicates that the assembly
registration includes the assembly’s full path in the registry.
- Note that this option cannot be used together with the
UNREGISTER argument.
2.4 The presence of the TYPELIB argument indicates the
following :
- For assembly registration, an associated type library
will be created and registered. - For assembly un-registration, the type library
associated with the assembly will be un-registered.
3. PerformAssemblyRegistration().
3.1 The source codes for the
PerformAssemblyRegistration() method is found in AssemblyRegistration.cs :
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; } }
3.2 PerformAssemblyRegistration() takes 2 parameters
:
- A path to the assembly file to be
registered. - A boolean flag that indicates whether the path to the
assembly (i.e. the code base) is to be written in the
registry.
The assembly registration work is done via
the RegistrationServices class, specifically,
the RegisterAssembly() method.
3.3 If all went well with the assembly registration
process, the types which have been registered will be displayed if the “VERBOSE”
flag was used.
3.4 If the registration process was successful,
PerformAssemblyRegistration() will return true.
3.5 If the registration process failed, either because
the RegisterAssembly() returned false or because an exception was
thrown, PerformAssemblyRegistration() will return false and the program
will stop.
4.
PerformTypeLibCreationAndRegistration().
4.1 The source codes for the
PerformTypeLibCreationAndRegistration() method is also listed
in AssemblyRegistration.cs :
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; } }
4.2 This method will perform the creation of a COM type
library from the target assembly. After the type library has been created, it
will be registered.
4.3 The TypeLibConverter class is used to perform
the type library creation. Specifically the ConvertAssemblyToTypeLib() method.
4.4 An important part of calling
ConvertAssemblyToTypeLib() has to do with the bit-ness of the type library to be
created for the assembly :
- If the RegisterAssembly program is compiled as a 32-bit
program, it can only register a 32-bit assembly. - Hence the TypeLibExporterFlags flag parameter for
ConvertAssemblyToTypeLib() must be set to
TypeLibExporterFlags.ExportAs32Bit. - In the same way, if it is compiled as a 64-bit program,
TypeLibExporterFlags.ExportAs64Bit must be used.
4.5 A simple but effective way of determining whether
RegisterAssembly is running as a 32-bit or 64-bit program is via testing the
size of IntPtr as can be seen in the Is32Bits() and Is64Bits()
methods.
4.6 Another point to note is the
ITypeLibExporterNotifySink parameter for ConvertAssemblyToTypeLib().
4.7 This parameter must be supplied with an instance of
a class that implements the ITypeLibExporterNotifySink interface. This object
can be important in some circumstances. This interface contains 2 methods
:
- The ReportEvent() method is purely for information
purposes only. - The ResolveRef() method requires some explanation (see
below).
4.8 In a nutshell, the ResolveRef() method will be
called when the assembly to be registered references a COM Type that is exported
from another assembly instead of from an unmanaged type library. E.g. the COM
type being defined as a managed type and is exposed to COM via
COMVisibleAttribute. More will be explained in the next section
(ConversionEventHandler).
4.9 When ResolveRef() is called, the referenced assembly
is passed as parameter and ResolveRef() is expected to return an object which,
at minimum, implements the ITypeLib interface. See ITypeLibExporterNotifySink.ResolveRef Method
(Assembly).
4.10 I will be writing separate blogs in the future
expounding ITypeLibExporterNotifySink implementations in greater detail. For the
current blog and source codes, a default adequate one (ConversionEventHandler)
is supplied and used (see next section).
4.11 The output of the ConvertAssemblyToTypeLib() method
will be an object that implements the ICreateTypeLib and the ITypeLib interfaces
:
- We then cast the returned object to ICreateTypeLib and
call the SaveAllChanges() method. - This will save the information in the ITypeLib object
into an external file. - The type library file will be saved in the same
directory and using the same name as the target assembly. - We then cast the returned object into the ITypeLib
interface and register the saved type library by calling the RegisterTypeLib()
API.
5. The ConversionEventHandler
class.
5.1 The source codes for the ConversionEventHandler
class is listed in ConversionEventHandler.cs :
// ConversionEventHandler.cs
// Source codes for handling assembly reference resolution.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Collections;
using System.Collections.Specialized;
using System.Reflection;
using System.IO; namespace RegisterAssembly
{ public class ConversionEventHandler : ITypeLibExporterNotifySink { public ConversionEventHandler(bool bVerbose) { m_bVerbose = bVerbose; } public void ReportEvent(ExporterEventKind eventKind, int eventCode, string eventMsg) { // Handle the warning event here. if (m_bVerbose) { Console.WriteLine("ConversionEventHandler.ReportEvent() [eventKind : {0:S}] [eventCode : {1:D}] [eventMsg : {2:S}]",
eventKind.ToString(), eventCode, eventMsg); } } 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 (Program.Is32Bits()) { flags = TypeLibExporterFlags.ExportAs32Bit; } else if (Program.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 = Program.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; } } private bool m_bVerbose = false; }
}
The following are the pertinent points concerning this
class (some points have been mentioned previously and are repeated) :
- It implements the ITypeLibExporterNotifySink
interface. - As mentioned previously, the ReportEvent() method is not
very important and it serves only to provide information during the conversion
process. - The implementation for ResolveRef(), however, is not
trivial. - It will be called when the following conditions hold
:- If the assembly to be registered references COM-visible
types from another assembly. - The assembly which contains the COM-visible types has
not been registered. - A type library for the assembly which contains the
COM-visible types has not been created nor registered.
- If the assembly to be registered references COM-visible
- Hence if the target assembly does not reference
COM-visible types from other assemblies, ResolveRef() will not be
invoked. - Also, if the target assembly does reference COM-visible
types from another assembly but that assembly has been registered and its type
library created and registered, then likewise, ResolveRef() will not be
invoked. - If a type library is to be created, it is expected to be
saved to disk and then registered.
5.3 The ConversionEventHandler.ResolveRef() method is
very similar to the PerformTypeLibCreationAndRegistration() method in that the
TypeLibConverter.ConvertAssemblyToTypeLib() method is used to process an
assembly :
- In the case of ResolveRef(), the assembly to be
processed is a reference assembly which contain COM-visible types. - In the case of the ConversionEventHandler class, its
ResolveRef() method uses TypeLibConverter.ConvertAssemblyToTypeLib() to generate
an ITypeLib object. - This ITypeLib object is then saved to disk and
registered. - This ITypeLib object is then returned.
Other implementations of ITypeLibExporterNotifySink may
opt to search for an existing type library file, dynamically load it into
memory, extract an ITypeLib object and then return it.
5.4 Note
well that referenced assemblies which contain
COM-visible types should be pre-registered (either via RegisterAssembly.exe or RegAsm.exe).
Likewise, their associated type libraries should have been generated and
registered before hand. Generally speaking a call to ResolveRef() can and should
be avoided if possible.
6.
PerformAssemblyUnregistration().
6.1 If the RegisterAssembly program is required to
unregister an assembly, PerformAssemblyUnregistration() will be used. The
listing for this method can be found in AssemblyUnregistration.cs :
static bool PerformAssemblyUnregistration(string strTargetAssemblyFilePath) { try { RegistrationServices registration_services = new RegistrationServices(); Assembly assembly = Assembly.LoadFrom(strTargetAssemblyFilePath); bool bRet = false; bRet = registration_services.UnregisterAssembly(assembly); if (bRet) { Console.WriteLine(string.Format("Successfully unregistered assembly [{0:S}].", strTargetAssemblyFilePath)); } else { Console.WriteLine(string.Format("Failed to unregister assembly [{0:S}].", strTargetAssemblyFilePath)); } return bRet; } catch (Exception ex) { Console.WriteLine(string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message)); return false; } }
6.2 It is simple. Just a call to the
RegistrationServices.UnregisterAssembly() will do.
7. PerformTypeLibUnRegistration().
7.1 If an associated type library for the assembly exist
and was registered, PerformTypeLibUnRegistration() is used to perform
unregistration of this type library.
7.2 The source codes for PerformTypeLibUnRegistration()
can be found in AssemblyUnregistration.cs :
static bool PerformTypeLibUnRegistration(string strTargetAssemblyFilePath) { try { Assembly assembly = Assembly.LoadFrom(strTargetAssemblyFilePath); Version version = assembly.GetName().Version; GuidAttribute guid_attribute = (GuidAttribute)assembly.GetCustomAttributes(typeof(GuidAttribute), false)[0]; Guid guid = new Guid(guid_attribute.Value); System.Runtime.InteropServices.ComTypes.SYSKIND syskind; if (Is32Bits()) { syskind = System.Runtime.InteropServices.ComTypes.SYSKIND.SYS_WIN32; } else if (Is64Bits()) { syskind = System.Runtime.InteropServices.ComTypes.SYSKIND.SYS_WIN64; } else { Console.WriteLine(string.Format("Unknown bit-ness.")); return false; } UInt32 uiRetTemp = UnRegisterTypeLib(ref guid, (UInt16)(version.Major), (UInt16)(version.Minor), 0, syskind); if (uiRetTemp == 0) { Console.WriteLine(string.Format("TypeLib File for assembly [{0:S}] unregistered.", strTargetAssemblyFilePath)); } else { Console.WriteLine(string.Format("Failed to unregister TypeLib File for assembly [{0:S}]. Error code : [{1:D}]", strTargetAssemblyFilePath, uiRetTemp)); return false; } return true; } catch (Exception ex) { Console.WriteLine(string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message)); return false; } }
Note the following :
- The UnRegisterTypeLib() API is used to perform the type
library un-registration. - Instead of specifying a path to the registered type
library, the LIBID is used, plus the type library’s major and minor version
numbers. - The original assembly’s GUID attribute is extracted and
is used to create a Guid instance. - The original assembly’s version number is also extracted
and is used to determine the type library’s major and minor version
numbers.
8. Selecting the ITypeLibExporterNotifySink
Object.
8.1 RegisterAssembly has been developed to allow for
custom ITypeLibExporterNotifySink implementation objects to be used in the call
to TypeLibConverter.ConvertAssemblyToTypeLib().
8.2 This is controlled in the RegisterAssembly.exe.config file
:
<?xml version="1.0" encoding="utf-8" ?>
<configuration> <startup> <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" /> </startup> <appSettings> <add key="TypeLibExporterNotifySink" value="RegisterAssembly.ConversionEventHandler, RegisterAssembly" /> </appSettings>
</configuration>
8.3 The default implementation is the
ConversionEventHandler class which is supplied in ConversionEventHandler.cs.
8.4 Readers can write custom ITypeLibExporterNotifySink
implementations and specify its use in the config file.
8.5 In upcoming blogs, I will be expounding more on
ITypeLibExporterNotifySink and will provide a sample custom
implementation.
8.6 The code that reads the config file and controls the
program’s ITypeLibExporterNotifySink implementation can be found
in ConfigSettings.cs :
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using System.Configuration;
using System.Collections.Specialized; namespace RegisterAssembly
{ partial class Program { const string DEFAULT_TYPELIB_EXPORTER_NOTIFY_SINK = "RegisterAssembly.ConversionEventHandler, RegisterAssembly"; static bool ReadConfigSettings() { NameValueCollection appSettings = ConfigurationManager.AppSettings; string strTypeLibExporterNotifySink = appSettings["TypeLibExporterNotifySink"]; if (string.IsNullOrEmpty(strTypeLibExporterNotifySink) == true) { strTypeLibExporterNotifySink = DEFAULT_TYPELIB_EXPORTER_NOTIFY_SINK; } Type type = Type.GetType(strTypeLibExporterNotifySink); if (type == null) { return false; } m_pITypeLibExporterNotifySink = (ITypeLibExporterNotifySink)(Activator.CreateInstance(type, new object[] { m_bVerbose })); if (m_pITypeLibExporterNotifySink == null) { return false; } return true; } }
}
9. The Test Programs.
9.1 Two sets of test programs are supplied in the
companion CodePlex site.
9.2 One is a pair of 32-bit code and the other
64-bit.
9.3 Remember that in order to process 64-bit
code, RegisterAssembly.exe must
be compiled as a 64-bit program.
9.4 Set this in the project properties under the “Build”
section :
- Set the Platform Target to “x64”.
- Set the Output path to a path separate from the one for
32-bits, e.g. “bin\Debug64\”
9.5 The 32-bit set includes the following projects
:
- A 32-bit managed assembly (ManagedClassLib32) which
contains a class (ManagedClass). - A 32-bit C++ client application (ConsoleClient32) which
references ManagedClass as a COM object.
To use this demonstration set together
with RegisterAssembly.exe perform
the following :
- Compile ManagedClassLib32 to produce
ManagedClassLib32.dll. - Run RegisterAssembly.exe using
the following command line :
RegisterAssembly.exe CODE_BASE TYPELIB "<path>\ManagedClassLib32.dll"
- Compile ConsoleClient32 to produce
ConsoleClient32.exe. - Run ConsoleClient32.exe to test for
success.
Then perform an unregistration of ManagedClassLib32.dll
with the following command line :
RegisterAssembly.exe UNREGISTER TYPELIB "<path>\ManagedClassLib32.dll"
- The unregistration process will not delete away the
original type library (ManagedClassLib32.tlb) created earlier. - Hence it is possible to re-compile ConsoleClient32 even
though the assembly and its associated type library has been
un-registered. - Run ConsoleClient32.exe. This time. the program will not
be able to create an instance of ManagedClass.
9.6 Analogous results will be observed when the 64-bit
test set is used.
10. In Summary.
10.1 RegisterAssembly.exe is
an on-going project, a work in progress.
10.2 I consider it a basic version and more features can
certainly be added to it.
10.3 I hope that the reader will comment on how to
improve it further.
[转]Programmatically Register Assemblies in C#.的更多相关文章
- 4: 模块化应用程序开发 Modular Application Development Using Prism Library 5.0 for WPF （英汉对照版）
A modular application is an application that is divided into a set of loosely coupled functional uni ...
- .net core高性能通讯开源组件BeetleX
BeetleX beetleX是基于dotnet core实现的轻量级高性能的TCP通讯组件,使用方便.性能高效和安全可靠是组件设计的出发点!开发人员可以在Beetlx组件的支持下快带地构建高性能的T ...
- ABP框架系列之二十：(Dependency-Injection-依赖注入)
What is Dependency Injection If you already know Dependency Injection concept, Constructor and Prope ...
- BeetleX高性能通讯开源组件
net core高性能通讯开源组件BeetleX https://www.cnblogs.com/smark/p/9617682.html BeetleX beetleX是基于dotnet core实 ...
- 微软企业库的 注入和依赖&nbs…
Working with ObjectBuilder This topic has not yet been rated - Rate this topic Retired Content This ...
- Exploring Micro-frameworks: Spring Boot--转载
原文地址:http://www.infoq.com/articles/microframeworks1-spring-boot Spring Boot is a brand new framework ...
- easyhook报错The given 64-Bit library does not exist
在调用 RemoteHooking.Inject 时,报错 查看easyhook源代码,出错位置如下 if(!RtlFileExists(UserLibrary)) { #ifdef _M_X64 T ...
- springcloud starter(一)
Spring Cloud - Getting Started Example, 转载自:https://www.logicbig.com/tutorials/spring-framework/spri ...
- .NET：CLR via C# Shared Assemblies and Strongly Named Assemblies
Two Kinds of Assemblies, Two Kinds of Deployment A strongly named assembly consists of four attribut ...
随机推荐
- 拦截导弹简单版（读入一串整数时getline（cin,s） stringstream is(s);）
拦截导弹简单版 时间限制: 1 Sec 内存限制: 128 MB提交: 40 解决: 16[提交][状态][讨论版][命题人:外部导入] 题目描述 某国为了防御敌国的导弹袭击,发展出一种导弹拦截系 ...
- C语言中的未初始化变量的值
C语言中未初始化的变量的值是0么 全局变量 .静态变量初始值为0局部变量,自动变量初始值随机分配 C语言中,定义局部变量时如果未初始化,则值是随机的,为什么? 定义局部变量,其实就是在栈中通过移动栈指 ...
- Py修行路 python基础 （十二） 协程函数应用 列表生成式 生成器表达式
一.知识点整理: 1.可迭代的:对象下有_iter_方法的都是可迭代的对象 迭代器:对象._iter_()得到的结果就是迭代器 迭代器的特性: 迭代器._next_() 取下一个值 优点: 1.提供了 ...
- python's twenty day for me 继承 和 super()方法
super(): 在单继承中就是单纯的寻找父类. 在多继承中就是根据子节点所在图 的mro顺序,找寻下一个类. 遇到多继承和super(): 对象.方法 1,找到这个对象对应的类. 2,将这个类的所有 ...
- Aggregate可以做字符串累加、数值累加、最大最小值
Aggregate("", (m, n) => m + n + ".").TrimEnd('.'); .Aggregate(0, (m, n) => ...
- SVN安装和使用总结
SVN简介: 为什么要使用SVN? 程序员在编写程序的过程中,每个程序员都会生成很多不同的版本,这就需要程序员有效的管理代码,在需要的时候可以迅速,准确取出相应的版本. Subversion是什么? ...
- DataGridView根据条件给单元格绑定图片
代码区: private void Form1_Load(object sender, EventArgs e) { myClass.mySqliteAPI conn = new myClass.my ...
- springboot整合redis单机及集群
一.单机配置 properties配置 #单机redis spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.passwor ...
- 14-EasyNetQ之用Future Publish发布预定中事件
很多商业流程需要事件在未来的时间按照预定时间发布.例如,在初次与客户接触后,可以在未来某个时间去电话回访客户.EasyNetQ可以用它的Future Publish功能帮你实现这个功能.举例:这里我们 ...
- @RequestParam注解的作用
1.这个注解是干什么的??? 提取和解析请求参数的能力. 2.实例解析: a.代码 @Controller @RequestMapping("/pets") @SessionAtt ...