COM visible DLLs: are they only legends?

COM visible DLLs: are they only legends?

• Lyn*

  I am not a fan of the VS.NET help system so any outside source of information is greatly appreciated. I did check out the faq. As I mentioned, I have examined dozens of pages of info about com - none of which actually describes a straightforward method. It's amazing how many times I have read: you can do this, that and the other thing but we don't recommend it.
  
  While the link noted appears to be a very good source of information and actually helped to clarify a few things for me, it still doesn't resolve my problem.
  
  I did "...explicitly define an interface..." several days ago; that didn't help. Naturally the last option was the recommended one "...The last and recommended option is ClassInterfaceType.None..." is preferred but didn't work either. Not even the class no less its methods were visible. Also, can't use ClassInterfaceType and ComClass at the same time but: "...if you're using VB.NET and the ComClass attribute, it uses ClassInterfaceType.None behind the scenes and defines a nested explicit interface for you  (to me, it appears to be implying that ClassInterfaceType is not needed if an interface is defined). However, the ComClass attribute also has versioning issues, so it's not recommended to use this as a shortcut." Oh well, not recommended and does not do the job anyway.
  
  I've never found DLLs complicated to write in C++ or even VB until .NET came along. I know it is supposed to provide benefits in the loooooong run. I just hope it is worth all the time wasted trying to find answers to what used to be simple procedures. Now, I know where the term DLL Hell came from - .NET DLL. In the .NET help world everything is a piece of this maybe, a piece of that maybe, or maybe a piece of this other thing (or not), find some glue somewhere (if you can) and hope it works.
  
  If the COM visible DLL is not a legend then I challenge all forum participants to provide one simple, clear-cut, straightforward, step by step explanation of how to create a COM visible .NET DLL. I'm not talking anything exotic - just a simple DLL with fields, properties, functions and subs that can be used by COM and .NET programs (as advertised but never explained).
  

• AlxSharp

  Did you finally get to use .NET component as COM components. If yes, please give me the solution because I've been thrue all what you 've been and there is no way I get to use it in an excel VBA module.

  I can see properties, functions, subs but I can't creat instance of the object via

  set a = new dllname.class

  Please help !

  thanks

  
  

• Dominik Ras

  express version doesn't offer COMClass as an add item; however it does have the property COMClass true which appears to do the same. Unfortunately, I've done all that and more (and less depending on the instructions one reads). No luck. Only the class and an enum are recognized in both .NET and COM apps. The property, functions and subs are not available at all (all publics are set as COM Visible true).
  

• Omega147

  >If the COM visible DLL is not a legend then I challenge all forum participants to provide one simple, clear-cut, straightforward, step by step explanation of how to create a COM visible .NET DLL.
   
  How about doing it the other way around You post your current solution somewhere and we try to help you find what's wrong.
  
  
  
  

• Ronald S

  This is for vb 2005
  
  Create a vb class library.
  Select add new item, and click on COMClass
  
  Add a public method to it.
  
  Build the project, the class should now be registered - check the references window in vb6 to find the assembly name there.
  
  Note that .Net does not work through registry entries as COM does - as such, if you want to use this class from .Net you need to add a reference to the assembly you just built, and unless you add it to the GAC every .net program that does reference it will need it's own copy (Visual studio will copy it for you, but if you're using the command line compiler, then you'll need to copy it manually).
  
  Also note that to use the binary from com, it will have to be registered in the machine you want to use it from - use regasm for that.
  
  

• mojaveson

  >Even all that does not help because only the class and an enum are visible; the public properties, functions and subs are not available when I try to access the DLL.
  
  See if this explains it
  
  http://www.dotnetinterop.com/faq/ q=ClassInterface
  
  
  
  

• Sidon

  Here's one of many methods I tried that does not work (IMyExampleClass1 is in a module); after build, I ran regasm MyExampleClass.dll /tlb:MyExampleClass.tlb; the dll can be added as a reference in but the property, sub and function are not available:
  
  

  <Microsoft.VisualBasic.ComClass()> Public Class MyExampleClass1
  Implements IMyExampleClass1

  'Field
  Private m_MyPrivateExampleField As Integer

  Public Property MyPublicExampleProperty() As Integer Implements IMyExampleClass1.MyPublicExampleProperty
     Get
        Return m_MyPrivateExampleField
     End Get

     Set(ByVal value As Integer)
        m_MyPrivateExampleField = value
     End Set
  End Property

  'New - constructor required as is or class will not register properly
  Public Sub New()

     MyBase.New()

  End Sub

  Public Sub MyPublicExampleSub(ByVal s As String) _
  Implements IMyExampleClass1.MyPublicExampleSub

     MsgBox(s)

  End Sub

  Public Function MyPublicExampleFunction(ByVal x As Integer, ByVal y As Integer) _
  As Integer Implements IMyExampleClass1.MyPublicExampleFunction

     MyPublicExampleFunction = x * y

  End Function

  End Class

  
  

• weezer24

  The link below is an excellent example of the type of information for which I am looking; it is from the VB6 documentation. Does anything like this exist for creating DLLs in VB2005
  
  http://msdn.microsoft.com/library/default.asp url=/library/en-us/vbcon98/html/vbconcreatinganinprocesscomponent.asp
  

