Before I embark on writing the code to create the TLB and adding the
appropriate registry keys (which sounds a bit messy actually), do I actually
need the TLB information?

I appreciate this is perhaps a difficult question to answer, but what
questions should I ask myself to decide whether the TYPELIB information is
actually required.

James

Ok, I've found other newsgroup posts that have used the
ConvertAssemblyToTypeLib, and I've tried to merge that code into my
Installer class (see code below).

When I run the installer (or do installutil.exe my.dll) I get:
 An exception occurred during the Install phase.
 System.UnauthorizedAccessException: Access is denied.

This happens at the point I do the:
 typeLib.SaveAllChanges();

I assume this is because the assembly is currently in use (I am running the
Install method in it after all !!)

So how do I apply the changes from within the Installer class?  This seems
like an awful lot of effort to simply get the installer to reliably do
REGASM on a packaged DLL.

James

using System;
using System.Collections;
using System.ComponentModel;
using System.Configuration.Install;
using System.IO;
using System.Runtime.InteropServices;
using System.Reflection;

namespace Collins.Datalink.Hermes.CommonInterfaces
{
 [ComImport,
 GuidAttribute( "00020406-0000-0000-C000-000000000046" ),
 InterfaceTypeAttribute( ComInterfaceType.InterfaceIsIUnknown ),
 ComVisible( false )]
 public interface UCOMICreateITypeLib
 {
   void CreateTypeInfo();
   void SetName();
   void SetVersion();
   void SetGuid();
   void SetDocString();
   void SetHelpFileName();
   void SetHelpContext();
   void SetLcid();
   void SetLibFlags();
   void SaveAllChanges();
 }

 public class ConversionEventHandler : ITypeLibExporterNotifySink
 {
   public void ReportEvent( ExporterEventKind eventKind, int eventCode,
string eventMsg )
   {
     // Handle the warning event here.
   }

   public Object ResolveRef( Assembly asm )
   {
     // Resolve the reference here and return a correct type library.
     return null;
   }
 }

