This article will cover the Pair class, highlight its strengths, compare it with Arrays and Dictionaries, and assist you in identifying the most suitable tool for your needs.

What is the Pair Class?

In Xojo, the Pair class is a basic structure that stores two associated values: Left and Right. These properties can be of any data type, allowing you to pair together any two pieces of data.

Var myPair As New Pair("Pie", 15)
// or
Var myPair As Pair = "Pie" : 15

In the example above, myPair.Left is "Pie" (a String), and myPair.Right is 15 (an Integer). The Pair class is especially handy when you need to associate two pieces of data without the overhead of creating a dedicated class or structure.

Advantages of Using the Pair Class

1. Returning Multiple Values from a Method

Sometimes, you need a method to return more than one value. While you could use ByRef parameters or create a custom class, using a Pair provides a quick and clean solution.

Example:

Public Function GetMinMax(values() As Integer) As Pair
  Var minValue As Integer = values(0)
  Var maxValue As Integer = values(0)
  
  For Each value As Integer In values
    If value < minValue Then minValue = value
    If value > maxValue Then maxValue = value
  Next
  
  Return New Pair(minValue, maxValue)
End Function

// Usage
Var numbers() As Integer = Array(5, 2, 8, 3, 9)
Var result As Pair = GetMinMax(numbers)
MessageBox("Min: " + result.Left.StringValue + ", Max: " + result.Right.StringValue)

2. Associating Related Data Temporarily

When processing data, you might need to temporarily associate two values without persisting them or creating a complex data structure.

Example:

Var people() As Pair
people.Append(New Pair("Alice", 30))
people.Append(New Pair("Bob", 25))
people.Append(New Pair("Charlie", 35))

For Each person As Pair In people
  MessageBox(person.Left.StringValue + " is " + person.Right.IntegerValue.ToString + " years old.")
Next

3. Representation of Key-Value Pairs

While Dictionaries are designed for key-value storage, sometimes you might need to represent key-value pairs explicitly, such as when iterating over a Dictionary’s entries.

Example:

Var dict As New Dictionary
dict.Value("Red") = "#FF0000"
dict.Value("Green") = "#00FF00"
dict.Value("Blue") = "#0000FF"

For Each key As Variant In dict.Keys
  Var entry As New Pair(key, dict.Value(key))
  MessageBox(entry.Left.StringValue + " color code is " + entry.Right.StringValue)
Next

Comparison: Pair vs. Arrays vs. Dictionaries

Understanding when to use the Pair class over Arrays or Dictionaries is crucial for writing efficient code.

Pair

• Structure: Holds exactly two related values (Left and Right).
• Type Safety: Both Left and Right can be any data type.
• Usage: Ideal for associating two pieces of data temporarily or for methods that need to return two values.
• Performance: Lightweight and minimal overhead.

Arrays

• Structure: Ordered collection of elements, accessible by index.
• Type Safety: Elements are of the same data type (unless you use Variant arrays).
• Usage: Best when dealing with lists of items where order matters.
• Performance: Efficient for iterating over large collections.

Dictionaries

• Structure: Collection of key-value pairs, with unique keys.
• Type Safety: Keys are typically String or Integer, values can be any data type.
• Usage: When you need fast lookup of values by keys.
• Performance: Optimized for key-based access; overhead of hash table management.

Considerations for Using Pair Instead of Arrays or Dictionaries

• Simplicity: When you need to associate two items without creating a complex structure.
• Temporary Associations: For short-lived pairings within methods or loops.
• Returning Multiple Values: When methods need to return two related results.

Best Practices with Pair

• Immutable Data: Since Pair is a class, be cautious when modifying Left or Right properties, especially if the Pair is shared among different parts of your code.
• Descriptive Code: Use comments or naming conventions to clarify what Left and Right represent, as they do not provide semantic meaning on their own.

Example:

// Pair: Left = Product Name, Right = Price
Var productPair As New Pair("Laptop", 999.99)

Drawbacks and Constraints of the Pair Class

• Lack of Clarity: Unlike custom classes or structures, Pair does not convey the meaning of its contents through property names.
• Fixed Size: Limited to exactly two items; for more complex data, consider using a class or structure.
• Reference Type: Being a class, Pair is a reference type, which can have implications for memory management and threading.

Conclusion

The Pair class is a handy tool that can simplify your code when you need to associate two related values. While it doesn’t replace Arrays or Dictionaries, the Pair class is valuable in particular situations that prioritize simplicity and efficiency.

Resources:

• Learn more about Pair
• Learn more about Arrays
• Learn more about Dictionary

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

After all, when using the following snippet of code we could (wrongly) expect that the contents stored in the ATarget Array would be the same that the ones stored in the ASource Array. Of course, and at a first glance, this is the case. Try to write the following fragment in the Opening Event of a new Xojo Project or Method created by yourself (don’t forget to call such method, if you decide to follow that path):

Var ASource() As Integer = Array(1,2,3,4,5,6,7,8)
Var ATarget() As Integer
ATarget = ASource

If you set a breakpoint in the last line of code and execute your test app, then you’ll see that, as exepected, the contents of the ATarget() Array are the same that the ones stored by the ASource() Array. (Navigate through the Debugger Inspector Panel to inspect these variables)

