Selbst die Inspektion von VB6 UDTs

Im Gegensatz zu dem, was andere gesagt haben, IST es möglich die run-time-type-information für UDT in VB6 (es ist zwar nicht ein built-in-Sprache-Funktion). Microsoft TypeLib-Informationen Objekt-Bibliothek (tlbinf32.dll) können Sie programmgesteuert prüfen COM-Typ-Informationen zur Laufzeit. Sollten Sie bereits über diese Komponente, wenn Sie Visual Studio installiert haben: zum hinzufügen zu einer vorhandenen VB6-Projekt, gehen Sie zu Projekt->Referenzen und überprüfen Sie den Eintrag mit der Bezeichnung "TypeLib-Informationen." Beachten Sie, dass Sie haben, zu verteilen und registrieren tlbinf32.dll im setup-Programm der Anwendung.

Können Sie überprüfen UDT-Instanzen mit Hilfe der TypeLib-Informationen-Komponente zur Laufzeit, wie lange Ihre UDT deklariert sind Public und definiert, innerhalb einer Public Klasse. Dies ist notwendig, damit der VB6 erzeugen von COM-kompatibler Typ-Informationen für Ihre UDT ' s (die dann aufgezählt werden, mit verschiedenen Klassen in der TypeLib-Informationen-Komponente). Der einfachste Weg, um diese Anforderung zu erfüllen wäre, um alle Ihre UDT ' s in einem öffentlichen UserTypes Klasse, die kompiliert wird in einer ActiveX-DLL oder ActiveX-EXE.

Zusammenfassung ein Beispiel

Diesem Beispiel enthält drei Teile:

• Teil 1: Erstellen eines ActiveX-DLL-Projekt, die sämtliche öffentliche UDT Erklärungen
• Teil 2: Erstellen einer Beispiel PrintUDT Methode zu demonstrieren, wie Sie aufzählen können, die Felder einer UDT-Instanz
• Teil 3: Erstellen Sie eine benutzerdefinierte iterator-Klasse, die Sie einfach Durchlaufen und die Felder der öffentlichen UDT und Holen der Feldnamen und Werte.

Beispiel

Teil 1: Die ActiveX-DLL -

Wie ich bereits erwähnt, Sie brauchen, um Ihre UDT öffentlich-zugänglich sind, um aufzuzählen mit Hilfe der TypeLib-Informationen-Komponente. Der einzige Weg dies zu tun ist, um Ihre UDT in einer public-Klasse in eine ActiveX-DLL oder ActiveX-EXE-Projekt. Andere Projekte, die in Ihrer Anwendung zugreifen zu können, müssen Sie den UDT ' s werden dann auf diese neue Komponente.

Folgen diesem Beispiel, erstellen Sie ein neues ActiveX-DLL-Projekt und nennen Sie es UDTLibrary.

Anschließend benennen Sie die Class1 Klasse-Modul (dieses wird standardmäßig Hinzugefügt, die von der IDE) zu UserTypes und fügen Sie zwei benutzerdefinierte Typen der Klasse Person und Animal:

' UserTypes.cls '

Option Explicit

Public Type Person
    FirstName As String
    LastName As String
    BirthDate As Date
End Type

Public Type Animal
    Genus As String
    Species As String
    NumberOfLegs As Long
End Type

Listing 1: UserTypes.cls fungiert als container für unsere UDT

Nächsten, ändern die Instancing Eigenschaft für die UserTypes Klasse "2-PublicNotCreatable". Es gibt keinen Grund für jedermann zu instanziieren, die UserTypes Klasse direkt, weil es einfach als eine öffentliche container für unsere UDT.

Schließlich, stellen Sie sicher, dass die Project Startup Object (unter Projekt->Eigenschaften) eingestellt ist auf "(None)" und das Projekt kompilieren. Sie sollten nun eine neue Datei namens UDTLibrary.dll.

Teil 2: Auflisten der UDT-Typ-Informationen

Jetzt ist es Zeit zu zeigen, wie wir Sie nutzen können TypeLib Objekt-Bibliothek zu implementieren, die eine PrintUDT Methode.

Zunächst erstellen Sie ein neues Standard EXE-Projekt, und nennen Sie es wie immer Sie wollen. Fügen Sie einen Verweis auf die Datei UDTLibrary.dll das war in Teil 1 erstellt haben. Da will ich nur zeigen, wie dies funktioniert, werden wir im Direktfenster verwenden, um den code zu testen, schreiben wir.

