Passing a UDT Variable to a Sub Argument Typed as Variant

Oh, I mentioned the alternitive, which is to encapsulate your data inside of a class.  In that case you will just define a class for each data type and give access to each field through the class methods and properties.  We can talk about that if you want, but from what you are saying I think you just need to define the types as public in a .BAS module.

Enlade, you say that it is not possible to pass UDTs between forms. Actually, using my first answer it is possible to have a public function of a form that takes and returns a UDT. Also, no one is talking about having more than one process.

To pass around UDTs you must put them in a "public object modules," according to your error message. If you make a class in your project it cannot be totally public, so you have to add an ActiveX DLL project and create a public class module in that, and you are doing what the error message says to fix your problem.

Remember I am saying between "Forms".  Clearly you can pass a type structure to a module function, but you cannot pass a structure to a form even if the forms function is public.  For example, try passing this to a function on a form:

Public Type MyType
  Field1 As Long
  Field2 As Long
End Type

I think that you might be giving him a much larger answer then he is looking for (though I'm not sure).  It seems to me that he wants to define some types and he is having trouble passing variables of those types between forms.  Though, maybe he is talking about creating class objects and passing them....and/or creating his own ActiveX object and linking it into his project.  So he will need to clearify that for us.

In any case, I'm not sure what you mean by "if you make a class in your project it cannot be totally public"?  It is totally public to your process.  Its just not totally public to some other process that your application may spawn.  But clearly I can create a class within my project that is totally public to my entire project and even create an object of that class that is also entirely public to all the code in my project.  Maybe I just don't understand what you are trying to suggest.  It seems like you are suggesting that he should create some ActiveX object to encapulate his data and that seems like an overkill.  Though maybe that is what he wants and I'm just not understanding him.  I'll wait for him to clearify his question for me.

Imbue--

I tried your suggestions (File > Add project > ActiveX DLL, etc.)

I put the following UDT in a Class Module in Project2:

    Public Type BinaryFileUtilityType
        PostDateTime as Variant
        Amount as Single
        Bool as Boolean
        LongInteg as Long
        Integ as Integer
        Desc as String * 25
    End Type


When I try to run the application I get the following error message:

   Compile error:

   Fixed-length strings and use of the 'new' qualifier are not allowed for fields in public user defined type defined in an object module.

and the 'Desc as String *' is highlighted by the error.

My problem is simple. Please don't read any complexity into it. All I want to do is create a generic binary file update procedure to add, change, delete and insert records into any binary file. Any such record will be defined by its own UDT. By "generic...procedure" I mean a procedure in some kind of module that I can develop once and reuse it over and over again for any record (UDT) structure in any application. Naturally, each record (UDT) structure will be unique, which is why I want to type the record parameter as a Variant in the generic procedure's Sub statement.

The problem is that you are using the term UDT and a lot of people simple understand that to mean "Class".  Well, a Class is a UDT, but so is a simple type structure like you are showing above.  Just don't use a Class module at all.  Just create your public type in a regular old module.

Oh, I think I see what you want to do.  You want to make this a generic function that takes any such type structure and writes it to a record in the file.  This is not a simple task.  I think you might have trouble with the fact that a Variant has additional information that is beyond that contained in the strucuture that you are passing.  Right now you are having trouble passing the structure, but you might end up with a larger problem when you try to write the variant (that contains the structure) into the file (thinking that it is just a file containing your original structures).  I'll need to think about this a bit.

I now understand what Imbue meant by "totally public".  I'll need to rethink this problem a bit to see if there is an easier solution.

Nope, no easier way that I can think of (short of copying the structure into a byte array or something).  So, I'll defer to Imbue on this one.  Still, I think you might end up with another problem when you try to write the variant to disk.

Ok, unless I am missing something (and I could very well be), you will need to have an ActiveX DLL project. If you only have the EXE project then you cannot get UDT data into the type library for that program (that means you cannot make it public enough to do cool stuff with it).

Anyway, to make it simple the fixed length string is causing your problem now. I don't know of an really slick ways to deal with that, though. You could make it variable length, or use a byte array. Why does it need to be fixed length?


Enlade, when you said "you cannot pass a structure to a form even if the forms function is public" I don't think you could be more wrong. If the UDT is in the type library you can do just about anything with it, including passing it to and from classes (forms).

You will not have any problems writing a variant (vs a real UDT) to a file. The variable length string shouln't cause any problems either, VB is really flexible and handles this stuff very well.

It was my missunderstanding.  I over simplfied the problem.

As far as not being able to pass type structures to a form.  You will have to explain to me how to do that.  Tell me how to pass this public type structure to a form without first making the structure into a Class.

Public Type MyType
  Field1 As Long
  Field2 As Long
End Type

In any case, you are on the right path with what you are suggesting.  I was way off.  Sorry.

Enlade, all you need to do to pass that structure to a form is get it into a public type library. The easiest way to do that is plop it into an ActiveX DLL's class. Please understand that this is not making it into a class. It is not a class, it is a user defined type.

Anyway, then once you have the project references set up you just make your public sub in your form like Public Sub Test (TestUDT as MyType).

The difference from being a class and being in a class is.


Public Type MyType 'A UDT defined in a class.
  Field1 As Long
  Field2 As Long
End Type


Public Field1 As Long 'Using a class to act like a UDT (not a real UDT)
Public Field2 As Long

You can pass a UDT as a param to a form, just make sure you use FRIEND and not PUBLIC as the scope identifier..


in a public module...
Public Type MyType
  Field1 As Long
  Field2 As Long
End Type


on a form..
Friend Sub Test(m As MyType)
   msgbox "Madeit"
End Sub

As for making a generic method,
Remember that passing a UDT requires early binding. This means that the structure of the UDT MUST be know at compile time. So a true generic way is not really possible. Well It is if you use some balck belt thing to actually pass along the address of the UDT then inside the SUB you use a few API calls to copy the data at that loction into a local udt. But in the end, again the UDT must be known if you plan on manipulating the UDT contents.

A similar and much safer way might to use the following as a jumping off point to do what you want...
Make a master UDT that contains all the sub UDT's and include a TYPE field to let the reciever know which sub UDT to work with..


Public Type MasterType
   UDT1 as UDT1_Type
   UDT2 as UDT2_Type
   MType as TypeEnum
End type

Also include the following before all else...
Public Enum TypeEnum
   eUDT1
   eUDT2
End Enum

Public Type UDT1_Type
        PostDateTime as Variant
        Amount as Single
        Bool as Boolean
        LongInteg as Long
        Integ as Integer
        Desc as String * 25
End Type

Public Type UDT2_Type
        PostDateTime as Variant
        Total as Single
        Bool as Boolean
        LongInteg as Long
        Integ as Integer
End Type


Then dim it with something like..
Public M as MasterType

then use it like...

' Set the UDT to use
M.MType = eUDT1  

' Set some Data        
With M.UDT1
   .PostDateTime = Now
   .Amount = 100
End With


'Call the function
call Form1.NewSub(M)


And the prototype of the sub is
Friend Sub NewSub(M as MasterType)
   If M.MType = eUDT1 then
      Msgbox "PostDate = " & M.UDT1.PostDateTime
   Else
      Msgbox "PostDate = " & M.UDT2.PostDateTime
   End If
End Sub


Hope this helps some

Passing a UDT does not require early binding. You can pass a UDT as a variant. You can pass a UDT to a form's public methods. The UDT just must be written in the type library.

I was offer an alternate example. In a sense they have to be considered early bound unless one uses the ActiveX DLL method.
I'm right with you though that the ActiveX DLL method should work here.