 /// <summary>
 /// Summary description for Installer.
 /// </summary>
 [RunInstaller(true)]
 public class ClientInterfaceInstaller :
System.Configuration.Install.Installer
 {
   #region Fields and Properties
   /// <summary>
   /// Required designer variable.
   /// </summary>
   private System.ComponentModel.Container components = null;
   #endregion

   [DllImport("oleaut32.dll")]
   private static extern int LoadTypeLib([MarshalAs(UnmanagedType.LPWStr)]
     string libPath, ref IntPtr ITypLib);

   [DllImport("oleaut32.dll")]
   private static extern int RegisterTypeLib(IntPtr ITypLib,
     [MarshalAs(UnmanagedType.LPWStr)] string libPath,
     [MarshalAs(UnmanagedType.LPWStr)] string helpDir);

   [DllImport("oleaut32.dll")]
   private static extern int UnRegisterTypeLib(ref Guid libID, Int16
     wVerMajor, Int16 wVerMinor, int LCID, SYSKIND syskind);

   /// <summary>
   /// Default constructor
   /// </summary>
   public ClientInterfaceInstaller()
   {
     // This call is required by the Designer.
     InitializeComponent();
   }

   /// <summary>
   /// Install method, overridden to allow this assembly to be registered
for COM
   /// </summary>
   /// <param name="stateSaver"></param>
   public override void Install(System.Collections.IDictionary stateSaver)
   {
     base.Install(stateSaver);

     RegistrationServices regsrv = new RegistrationServices();
     if (!regsrv.RegisterAssembly(this.GetType().Assembly,
AssemblyRegistrationFlags.SetCodeBase))
     {
       throw new InstallException("Failed To Register for COM");
     }
     RegisterTypeLibrary();
   }

   /// <summary>
   /// Uninstall method, overridden to allow this assembly to be registered
for COM
   /// </summary>
   /// <param name="savedState"></param>
   public override void Uninstall(System.Collections.IDictionary
savedState)
   {
     base.Uninstall(savedState);

     RegistrationServices regsrv = new RegistrationServices();
     if (!regsrv.UnregisterAssembly(this.GetType().Assembly))
     {
       throw new InstallException("Failed To Unregister for COM");
     }
     UnRegisterTypeLibrary();
   }

   public void RegisterTypeLibrary()
   {
     string assemblyLocation = GetType().Assembly.Location;
     string typeLibLocation = Path.ChangeExtension(assemblyLocation,
".tlb");

     //Convert assembly to type library file
     Assembly asm = Assembly.LoadFrom(assemblyLocation);
     TypeLibConverter converter = new TypeLibConverter();
     ConversionEventHandler eventHandler = new ConversionEventHandler();

     UCOMICreateITypeLib typeLib =
(UCOMICreateITypeLib)converter.ConvertAssemblyToTypeLib(asm,
assemblyLocation, 0, eventHandler);
     typeLib.SaveAllChanges(); // EXCEPTION THROWN HERE

     //Now register the type library
     IntPtr obj = IntPtr.Zero;
     LoadTypeLib(typeLibLocation, ref obj);
     RegisterTypeLib(obj, typeLibLocation, "");
   }

   public void UnRegisterTypeLibrary()
   {
     string assemblyLocation = GetType().Assembly.Location;
     string typeLibLocation = Path.ChangeExtension(assemblyLocation,
".tlb");

     // Call LoadTypeLib function to get ITypeLib interface pointer
     IntPtr obj = IntPtr.Zero;
     LoadTypeLib(typeLibLocation, ref obj);
     System.Runtime.InteropServices.TYPELIBATTR typeLibAttr = new
TYPELIBATTR();

     // Call GetLibAttr method of ITypeLib interface to get pointer to Type
Library attributes
     System.Runtime.InteropServices.UCOMITypeLib myLib =

(System.Runtime.InteropServices.UCOMITypeLib)Marshal.GetTypedObjectForIUnkno
wn(obj, typeof(System.Runtime.InteropServices.UCOMITypeLib));
     myLib.GetLibAttr(out obj);
     typeLibAttr = (TYPELIBATTR)Marshal.PtrToStructure(obj,
typeof(TYPELIBATTR));

     // Call UnRegisterTypeLib to unregister type library
     UnRegisterTypeLib(ref typeLibAttr.guid, typeLibAttr.wMajorVerNum,
typeLibAttr.wMinorVerNum, typeLibAttr.lcid, SYSKIND.SYS_WIN32);
   }

   /// <summary>
   /// Clean up any resources being used.
   /// </summary>
   protected override void Dispose( bool disposing )
   {
     if( disposing )
     {
       if(components != null)
       {
         components.Dispose();
       }
     }
     base.Dispose( disposing );
   }

   #region Component Designer generated code
   /// <summary>
   /// Required method for Designer support - do not modify
   /// the contents of this method with the code editor.
   /// </summary>
   private void InitializeComponent()
   {
     components = new System.ComponentModel.Container();
   }
   #endregion
 }
}

Thanks for the response.  I'll try the converter.

The reason I chose to use an Installer class is because of the problems
getting the Windows Installer to COM register .NET assembly Project Outputs
in Merge Modules.  It simply didn't work at all for me.  The alternative was
to add a file link to my assembly and COM register that, but then it makes
Merge Modules seem pointless.

I have found many other reports of the same problem in newsgroups and on the
web.  Do a google search for "vsdrpCOM" or "vsdraCOM" through for reference.
Not sure if it is a bug or feature, but it is very frustrating.  The problem
becomes even more difficult when you want the .NET assembly to be put in the
GAC, and be copied to a folder for COM registration.

But for now, the Installer class direction seems a nice tidy solution.
Making each DLL handle its own registration in code seems better than
external registration.

James