Erstellen Sie ein neues Modul, nennen Sie es UDTUtils und fügen Sie den folgenden code hinzu:

'UDTUtils.bas'
Option Explicit    

Public Sub PrintUDT(ByVal someUDT As Variant)

    ' Make sure we have a UDT and not something else... '
    If VarType(someUDT) <> vbUserDefinedType Then
        Err.Raise 5, , "Parameter passed to PrintUDT is not an instance of a user-defined type."
    End If

    ' Get the type information for the UDT '
    ' (in COM parlance, a VB6 UDT is also known as VT_RECORD, Record, or struct...) '

    Dim ri As RecordInfo
    Set ri = TLI.TypeInfoFromRecordVariant(someUDT)

    'If something went wrong, ri will be Nothing'

    If ri Is Nothing Then
        Err.Raise 5, , "Error retrieving RecordInfo for type '" & TypeName(someUDT) & "'"
    Else

        ' Iterate through each field (member) of the UDT '
        ' and print the out the field name and value     '

        Dim member As MemberInfo
        For Each member In ri.Members

            'TLI.RecordField allows us to get/set UDT fields:                 '
            '                                                                 '
            ' * to get a fied: myVar = TLI.RecordField(someUDT, fieldName)    '
            ' * to set a field TLI.RecordField(someUDT, fieldName) = newValue ' 
            '                                                                 '
            Dim memberVal As Variant
            memberVal = TLI.RecordField(someUDT, member.Name)

            Debug.Print member.Name & " : " & memberVal

        Next

    End If

End Sub

Public Sub TestPrintUDT()

    'Create a person instance and print it out...'

    Dim p As Person

    p.FirstName = "John"
    p.LastName = "Doe"
    p.BirthDate = #1/1/1950#

    PrintUDT p

    'Create an animal instance and print it out...'

    Dim a As Animal

    a.Genus = "Canus"
    a.Species = "Familiaris"
    a.NumberOfLegs = 4

    PrintUDT a

End Sub

Listing 2: Beispiel PrintUDT Methode und eine einfache test-Methode

Teil 3: so dass es Objekt-Orientiert

Die oben genannten Beispiele bieten eine "quick-and-dirty" - demonstration, wie Sie die TypeLib-Informationen Objekt-Bibliothek zum auflisten der Felder eines UDT. In einem real-world-Szenario, würde ich wahrscheinlich zu erstellen a UDTMemberIterator Klasse, würde Ihnen erlauben, mehr leicht iterieren über die Felder von UDT, zusammen mit einem Dienstprogramm-Funktion in ein Modul erstellt eine UDTMemberIterator für einen bestimmten UDT-Instanz. Dies würde es Ihnen ermöglichen, etwas zu tun, wie die folgenden in Ihrem code, die viel näher an den pseudo-code, den Sie geschrieben in deiner Frage:

Dim member As UDTMember 'UDTMember wraps a TLI.MemberInfo instance'

For Each member In UDTMemberIteratorFor(someUDT)
   Debug.Print member.Name & " : " & member.Value
Next

Es ist eigentlich nicht allzu schwer zu tun, und wir können re-verwenden Sie den code aus dem PrintUDT routine erstellt in Teil 2.

Zuerst, erstellen Sie ein neues ActiveX-Projekt und nennen Sie es UDTTypeInformation oder etwas ähnliches.

Nächste, stellen Sie sicher, dass das Start-Objekt für das neue Projekt auf "(None)".

Das erste, was zu tun ist, erstellen Sie eine einfache wrapper-Klasse, die verstecken die details der TLI.MemberInfo Klasse aus dem Aufruf-code und machen es leicht, eine UDT-Feld mit Namen und Wert. Ich nannte diese Klasse UDTMember. Die Instancing Eigenschaft für diese Klasse sollte PublicNotCreatable.

'UDTMember.cls'
Option Explicit

Private m_value As Variant
Private m_name As String

Public Property Get Value() As Variant
    Value = m_value
End Property

'Declared Friend because calling code should not be able to modify the value'
Friend Property Let Value(rhs As Variant)
    m_value = rhs
End Property

Public Property Get Name() As String
    Name = m_name
End Property

'Declared Friend because calling code should not be able to modify the value'
Friend Property Let Name(ByVal rhs As String)
    m_name = rhs
End Property

Listing 3: Die UDTMember wrapper-Klasse

