Problems with memory leaks using interface?

Question

I have a method that returns a IInterface, the method contain a dictionary created like this:

Dictionary:= TDictionary<string, IInterface>.Create;

That contains:

Dictionary.Add('key', TPerson.Create(DatabaseCon)as IInterface);

When I quit my ongoing program I get an error message memory leaks on the object Tperson.

I've tried in the class destructor method the following:

  private //Global variabels
    Person:TPerson;
    I: IInterface;

begin // in the destructor method of the class
   Person:= IInterface as TPerson;
   Person.Free;
end;

But I still get the error... How do I release the TPerson.Create(DatabaseCon) as IInterface)? Or would it be better to save the TPerson as a string in an INI file and then drag the string name out and turn it into an object .. But how??

The structure of the program:

Inf1= Interface(IInterface)
//some functions 
Inf2=Interface(Inf1)
//Some functions
TPerson= class(TInterfacedPersistent,Inf2)
// All my functions.

I can get it to work if I:

Dictionary.Add ('key', Person) as IInterface);

Where I in the Create method of the class write:

Person:= TPerson.Create(DatabaseCon);

and in the destructor method writes:

Person.Free;

but is it not wrong to do so? since the class person must first be instantiated when I access the dictionary?

Answer 1

The most likely explanation is that TPerson does not use interface reference counting to manage lifetime. To be sure we'd need to know exactly how TPerson implements IInterface. Unfortunately that key detail was omitted from the question.

If TPerson derives from TInterfacedObject, and so has lifetime managed by reference counting, then your code will not leak. So, I'm reasonably confident that the problem is that your class's implementation of IInterface does not free the object when its reference count goes to zero.

Assuming I am correct, then you have a couple of options to resolve the issue:

1. Change your class to implement interface reference counted lifetime management.
2. Use TObjectDictionary<TKey,TValue> rather than TDictionary<TKey,TValue>. Arrange that the value type TValue is TPerson rather than IInterface. And arrange that the dictionary owns its values so that it can free them when they are removed.

---

Update: Your update shows that my hunch was correct. Your class does not manage lifetime with interface reference counting.