• CRasmussen

  Three reason that I'd prefer not to: 1) proprietary software, 2) quite long, 3) I have many different versions all based on the varying information I've read on the MSDN site and instructions from posters. Of course, this brings me back to an earlier question: Is there one basic, straightforward way to create a COM class In my previous posts (several threads because I've been looking for this information for more than a week), I mentioned some of the methods tried: COM Class true, visible, etc.; with & w/out GUIDs; regasm'd, sn'd & gacutil'd (or not); w/ interface or w/out; and more. In some cases, the process is self-registering (preferred) in others the utils mentioned above are used.
  
  Isn't there one, basic way create a COM class All the variations serve specific purposes but until the properties, functions & subs are visible (yes, their properties are marked w/ visible true), the COM class is useless. I would imagine that is the essential question. How does one make properties and methods visible to other programs The class has been recognized tho sometimes does and sometimes doesn't show up in the COM list (under Add Reference) in VB6, 2003 & 2005 Express. I could go back to using VB6 since the procedure is much easier to implement.
  
  I know it can be done but so far no has been able to describe the process (a complete working solution; not a repeat of the bits and pieces on MSDN). I have seen other postings about similar problems on this forum and various others on the web. None that I have seen received a working response. So, I know I am not the only person with this problem. Perhaps sample code exists on the exact procedure for doing this. Again, a complete working com class (not disjointed bits & pieces).
  
  BTW, the part about "legend" and "challenge" is a tongue in cheek approach to attract attention. It seems to be working because, of all the threads I've started on this subject, this has gotten the most response.

  
  

• Holly522

  Hope this helps
  
  Making a COM object in VS2005< xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

   

  Start a vis studio project and make a class library.

   

  In the class library, have an Interface section and then have a a procedure which Implements this (implements keyword). See the example attached.

   

  Tick ON the COM Visible box (you’ll find it eventually)

   

  Start a vis studio command window ( start programs-> vis studio tools)

   

  Use the SN tool to make a strong name key pair ->  SN/k democom.snk

   

  Using Project-> Properties -> Signing, select this file as the key file – signs the assembly. If you don’t do this , you cannot put the assembly in the global assembly cache

   

  Build the class library

   

  With the vis studio command window, navigate to the assembly dir

  Use REGASM /tlb:democom.tlb democom.dll

  This registers the dll and the type library, and it also creates the type library

   

  Use GACUTIL /I democom to insert the democom assembly in the global cache

   

  Now go to VB6, or VBA and add a REFERENCE tot the progect. Democom appears in the list so tick it ON

   

   

   

  Article at

  http://whidbey.msdn.microsoft.com/library/default.asp url=/library/en-us/dndotnet/html/callnetfrcom.asp

   

  title “Calling a .net Component from a  COM  components” (Mike Gunderloy)

   

  was used as the basis for this procedure – although the detail of the operations is different
  

  
  
  
  attachments:::
  
  

  VB6 code to use democom

   

  Private moTempClass As demoCOM.NET_Temperature

  Private moTemp As demoCOM.iTemperature

   

   

  Private Sub Command1_Click()

      With moTemp

          .Fahrenheit = txtfahrenheit.Text

           TxtCelsius.Text = .GetCelsius

      End With

   

   

   

   

  End Sub

   

  Private Sub Form_Load()

  Set moTempClass = New demoCOM.NET_Temperature

      Set moTemp = moTempClass

   

  End Sub

   

  
  

  DEMOCOM source  VB.Net

   

  Public Interface iTemperature

      Property Celsius() As Double

      Property Fahrenheit() As Double

      Function GetCelsius() As Double

      Function GetFahrenheit() As Double

  End Interface

   

  Public Class NET_Temperature

      Implements iTemperature

   

      Private mdblCelsius As Double

      Private mdblFahrenheit As Double

   

      Public Property Celsius() As Double _

       Implements iTemperature.Celsius

          Get

              Celsius = mdblCelsius

          End Get

          Set(ByVal Value As Double)

              mdblCelsius = Value

              mdblFahrenheit = ((Value * 9) / 5) + 32

          End Set

      End Property

   

      Public Property Fahrenheit() As Double _

       Implements iTemperature.Fahrenheit

          Get

              Fahrenheit = mdblFahrenheit

          End Get

          Set(ByVal Value As Double)

              mdblFahrenheit = Value

              mdblCelsius = ((Value - 32) * 5) / 9

          End Set

      End Property

   

      Public Function GetCelsius() As Double _

       Implements iTemperature.GetCelsius

          GetCelsius = mdblCelsius

      End Function

   

      Public Function GetFahrenheit() As Double _

       Implements iTemperature.GetFahrenheit

          GetFahrenheit = mdblFahrenheit

      End Function

  End Class

   

   

   

   

   

   

   

  
  
  

• Paully_l

  It should still be possible to do this - I don't have express installed, so I can't try it out, but play with this:
  Create a Class library, select view all and open the assemblyinfo.vb file - set the assembly level comvisible attribute to true
  On a class with public methods, add the comclass attribute
  Build the assembly
  Register the built binary with Regasm /tlb (unless the assembly is GAC'd you may also need /codebase for this to work, I'm a bit rusty on that)
  That should do it, I've just made it work with command line tools only - check to see if vb6 allows you to use it.
  
  
• COM visible DLLs: are they only legends?