Nun müssen wir erstellen einen iterator-Klasse UDTMemberIterator, dass es uns erlauben wird, zu verwenden, VB - For Each...In syntax zum Durchlaufen der Felder eines UDT-Instanz. Die Instancing Eigenschaft für diese Klasse festgelegt werden sollte PublicNotCreatable (wir definieren eine utility-Methode später, erstellen von Instanzen im Namen der aufrufende code).

EDIT: (2/15/09) ich gereinigt habe den code oben ein bisschen mehr.

'UDTMemberIterator.cls'

Option Explicit

Private m_members As Collection ' Collection of UDTMember objects '


' Meant to be called only by Utils.UDTMemberIteratorFor '
'                                                       '
' Sets up the iterator by reading the type info for     '
' the passed-in UDT instance and wrapping the fields in '
' UDTMember objects                                     '

Friend Sub Initialize(ByVal someUDT As Variant)

    Set m_members = GetWrappedMembersForUDT(someUDT)

End Sub

Public Function Count() As Long

    Count = m_members.Count

End Function

' This is the default method for this class [See Tools->Procedure Attributes]   '
'                                                                               '
Public Function Item(Index As Variant) As UDTMember

    Set Item = GetWrappedUDTMember(m_members.Item(Index))

End Function

' This function returns the enumerator for this                                     '
' collection in order to support For...Each syntax.                                 '
' Its procedure ID is (-4) and marked "Hidden" [See Tools->Procedure Attributes]    '
'                                                                                   '
Public Function NewEnum() As stdole.IUnknown

    Set NewEnum = m_members.[_NewEnum]

End Function

' Returns a collection of UDTMember objects, where each element                 '
' holds the name and current value of one field from the passed-in UDT          '
'                                                                               '
Private Function GetWrappedMembersForUDT(ByVal someUDT As Variant) As Collection

    Dim collWrappedMembers As New Collection
    Dim ri As RecordInfo
    Dim member As MemberInfo
    Dim memberVal As Variant
    Dim wrappedMember As UDTMember

    ' Try to get type information for the UDT... '

    If VarType(someUDT) <> vbUserDefinedType Then
        Fail "Parameter passed to GetWrappedMembersForUDT is not an instance of a user-defined type."
    End If

    Set ri = tli.TypeInfoFromRecordVariant(someUDT)

    If ri Is Nothing Then
        Fail "Error retrieving RecordInfo for type '" & TypeName(someUDT) & "'"
    End If

    ' Wrap each UDT member in a UDTMember object... '

    For Each member In ri.Members

        Set wrappedMember = CreateWrappedUDTMember(someUDT, member)
        collWrappedMembers.Add wrappedMember, member.Name

    Next

    Set GetWrappedMembersForUDT = collWrappedMembers

End Function

' Creates a UDTMember instance from a UDT instance and a MemberInfo object  '
'                                                                           '
Private Function CreateWrappedUDTMember(ByVal someUDT As Variant, ByVal member As MemberInfo) As UDTMember

    Dim wrappedMember As UDTMember
    Set wrappedMember = New UDTMember

    With wrappedMember
        .Name = member.Name
        .Value = tli.RecordField(someUDT, member.Name)
    End With

    Set CreateWrappedUDTMember = wrappedMember

End Function

' Just a convenience method
'
Private Function Fail(ByVal message As String)

    Err.Raise 5, TypeName(Me), message

End Function

Listing 4: Die UDTMemberIterator Klasse.

Beachten Sie, dass, um diese Klasse iterierbar, so dass For Each verwendet werden können, müssen Sie bestimmte Verfahren Attribute für das Item und _NewEnum Methoden (wie bereits in den Kommentaren im code). Sie können ändern Sie die Prozedur Attribute aus dem Menü Extras (Tools->Procedure Attribute).

Endlich, wir brauchen eine utility-Funktion (UDTMemberIteratorFor im ersten code-Beispiel in diesem Abschnitt) zu schaffen, der eine UDTMemberIterator für eine UDT-Instanz, welche dann iterativ mit For Each. Erstellen Sie ein neues Modul namens Utils und fügen Sie den folgenden code:

'Utils.bas'

Option Explicit

