[VB.Net] Virtual Treeview implementatie

[RobIII]

Ik ben sinds kort overgestapt van VB6 naar VB.Net (eindelijk) om nu eindelijk eens helemaal netjes OO te kunnen gaan werken. Nu ben ik bezig met het volgende:

Ik heb een treeview die nogal wat data bevat (uiteraard hiëarchische data). Om mijn database niet op z'n flikker te geven bij het bouwen van de (nogmaals: enorme) tree probeer ik deze "virtual" te maken. Dat wil zeggen dat ik alleen de root node maak en 1 "dummy childnode" geef zodat het "plusje" voor de rootnode verschijnt. Op het moment dat ik deze "uitklap" wordt er gekeken of er een "dummy node" onder zit (en dat is dus zo bij de eerste keer uitklappen) en in dat geval wordt het niveau gevuld dat uitgeklapt gaat worden. Dat geld dan vervolgens weer voor alle subniveaus; ze bevatten allemaal een dummy node, welke bij uitklappen wordt vervangen door de echte nodes.

Nu heb ik alles netjes werkend met mijn eigen "nodetype". Ik inherit van de TreeNode en geef deze een aantal eigen properties en methods (zoals een .sort method, zodat ik binnen een bepaalde node alle subnodes (en childnodes daar weer van...) kan sorteren).

Lang verhaal kort: Dat inheriten enzo is me wel duidelijk. Wat me niet duidelijk is, is hoe ik nu het "BeforeExpand" event kan "Inheriten" zodat ik dus, bij het klikken op het plusje, "effe snel" de node kan gaan vullen met de benodigde data voordat het aan de gebruiker wordt gepresenteerd.

Ik heb momenteel dus:

Visual Basic .NET:

Private Sub TreeView1_BeforeExpand(ByVal sender As Object, ByVal e As System.Windows.Forms.TreeViewCancelEventArgs) Handles TreeView1.BeforeExpand
    If CType(e.Node, RDProductTreeNode).IsVirtual Then CType(e.Node, RDProductTreeNode).Fill()
End Sub

Hier wordt dus gekeken of de node reeds gevuld is met data of niet (.IsVirtual) en als dat niet het geval is (.IsVirtual = True) dan vul ik de node (.Fill). Het liefste zou ik echter gewoon dit event "inheriten" en in mijn eigen class dus vangen.

Ik heb dit nu in mijn eigen class:

Visual Basic .NET:

Public Overloads Sub Expand()
    If Me.IsVirtual Then Me.Fill()
End Sub

Maar die Expand method wordt dus niet aangeroepen. Ik neem aan dat dat komt omdat ik nog iets van "Handles Treeview.BeforeExpand" ofzo achter moet, maar dat vreet 'ie dus niet.

Ik voel me weer zo ontzettend n00b...

Mijn vraag: Hoe vang ik nu in mijn eigen class, die Inherit van een TreeNode, een bepaald event zoals het BeforeExpand event? Uiteraard kon ik met Google (+Groups) en GoT search niets zinnigs vinden, anders stelde ik mijn vraag hier niet (en helaas ligt mijn enorme stapel VB.Net boeken zuhause)

[ Voor 18% gewijzigd door RobIII op 20-03-2006 15:24 ]

[whoami]

Hmm, eigenlijk heb je dus een soort lazy-loading. (Virtual vind ik maar een slechte naam voor dit).

Een event kan je niet overriden (inheriten is weer wat anders).

Die Expand wordt niet aangeroepen, omdat je een eigen Expand method gemaakt hebt, die de originele hided.

Ik zou m'n eigen TreeView control maken (LazyTreeView) die inherit van TreeView. Dan kan je de OnBeforeExpand member method van TreeView (die virtual is) , gaan overriden en je eigen extra functionaliteit aan toekennen. (Het verwijderen dus van de dummy node).