However, what happens if we add the following line of code at the end of our fragment of code?:

ASource.ResizeTo(-1)

In this case we will be redimensioning the storage capacity of our ASource() Array with a total of 0 items. That is, in practice we will be emptying the Array.

As result of this operation you could expect that, while the contents of the ASource() variable are emptied, your ATarget() Array will continue storing their items. 

The truth is that it doesn’t.

This is how Array Assignment Works

When we use the assignement operator (=) to set the values (items) of an Array to another one, what in fact happens behind the scenes is that the target Array will store only a reference to the source Array (the right-side value of the assignement operator), and not a copy of the values/objects stored.

Thus, and because they are references, all the operations we do on the source Array will be reflected in the target Array.

If you want to see that for yourself, try to delete the previous breakpoint and put a new one in the last line of code added.

When you run the now modified code, using the IDE Debugger feature to run the line of code where the Debugger has stopped, you’ll see how both Array variables (ASource and ATarget) reveal that their dimensions are -1. That is: when you clean the source Array using the ResizeTo method that change is also reflected in the target Array.

Why does this happens?

Better Understanding: Reference vs Copy

All the apps you execute in your computer or any other device are stored in memory, both the code to be executed and the Objects created and used during all the application lifetime.

For example, when we declare a variable in our example code (in this case an Array of Integer type), we can think about that variable as a mere label pointing to the starting cell of memory where will be stored the values later. We could visually represent that as this:

So, this could be the visual representation of the memory when we add new items on the Array, although the real Xojo implementation of the stored values for an Array can differ from this. It doesn’t needs to be a contiguous region of memory or even the same structure to represent an Array in memory:

However, when we use the assignment operator (“=”) to set the contents of our ASource() Array to the ATarget Array what happens is that the value set for the ATarget() variable is the same memory position used by the ASource() variable; so all the operations made on the ASource() object (memory region) will be also reflected on ATarget():

Conversely, when we iterate the items stored in the ASource() Array and use the Add method on the ATarget() Array, what happens is that the target Array will get and use its own memory region to store its own copy of the added values and, thus, is independent of the memory region used by the source Array.

This way, all the opeations made on the items pointed by the source Array will not be reflected on the target Array:

Copying Array Items

So, if what we really want to do is have our target Array stores its own copies of a source Array items, then we need to change from a simple assignment to an iteration and addition of the iterated values.

For that we need to use the Add Method on the target Array; while to access every item stored in the source Array we need to employ its index position in the Array (for example, ASource(0) will get the first item stored in the Array, while ASource.LastIndex will gives us the index position of the last added value).

Replace the previous code example with this one:

Var ASource() As Integer = Array(1,2,3,4,5,6,7,8)
Var ATarget() As Integer 
Var Max As Integer = ASource.LastIndex
For n As Integer = 0 to Max
 ATarget().Add ASource(n)
Next
ASource.ResizeTo(-1)

Now, if you set the a Debugger breakpoint in the last line of code and execute the application, then you’ll see, after executing the last line of code, our ATarget() Array will keep its own set of values, even after redimensioning the ASource() Array with the equivalent to “reserve storage for no items”, thus cleaning the region of memory used by such variable.

You can see all this in action in the following video (in Spanish):

Javier Rodri­guez has been the Xojo Spanish Evangelist since 2008, he’s also a Developer, Consultant and Trainer who has be using Xojo since 1998. He manages AprendeXojo.com and is the developer behind the GuancheMOS plug-in for Xojo Developers, GuancheID, AXImageCanvas, Markdown Parser for Xojo, HTMLColorizer for Xojo and the Snippery app, among others.

It turns out it is super-easy to use the Sort(Delegate) method to create your own sorting method and then pass it to the call to sort.

The sorting method would use StrComp to get a case-sensitive sort and could look like this:

Public Function CaseSensitiveSort(value1 As String, value2 As String) as Integer
   Return StrComp(value1, value2, Realbasic.StrCompCaseSensitive)
End Function

And then you can call it like this:

Dim s() As String = Array("alpha", "Test", "Beta", "candy")
s.Sort(AddressOf CaseSensitiveSort)

To get this sorted result:

• Beta
• Test
• alpha
• candy

Last month, the family went mini-golfing for my son’s birthday. It was a lovely course called Pirate’s Cove Adventure Golf right next to the ocean. But they didn’t have scoring stands and we had to use a tiny pencil on a little cardboard scorecard to keep score. So this week’s app is a simple iOS app track of mini-golf scores!

The iOS app has two screens. The main screen has a giant Table that lists all the 18 holes. You tab on the detail button for a row (it’s the “I” icon) to go to the scoring screen.

The scoring screen has places to enter scores for up to four players. It also keeps a running score total for each player.

The scores are stored in a two-dimensional array that is 4 x 18. Keep in mind that Xojo arrays are 0-based so this array is declared, as a property on the App object, with these dimensions: 3 x 17.

Download the Mini Golf project.

This app is pretty simple, so here are some ideas for enhancements:

• Enter and display player names
• Allow for more than 4 people on a team
• Allow entry for “par” for each hole
• Give each hole a name and save it separately so you can reload it should you go there to play often

Download and check out earlier projects:

• Week 3: Dogs Up!
• Week 2: Password Generator
• Week 1: Color Picker