' Returns a UDTMemberIterator for the given UDT    '
'                                                  '
' Example Usage:                                   '
'                                                  '
' Dim member As UDTMember                          '
'                                                  '        
' For Each member In UDTMemberIteratorFor(someUDT) '
'    Debug.Print member.Name & ":" & member.Value  '
' Next                                             '
Public Function UDTMemberIteratorFor(ByVal udt As Variant) As UDTMemberIterator

    Dim iterator As New UDTMemberIterator
    iterator.Initialize udt

    Set UDTMemberIteratorFor = iterator

End Function

Listing 5: Die UDTMemberIteratorFor utility-Funktion.

Schließlich, kompilieren Sie das Projekt und erstellen Sie ein neues Projekt zu testen.

In deinem test-Projekt, fügen Sie einen Verweis auf die neu erstellte UDTTypeInformation.dll und die UDTLibrary.dll in Teil 1 erstellt haben, und versuchen Sie den folgenden code in ein neues Modul:

'Module1.bas'

Option Explicit

Public Sub TestUDTMemberIterator()

    Dim member As UDTMember

    Dim p As Person

    p.FirstName = "John"
    p.LastName = "Doe"
    p.BirthDate = #1/1/1950#

    For Each member In UDTMemberIteratorFor(p)
        Debug.Print member.Name & " : " & member.Value
    Next

    Dim a As Animal

    a.Genus = "Canus"
    a.Species = "Canine"
    a.NumberOfLegs = 4

    For Each member In UDTMemberIteratorFor(a)
        Debug.Print member.Name & " : " & member.Value
    Next

End Sub

Listing 6: Test der UDTMemberIterator Klasse.

InformationsquelleAutor

Wenn Sie ändern Sie alle Ihre Arten zu den Klassen. Sie haben Optionen. Die große Gefahr der Veränderung von einer Art zu einer Klasse ist, müssen Sie verwenden die neue keyworld. Jedes mal, wenn es eine Deklaration einer variable vom Typ add new.

Dann können Sie die Variante verwenden, Stichwort oder CallByName. VB6 nicht anytype der Reflexion, aber Sie können Listen der Felder und testen, um zu sehen, wenn Sie vorhanden sind, zum Beispiel

Die Klasse Test hat die folgenden

Public Key As String
Public Data As String

Können Sie dann Folgendes tun

Private Sub Command1_Click()
    Dim T As New Test 'This is NOT A MISTAKE read on as to why I did this.
    T.Key = "Key"
    T.Data = "One"
    DoTest T
End Sub

Private Sub DoTest(V As Variant)
    On Error Resume Next
    Print V.Key
    Print V.Data
    Print V.DoesNotExist
    If Err.Number = 438 Then Print "Does Not Exist"
    Print CallByName(V, "Key", VbGet)
    Print CallByName(V, "Data", VbGet)
    Print CallByName(V, "DoesNotExist", VbGet)
    If Err.Number = 438 Then Print "Does Not Exist"
End Sub

Wenn Sie versuchen, ein Feld, das nicht existiert, dann Fehler 438 angehoben werden. CallByName-ermöglicht die Verwendung von Zeichenfolgen zum aufrufen der Feld-und Methoden einer Klasse.

Was VB6 tut, wenn Sie deklarieren Dim as New ist sehr interessant und wird stark minimieren Fehler in dieser Konvertierung. Sehen Sie diese

Dim T as New Test

nicht genauso behandelt, wie

Dim T as Test
Set T = new Test

Beispielsweise dies funktioniert

Dim T as New Test
T.Key = "A Key"
Set T = Nothing
T.Key = "A New Key"

So wird ein Fehler

Dim T as Test
Set T = New Test
T.Key = "A Key"
Set T = Nothing
T.Key = "A New Key"

Der Grund dafür ist, dass im ersten Beispiel VB6 Flaggen T, so dass jederzeit ein Mitglied ist aufgerufen es zu überprüfen, ob die T ist auch nichts. Wenn es ist, es wird automatisch erstellen Sie eine neue Instanz der Testklasse und weisen Sie dann die variable.

Im zweiten Beispiel VB nicht dieses Verhalten.

In den meisten Projekt, die wir gründlich sicherzustellen, dass wir gehen Dim T as Test, T = New Test. Aber in Ihrem Fall, da Sie konvertieren möchten Typen in Klassen mit der geringsten Anzahl von Nebenwirkungen mit Dim T as New Test ist der Weg zu gehen. Dies ist, weil die Dim als Neue Ursache die variable imitieren die Art Typen, die Werke genauer an.

InformationsquelleAutor RS Conley