Echter, iets anders: wat als een bepaalde tree-node geen children meer heeft, en dus eigenlijk ook geen plusje moet hebben ?

[Woy]

je doet Overloads moet dat geen overides oid zijn? Overloads is volgens mij bedoelt om methoden te overloaden en is dus eigenlijk een beetje overbodig.

Verder is wat Whoami zegt denk wel de beste oplossing. ( Expand is volgens mij trouwens geen event maar een method ).

[ Voor 29% gewijzigd door Woy op 20-03-2006 15:37 ]

[whoami]

Expand is een method, maar BeforeExpand is een event.

[RobIII]

whoami schreef op maandag 20 maart 2006 @ 15:33:
Hmm, eigenlijk heb je dus een soort lazy-loading. (Virtual vind ik maar een slechte naam voor dit).

Inderdaad lazy loading mechanisme. En inderdaad is de benaming misschien wat...gaar

whoami schreef op maandag 20 maart 2006 @ 15:33:
Een event kan je niet overriden (inheriten is weer wat anders).

Die Expand wordt niet aangeroepen, omdat je een eigen Expand method gemaakt hebt, die de originele hided.

Ok, zover begrijp ik het nog.

whoami schreef op maandag 20 maart 2006 @ 15:33:
Ik zou m'n eigen TreeView control maken (LazyTreeView) die inherit van TreeView. Dan kan je de OnBeforeExpand member method van TreeView (die virtual is) , gaan overriden en je eigen extra functionaliteit aan toekennen. (Het verwijderen dus van de dummy node).

Dus ik moet een extra class maken die van de Treeview inherit en daar dan weer mijn eigen nodes inladen? Of begrijp ik je nu verkeerd? En hoe "koppel" ik die dan aan de Treeview op mijn form? En hoe "koppel" ik het BeforeExpand event dan in dit geval?

whoami schreef op maandag 20 maart 2006 @ 15:33:
Echter, iets anders: wat als een bepaalde tree-node geen children meer heeft, en dus eigenlijk ook geen plusje moet hebben ?

Dat is het probleem met lazy-loading. Ik kan dat "onderwater" op twee manieren oplossen.
1) Bij het ophalen van het niveau de DB meteen de childcount laten teruggeven (middels een Count(blahblah) en een join op de "childtabel". Op die manier kan ik bepalen of er een plusje moet komen (dummy node) of niet.
2) Simpelweg een plusje neerzetten. Op het moment dat de node ge-expand wordt wordt de dummynode verwijderd en worden (eventuele) childnodes er in gezet. Zijn die er niet (childnodes) dan is het effect dus dat het plusje simpelweg "verdwijnt". Interfacetechnisch is dit (helaas) niet helemaal netjes, maar in de praktijk blijkt dat er in 99% van de gevallen wel degelijk childnodes zijn, behalve op het laagste/diepste niveau. Ik heb dit toch wel vaker gezien in de praktijk (kan het me alleen even niet heugen waar dan ook weer )

whoami schreef op maandag 20 maart 2006 @ 15:40:
Expand is een method, maar BeforeExpand is een event.

Eensch, maar dat was ook maar een "probeersel" in de ijdele hoop dat de .Expand method zou worden aangeroepen door de control op het moment dat er op het plusje zou worden ge-click-ed.

[ Voor 9% gewijzigd door RobIII op 20-03-2006 15:44 ]

[whoami]

RobIII schreef op maandag 20 maart 2006 @ 15:42:
[...]

Dus ik moet een extra class maken die van de Treeview inherit en daar dan weer mijn eigen nodes inladen? Of begrijp ik je nu verkeerd? En hoe "koppel" ik die dan aan de Treeview op mijn form? En hoe "koppel" ik het BeforeExpand event dan in dit geval?

Je moet gewoon een nieuwe Control maken.
Add New Item - Component Class

Die inherit je dan van TreeView, en je kan die dan gewoon op je form droppen in de designer.
(Het is wel aan te raden om die control in een aparte DLL te stoppen; je moet dan ook nog wel ff die dll toevoegen aan je toolbox).

