Memory leak with one-to-one associations

   I've been tracing some more memory leaks and found some odd behavior of the EntityManager.UnresolvedParentMap where it would end up holding on to detached entities - leading to a memory leak in our app.  It took some narrowing down but it seems to only happen when there is a one-to-one relationship (or at least that is where we noticed it in our app and that is the only way I could reproduce it - but perhaps it happens in other cases).  To reproduce it, I started with the NorthwindIB database and added a new table called "EmployeeDetail" that is basically a one-to-one with an Employee (I guess it is technically a One-to-OneOrZero).  It looks like this:

If I just make a new employee in an entity manager and then immediately remove it, the employee remains in the UnresolvedParentMap collection even though it is now detached.  And since it's being held by the UnresolvedParentMap, it won't ever get garbage collected and we end up with a memory leak (in our case, the Entity Manager sticks around for a while so we want to be able to evict entities and have them garbage collected).

Here is some test code that demonstrates the problem.  If we pick any other entity type (without one-to-one relationships), it will run fine.  It's just this Employee example that will break:
[TestMethod]public void TestUnresolvedParentMap()
{
    var em = new EntityManager();

    //Make a new Employee
    var e = em.CreateEntity<Employee>();
    e.EntityAspect.AddToManager();
    e.EmployeeID = 10; //Giving it an ID isn't necessary for the bug

    //Immediately remove it from the entity manager - in this case, we'd assume it 
    //  disappears forever...
    e.EntityAspect.RemoveFromManager();

    //Sanity check - it became detached and the entity manager no longer thinks it is loaded
    Assert.AreEqual(EntityState.Detached, e.EntityAspect.EntityState);
    Assert.IsFalse(em.IsEntityLoaded(e.EntityAspect.EntityKey));

    //If we break into the debugger at this point, we can see that em.UnresolvedParentMap is still 
    //   holding on to our employee even though it is detached.

    //To double check, we'll use a weak reference to hold on to the employee
    var wr = new WeakReference(e);

    //Clear out of 'strong' reference and force garbage collection to happen
    e = null;
    GC.Collect();

    //At this point, we'd expect the employee to be gone.  But it's not!
    Assert.IsFalse(wr.IsAlive);
}