Add class to dictionary

[tiredofit]

In the following code to find unique values and aggregate amounts and volumes:

Option Explicit
Sub Start()
    Dim dict As Scripting.Dictionary
Set dict = ReadData

End Sub

Function ReadData() As Dictionary
    Dim dict As Scripting.Dictionary
Set dict = New Scripting.Dictionary

Dim rg As Range
Set rg = Sheet1.Range("A1").CurrentRegion

Dim i As Long, CustomerID As String, Amount As Currency
Dim Volume As Long, oCustomer As Class1

For i = 2 To rg.Rows.Count

CustomerID = rg.Cells(i, 1).Value

Amount = rg.Cells(i, 4).Value
Volume = rg.Cells(i, 5).Value

If dict.Exists(CustomerID) Then

Set oCustomer = dict(CustomerID)

Else

Set oCustomer = New Class1

dict.Add CustomerID, oCustomer

End If

oCustomer.Amount = oCustomer.Amount + Amount
oCustomer.Volume = oCustomer.Volume + Volume

    Next i
    Set ReadData = dict

End Function

This is Class1:

Option Explicit

Private pAmount As Currency
Private pVolume As Long
Public Property Get Amount() As Currency
    Amount = pAmount

End Property
Public Property Let Amount(ByVal vNewValue As Currency)
    pAmount = vNewValue
End Property
Public Property Get Volume() As Long
    Volume = pVolume

End Property
Public Property Let Volume(ByVal vNewValue As Long)
    pVolume = vNewValue

End Property

can someone please explain this line:

If dict.Exists(CustomerID) Then
Set oCustomer = dict(CustomerID) 'PUZZLES ME ?????
Else
Set oCustomer = New Class1
dict.Add CustomerID, oCustomer
End If

I understand that if the dictionary with the key CustomerID DOES NOT exist, then create a new instance of Class1 and add this instance of Class1 to the dictionary with CustomerID as the key but if the key CustomerID DOES exist, what is "Set oCustomer = dict(CustomerID)" doing?

Thanks

 

[Domenic]

dict(CustomerID) returns the class object associated with CustomerID. The class object is then assigned to oCustomer, which is an object variable that is capable of holding a class object of the same type.

 

[tiredofit]

dict(CustomerID) returns the class object associated with CustomerID. The class object is then assigned to oCustomer, which is an object variable that is capable of holding a class object of the same type.

I understand what you mean by:

"The class object is then assigned to oCustomer, which is an object variable that is capable of holding a class object of the same type."

but what do you mean a the start, namely:

dict(CustomerID) returns the class object associated with CustomerID.

 

[Domenic]

Let's say that the key is "A", and that the item is a class object (ie oCustomer). So, as you know, we first add an item to the dictionary like this...

dict.add key:="A", item:=oCustomer

... or if you prefer, without named arguments...

dict.add "A", oCustomer

Then we can retrieve the item, in this case the class object, by using the Item method and passing it a key...

dict.Item("A")  --> returns the item (ie. the class object) associated with the key (ie. "A")

Note that you can also do it this way...

dict("A") --> also returns the item associated with the key

The Item method is implicit.

***EDITED***

So this means that we can assign the returned object to an object variable of the same type and access the properties like this...

Set oCustomer = dict("A")
debug.print oCustomer.Amount
debug.print oCustomer.Volume

...or we can also access them directly like this...

debug.print dict("A").Amount
debug.print dict("A").Volumne

Hope this helps!

 

[tiredofit]

Let's say that the key is "A", and that the item is a class object (ie oCustomer). So, as you know, we first add an item to the dictionary like this...

dict.add key:="A", item:=oCustomer

... or if you prefer, without named arguments...

dict.add "A", oCustomer

Then we can retrieve the item, in this case the class object, by using the Item method and passing it a key...

dict.Item("A")  --> returns the item (ie. the class object) associated with the key (ie. "A")

Note that you can also do it this way...

dict("A") --> also returns the item associated with the key

The Item method is implicit.

Hope this helps!

Great, I get it now, thanks.

 

[Domenic]

Please have a look at my edited post.

Cheers!

 

[tiredofit]

Please have a look at my edited post.

Cheers!

Yes very clear.

My problem with OOP is that reading material often states:

Dim dict As Scripting.Dictionary

then it talks about instantiating dict like:

Set dict = New Scripting.Dictionary

However as in the original code at the start of the post, we actually have:

Dim dict As Scripting.Dictionary
Set dict = ReadData

obviously ReadData is function of TYPE dictionary, otherwise you'd get a compile error.

It's these techniques that I find books tend to gloss over and not explain in greater detail.

 

[Domenic]

However as in the original code at the start of the post, we actually have:

Dim dict As Scripting.Dictionary
Set dict = ReadData

obviously ReadData is function of TYPE dictionary, otherwise you'd get a compile error.

I guess, more precisely, ReadData is a function that returns a dictionary object. So ReadData actually creates the dictionary object, not the calling procedure. Then, it adds items to the collection, then it returns the dictionary object to calling procedure, and then it's assigned to the object variable dict, which is declared as a Dictionary object, and so capable of holding an object of that type.

 

[tiredofit]

I guess, more precisely, ReadData is a function that returns a dictionary object. So ReadData actually creates the dictionary object, not the calling procedure. Then, it adds items to the collection, then it returns the dictionary object to calling procedure, and then it's assigned to the object variable dict, which is declared as a Dictionary object, and so capable of holding an object of that type.

Very thorough, couldn't have made it any clearer, thanks!

at times, I tend to view (incorrectly) programming to be like maths, eg ax+ay = a(x+y).

So in the code, as I see:

Dim dict As Scripting.Dictionary

in Sub Start and I also see it in Function ReadData() As Dictionary, I instinctively think I could have declared dict at the module level but would be wrong.

 

[Domenic]

in Sub Start and I also see it in Function ReadData() As Dictionary, I instinctively think I could have declared dict at the module level but would be wrong.

Actually, the dictionary object could have been declared at the module level, and then both procedure and function, along with any other procedures or functions in the module, would have direct access to it. So there would be no need to pass the dictionary object from the function back to the calling procedure. However, it's considered poor programming practice.