CODEWITHSUNDEEP
delphi
awmross
awmross

Reputation: 3839

Do Delphi generic collections override equals?

This is a question for the generic collection gurus.

I'm shocked to find that TList does not override equals. Take a look at this example:

list1:=TList<String>.Create;       
list2:=TList<String>.Create;

list1.Add('Test');
list2.Add('Test');

Result:=list1.Equals(list2);

"Result" is false, even though the two Lists contain the same data. It is using the default equals() (which just compares the two references for equality).

Looking at the code, it looks like the same is true for all the other generic collection types too.

Is this right, or am I missing something??

It seems like a big problem if trying to use TLists in practice. How do I get around this? Do I create my own TBetterList that extends TList and overrides equals to do something useful? Or will I run into further complications with Delphi generics...... ?

[edit: I have one answer so far, with a lot of upvotes, but it doesn't really tell me what I want to know. I'll try to rephrase the question]

In Java, I can do this:

List<Person> list1=new ArrayList<Person>();
List<Person> list2=new ArrayList<Person>();
list1.add(person1);
list2.add(person1);
boolean result=list1.equals(list2);

result will be true. I don't have to subclass anything, it just works.

How can I do the equivalent in Delphi?

If I write the same code in Delphi, result will end up false.

If there is a solution that only works with TObjects but not Strings or Integers then that would be very useful too.

Upvotes: 1

Views: 2277

Answers (3)

awmross
awmross

Reputation: 3839

I looked around and found a solution in DeHL (an open source Delphi library). DeHL has a Collections library, with its own alternative List implementation. After asking the developer about this, the ability to compare generic TLists was added to the current unstable version of DeHL.

So this code will now give me the results I'm looking for (in Delphi):

list1:=TList<Person>.Create([Person.Create('Test')]);
list2:=TList<Person>.Create([Person.Create('Test')]);

PersonsEqual:=list1.Equals(list2); // equals true

It works for all types, including String and Integer types

stringList1:=TList<string>.Create(['Test']);
stringList2:=TList<string>.Create(['Test']);

StringsEqual:=stringList1.Equals(stringList2); // also equals true

Sweet!

You will need to check out the latest unstable version of DeHL (r497) to get this working. The current stable release (0.8.4) has the same behaviour as the standard Delphi TList.

Be warned, this is a recent change and may not make it into the final API of DeHL (I certainly hope it does).

So perhaps I will use DeHL instead of the standard Delphi collections? Which is a shame, as I prefer using standard platform libraries whenever I can. I will look further into DeHL.

Upvotes: 2

Kenneth Cochran
Kenneth Cochran

Reputation: 12064

What it boils down to is this:

In Java (and .NET languages) all types descend from Object. In Delphi integers, strings, etc. do not descend from TObject. They are native types and have no class definition.

The implications of this difference are sometimes subtle. In the case of generic collections Java has the luxury of assuming that any type will have a Equals method. So writing the default implementation of Equals is a simple matter of iterating through both lists and calling the Equals method on each object.

From AbstractList definition in Java 6 Open JDK:

public boolean equals(Object o) {
    if (o == this)
        return true;
    if (!(o instanceof List))
        return false;

    ListIterator<E> e1 = listIterator();
    ListIterator e2 = ((List) o).listIterator();
    while(e1.hasNext() && e2.hasNext()) {
        E o1 = e1.next();
        Object o2 = e2.next();
        if (!(o1==null ? o2==null : o1.equals(o2)))
            return false;
    }
    return !(e1.hasNext() || e2.hasNext());
}

As you can see the default implementation isn't really all that deep a comparison after all. You would still be overriding Equals for comparison of more complex objects.

In Delphi since the type of T cannot be guaranteed to be an object this default implementation of Equals just won't work. So Delphi's developers, having no alternative left overriding TObject.Equals to the application developer.

Upvotes: 3

Deltics
Deltics

Reputation: 23036

Generics aren't directly relevant to the crux of this question: The choice of what constitutes a valid base implementation of an Equals() test is entirely arbitrary. The current implementation of TList.Equals() is at least consistent will (I think) all other similar base classes in the VCL, and by similar I don't just mean collection or generic classes.

For example, TPersistent.Equals() also does a simple reference comparison - it does not compare values of any published properties, which would arguably be the semantic equivalent of the type of equality test you have in mind for TList.

You talk about extending TBetterList and doing something useful in the derived class as if it is a burdensome obligation placed on you, but that is the very essence of Object Oriented software development.

The base classes in the core framework provide things that are by definition of general utility. What you consider to be a valid implementation for Equals() may differ significantly from someone else's needs (or indeed within your own projects from one class derived from that base class to another).

So yes, it is then up to you to implement an extension to the provided base class that will in turn provide a new base class that is useful to you specifically.

But this is not a problem.

It is an opportunity.

:)

You will assuredly run into further problems with generics however, and not just in Delphi. ;)

Upvotes: 7

Related Questions