[RobIII]

whoami schreef op maandag 20 maart 2006 @ 15:47:
[...]

Je moet gewoon een nieuwe Control maken.
Add New Item - Component Class

Die inherit je dan van TreeView, en je kan die dan gewoon op je form droppen in de designer.
(Het is wel aan te raden om die control in een aparte DLL te stoppen; je moet dan ook nog wel ff die dll toevoegen aan je toolbox).

Hmmm, dat ga ik dan nu proberen.
Even mijn ego opzij gezet, en wellicht niet geheel overbodig toch nog even de vraag: Ben ik wat onderstaande code betreft op de juiste weg? (Scroll even naar beneden en lees eerst even verder...)

Visual Basic .NET:

Imports RDOffice_BO.CollectionClasses
Imports RDOffice_BO.EntityClasses
Imports RDOffice_BO.HelperClasses
Imports SD.LLBLGen.Pro.ORMSupportClasses

Public Class RDProductTreeNode
    Inherits TreeNode

    Public Enum RDNodeType
        Unknown     'This type is used to add a dummy node
        Root        'This node-level displays only a root node ("Devices")
        DeviceType  'This node-level displays devicetypes ("Laptop","PDA","Camcorder",...)
        Brand       'This node-level displays brands ("Compaq","Dell","Acer",...)
        Model       'This node-level displays models ("Aspire","EVO","Armada",...)
        ModelType   'This node-level displays modeltypes ("1100","1200","1300",...) and is able to display childnodes of the same type (Modeltype)
    End Enum

    Public Sub New(ByVal sTitle As String, ByVal iID As Integer, ByVal iType As RDNodeType)
        MyBase.New()
        Me.ID = iID
        Me.Text = sTitle
        m_iNodeType = iType

        'Add a dummy node to make this node "virtual" and display a "plus sign"
        If iType <> RDNodeType.Unknown Then Me.Nodes.Add(New RDProductTreeNode("~", -1, RDNodeType.Unknown))
    End Sub

    ''' <summary>
    ''' When a node contains only a "dummy node" it is considered to be "virtual"
    ''' </summary>
    ''' <returns>Returns True when the node is virtual, false if the node has been initialized with data</returns>
    Public ReadOnly Property IsVirtual() As Boolean
        Get
            If Me.Nodes.Count > 0 Then
                Return CType(Me.Nodes(0), RDProductTreeNode).ID < 0
            Else
                Return False
            End If
        End Get
    End Property

    Private m_iNodeType As RDNodeType
    ''' <summary>
    ''' A node of the type RDProductTreenode always contains a subtype (Root, Devicetype, Brand, Model, ... ) of type RDNodeType
    ''' </summary>
    Public ReadOnly Property Nodetype() As RDNodeType
        Get
            Return m_iNodeType
        End Get
    End Property

    Private m_iID As Integer
    ''' <summary>
    ''' A node of the type RDProductTreenode always contains an ID of the underlying database record for that type
    ''' </summary>
    Public Property ID() As Integer
        Get
            Return m_iID
        End Get
        Set(ByVal value As Integer)
            m_iID = value
        End Set
    End Property

    ''' <summary>
    ''' This method sorts the nodes childnodes alphabetically. It can also sort its childnodes
    ''' </summary>
    ''' <param name="bSortChildNodes">Default: False. Specifies whether childnodes need to be sorted too</param>
    Public Sub Sort(Optional ByVal bSortChildNodes As Boolean = False)
        Dim oNodes() As RDProductTreeNode
        Dim oNode As TreeNode
        Dim T As Integer

        Me.TreeView.BeginUpdate()
        Me.TreeView.Cursor = Cursors.WaitCursor

        'Create a node array
        ReDim oNodes(Me.Nodes.Count - 1)

        'Add all nodes to the array
        T = 0
        For Each oNode In Me.Nodes
            oNodes(T) = CType(Me.Nodes(T), RDProductTreeNode)
            T = T + 1
        Next

        'Sort the array
        Array.Sort(oNodes, New TreeNodeSorter)

        'Clear childnodes
        Me.Nodes.Clear()

        'Add the sorted childnodes
        For T = 0 To oNodes.Length - 1
            If bSortChildNodes Then oNodes(T).Sort(True)
            Me.Nodes.Add(oNodes(T))
        Next

        Me.TreeView.Cursor = Cursors.Default
        Me.TreeView.EndUpdate()
    End Sub

    ''' <summary>
    ''' This method takes care of filling the node with all required childnodes of the correct type
    ''' </summary>
    Private Sub Fill()
        Dim oFilter As PredicateExpression = Nothing

        'Show user we're busy
        Me.TreeView.BeginUpdate()
        Me.TreeView.Cursor = Cursors.WaitCursor
        'Remove childnodes
        Me.Nodes.Clear()

        'Depending on the type of node that we "are" we need to fill this node with the correct childnodes
        Select Case Me.Nodetype
            Case RDNodeType.Root
                Dim oDTs As New DeviceTypeCollection
                Dim oDT As DeviceTypeEntity

                'Get all devicetypes and sort the records
                oDTs.GetMulti(oFilter)
                oDTs.SupportsSorting = True
                oDTs.Sort(DeviceTypeFields.Desc_Short_nl.FieldIndex, System.ComponentModel.ListSortDirection.Ascending)
                'Add the childnodes to the current node
                For Each oDT In oDTs
                    Me.Nodes.Add(New RDProductTreeNode(oDT.Desc_Short_nl, oDT.ID, RDNodeType.DeviceType))
                Next
            Case RDNodeType.DeviceType
                Dim oDT As New DeviceTypeEntity(Me.ID)
                Dim oBR As BrandEntity

                'Try to fetch the devicetype and if exists, fill this node with all brands for the devicetype
                If oDT.Refetch Then
                    oDT.Brand.SupportsSorting = True
                    oDT.Brand.Sort(BrandFields.Brandname.FieldIndex, System.ComponentModel.ListSortDirection.Ascending)
                    For Each oBR In oDT.Brand
                        Me.Nodes.Add(New RDProductTreeNode(oBR.Brandname, oBR.ID, RDNodeType.Brand))
                    Next
                End If
            Case RDNodeType.Brand
                Dim oBR As New BrandEntity(Me.ID)
                Dim oMD As ModelEntity

                'Try to fetch the brand and if exists, fill this node with all models for the brand
                If oBR.Refetch Then
                    oBR.Model.SupportsSorting = True
                    oBR.Model.Sort(ModelFields.Modelname.FieldIndex, System.ComponentModel.ListSortDirection.Ascending)
                    For Each oMD In oBR.Model
                        Me.Nodes.Add(New RDProductTreeNode(oMD.Modelname, oMD.ID, RDNodeType.Model))
                    Next
                End If
            Case RDNodeType.Model
                Dim oMD As New ModelEntity(Me.ID)
                Dim oMT As ModelTypeEntity

                'Try to fetch the model and if exists, fill this node with all modeltypes for this model
                If oMD.Refetch Then
                    oMD.ModelType.SupportsSorting = True
                    oMD.ModelType.Sort(ModelTypeFields.TypeDesc.FieldIndex, System.ComponentModel.ListSortDirection.Ascending)
                    For Each oMT In oMD.ModelType
                        Me.Nodes.Add(New RDProductTreeNode(oMT.TypeDesc, oMT.ID, RDNodeType.ModelType))
                    Next
                End If
            Case RDNodeType.ModelType
                Dim oMTs As New ModelTypeEntity(Me.ID)
                Dim oMT As ModelTypeEntity

                'Try to fetch the modeltype and if exists, fill this node with all child-modeltypes for this modeltype 
                If oMTs.Refetch Then
                    oMTs.ModelType_.SupportsSorting = True
                    oMTs.ModelType_.Sort(ModelTypeFields.TypeDesc.FieldIndex, System.ComponentModel.ListSortDirection.Ascending)
                    For Each oMT In oMTs.ModelType_
                        Me.Nodes.Add(New RDProductTreeNode(oMT.TypeDesc, oMT.ID, RDNodeType.ModelType))
                    Next
                End If
        End Select
        Me.TreeView.Cursor = Cursors.Default
        Me.TreeView.EndUpdate()
    End Sub

    ''' <summary>
    ''' Refetches the current node and fills it's childnodes again
    ''' </summary>
    Public Sub Refresh()
        Me.Fill()
    End Sub

    ''' <summary>
    ''' This class is used to sort RDProductTreenodes alphabetically. It implements the IComparer interface to do so.
    ''' </summary>
    Public Class TreeNodeSorter
        Implements IComparer

        Public Function Compare(ByVal x As Object, ByVal y As Object) As Integer Implements IComparer.Compare
            Dim tx As TreeNode = CType(x, TreeNode)
            Dim ty As TreeNode = CType(y, TreeNode)

            Return String.Compare(tx.Text, ty.Text, True)
        End Function
    End Class
End Class

Ik ben nog een beetje onzeker in het OO gebeuren en weet niet of ik uberhaupt op de juiste weg ben of dat dit misschien nog makkelijker/netter/beter kan. Ik vraag dus duidelijk niet of iemand mijn code even wil debuggen of tot op de letter wil inspecteren, echter alleen of er zo op het eerste oog een goede aanpak in zit of niet. Ik heb zelf ook een hekel aan mensen die enorme lappen code neerplempen, maar op dit moment voel ik me even Bambi op het ijs
(Overigens even los van naming-conventions e.d., die zijn min of meer vastgelegd en niet door mij helaasch)
En ik heb de .Fill private gemaakt en gewrapped in een public .Refresh method

[ Voor 29% gewijzigd door RobIII op 20-03-2006 15:58 ]

[bigbeng]

RobIII schreef op maandag 20 maart 2006 @ 15:42:
[...]

...
Ik heb dit toch wel vaker gezien in de praktijk (kan het me alleen even niet heugen waar dan ook weer )

[...]

Windows Explorer op netwerkschijven bijvoorbeeld

[LaptopRookie]

Lange tijd geleden dat ik ooit ook dit zelfde principe heb gedaan in VB5/6 en gegevens uit een database. Je zou toch een event kunnen maken en die event kunnen triggeren? Vroeger was het raise event...nu throw event misschien? In de oude treeview van VB5/6 had je trouwens een property "tag" (geloof ik, om bv het pad op te slaan) dat je kon gebruiken als trigger/herkenning dat een parent gevuld is met children nodes; de bedoeling is dus om steeds 1 nivo met dummy child bij te bouwen. Sorry...ben er zelf enkele jaren uit, probeer nu C# op te pakken...hopelijk heb je wat aan mijn advies

[whoami]

In grote lijnen denk ik dat het wel meevalt.
Ik vraag me alleen af waarom je die enum binnen je class scope hebt gedefinieert, en, waar ik ook niet zo van hou, is dat ellenlang switch statement. Misschien is het beter om daar een strategy van te maken.

(Oja, en die IsVirtual vind ik maar een slechte naam )

[RobIII]

LaptopRookie schreef op maandag 20 maart 2006 @ 16:04:
Lange tijd geleden dat ik ooit ook dit zelfde principe heb gedaan in VB5/6 en gegevens uit een database. Je zou toch een event kunnen maken en die event kunnen triggeren? Vroeger was het raise event...nu throw event misschien? In de oude treeview van VB5/6 had je trouwens een property "tag" (geloof ik, om bv het pad op te slaan) dat je kon gebruiken als trigger/herkenning dat een parent gevuld is met children nodes; de bedoeling is dus om steeds 1 nivo met dummy child bij te bouwen. Sorry...ben er zelf enkele jaren uit, probeer nu C# op te pakken...hopelijk heb je wat aan mijn advies

Hoewel goedbedoeld, heb ik helaas weinig aan je advies
In VB6 had ik dit waarschijnlijk in no-time gemaakt, maar ik probeer nu naar de *kuch* betere *kuch* manier van OO te gaan dan VB6 toelaat. Met een raiseevent raise je inderdaad een event in VB6, evenals in VB.net (nog steeds dus). Het Tag property had ik in VB6 prima ge/misbruikt, maar omdat ik nu mooi mijn eigen node-class kan maken zie ik niet in waarom ik die nog zou moeten gebruiken als ik een eigen "ID" property aan mijn class kan geven. Ook om het "pad" van de node op te halen heb ik die tag niet nodig. Onder VB6 had je volgens mij net zo goed een .parent property die netjes de parent node terug gaf, en het pad heb ik an sich niet nodig omdat ik het nodetype van mijn eigen .Nodetype property kan aflezen.

whoami schreef op maandag 20 maart 2006 @ 16:13:
In grote lijnen denk ik dat het wel meevalt.

\o/

whoami schreef op maandag 20 maart 2006 @ 16:13:
Ik vraag me alleen af waarom je die enum binnen je class scope hebt gedefinieert

Wat zou een betere plek zijn dan?

whoami schreef op maandag 20 maart 2006 @ 16:13:
en, waar ik ook niet zo van hou, is dat ellenlang switch statement. Misschien is het beter om daar een strategy van te maken.

Ik wil dat inderdaad nog even uitsplitsen naar losse "subjes" als dat is wat je bedoelt.

whoami schreef op maandag 20 maart 2006 @ 16:13:
(Oja, en die IsVirtual vind ik maar een slechte naam )

Jah, die ga ik (als laatste weliswaar) aanpassen.

Ik wil graag meteen een goede manier van werken aanleren (en aanhouden), dus al je (en jullie) commentaar is zeer welkom Thanks alvast. Ik ben nu bezig met een eigen component class om te proberen van een treeview te inheriten. Dat is denk ik nog even puzzelen

bigbeng schreef op maandag 20 maart 2006 @ 16:18:
Losse subjes... gij vb6 programmeur

Dit is volgens mij wat whoami bedoelde:
http://www.dofactory.com/Patterns/PatternStrategy.aspx

Als je dan toch OO gaat, doe het dan goed

Ghehe... *schaam*
Ah zo bedoelde whoami

[ Voor 39% gewijzigd door RobIII op 20-03-2006 16:21 ]

[bigbeng]

Losse subjes... gij vb6 programmeur

Dit is volgens mij wat whoami bedoelde:
http://www.dofactory.com/Patterns/PatternStrategy.aspx

Als je dan toch OO gaat, doe het dan goed

[RobIII]

Hmmm, dat "Component Class" laten inheriten van een treeview valt nog niet mee*, maar dat is nog even puzzelen. Wat betreft die case statement vervangen door een strategy weet ik ook zo net nog niet. Zoals ik het zie zou ik dan een "iets" moeten maken met overrides die, afhankelijk van het objecttype dan de childnodes gaan vullen. Maar ze zijn allemaal van hetzelfde objecttype (RDProductTreenode) en afhankelijk van het NodeType property moeten dan de childnodes gevuld gan worden. Of zou ik dan alle "niveaus" ook moeten gaan splitsen in losse Node objecten van verschillende types volgens het advies van whoami?

[edit]
De rest (eigen treeview maken die inherit van de "windows.forms.treeview") heb ik nu voor elkaar

[ Voor 151% gewijzigd door RobIII op 20-03-2006 18:07 ]