How to debug PurgeDeletedObjects

Our developers suppose that the issue is in objects that reference objects that cannot be deleted. You can find these objects via the following code:

    public static class GCRootsFindHelper {
        public static IEnumerable FindRoots(IXPSimpleObject theObject) {
            return FindRoots(theObject.Session, theObject);
        }
        public static IEnumerable FindRoots(Session session, params object[] objects) {
            return FindRoots(session, (IEnumerable)objects);
        }
        public static IEnumerable FindRoots(Session session, IEnumerable notPurgedObjects) {
            ArrayList rv = new ArrayList();
            ArrayList toProcess = new ArrayList(notPurgedObjects.Cast<object>().ToArray());
            ObjectSet processed = new ObjectSet();
            while(toProcess.Count > 0) {
                object o = toProcess[toProcess.Count - 1];
                toProcess.RemoveAt(toProcess.Count - 1);
                if(processed.Contains(o))
                    continue;
                processed.Add(o);
                if(session.IsObjectMarkedDeleted(o)) {
                    foreach(object r in session.CollectReferencingObjects(o, PersistentCriteriaEvaluationBehavior.InTransaction, true)) {
                        if(!processed.Contains(r))
                            toProcess.Add(r);
                    }
                } else {
                    rv.Add(o);
                }
            }
            return rv;
        }
    }

This function was really helpful. You should consider to add it directly on the session object.
I could find out, that an older object instance is not deleted when overwritten:

        private LocalizedString localizedInformation;
        [Aggregated]
        public LocalizedString LocalizedInformation
        {
            get { return localizedInformation; }
            set
            {
                if (localizedInformation != null && localizedInformation != value)
                {
                    // Delete old string.
                    localizedInformation.Delete();
                }
                SetPropertyValue<LocalizedString>("LocalizedInformation", ref localizedInformation, value);
            }
        }

If I don't add the Delete() method, the old value when setting the property will not be deleted.
Is this by design?

Thank you for your idea. I will pass it to our developers.
Aggregated references are not deleted by default when the property value is changed. If one requires this logic, he/she needs to take care of this, as you did in your code snippet.

But this is what I have asked DevExpress longtime ago, and the answer was, if the property is attributed with [Aggregated], the objects will be deleted. And I was using this approach with simpler objects, and they were deleted.
Is [Aggregated] obsolete now?

I think there was some kind of misunderstanding about this attribute. The Aggregated deletes related objects only when the master object is deleted. In spite of the fact that, most probably, this functionality worked in a previous version as you described, it was not designed to operate in such a manner. The [Aggregated] attribute is not obsolete, it still works just as described in our documentation. Should you have any additional questions in this regard, do not hesitate to contact me.

I have also posted an Answer, so that you can close this ticket.