Instance methods that modify multiple objects

Question

I'm currently in the process of rewriting an older library for managing documents.

I'm having difficulties to specify an interface for the management of links between those documents. Previously they have been specified simply as the primary keys of the other documents. But in order to have a more object-oriented interface the primary keys should be replace with objects of the actual documents.

Now the implementation of the AddLink/RemoveLink methods are a problem because if you add a link from document A to document B another link from B to A is automatically added.

A more general description of the problem would be: How can you change properties that depend on each other but are in different objects (possibly behind interfaces).

Things I've tried so far:

• Using internal methods to change the links "behind the back" of the object

  This only works for normal classes but when interfaces are involved (my case) it won't work.

• Using some kind of recursion detection mechanism, to simply stop at that point

  This works but it's a hack in my opinion

• Using event handlers (doesn't work for adding, only for removing)

• Giving up on the idea of having direct access to the objects and just continue to use the primary keys

Example Code:

class Document
{
    private List<Document> links;

    public IReadOnlyList<Document> Links { get { return links.AsReadOnly(); } }

    public void AddLink(Document other)
    {
        links.Add(other);
        // How to add this to other.Links?
        // Just calling other.AddLink(this) would cause infinite recursion
    }
}

Answer 1

OK, I don't see the advantage of having the object rather than the id, but..

one way to do this is to inject a Document/Link repository. so when you add the link, it gets added (as a two way link) to the repository. Both documents generate their links when queried by checking the (shared) repository.

ie.

    /// <summary>
    /// inject into documents, this access a shared database or its a shared instance etc
    /// </summary>
    public interface IRepository
    { 
        Document GetDocument(string id);

        /// <summary>
        /// get all the links which are linked to or from the Id
        /// </summary>
        /// <param name="documentId"></param>
        List<Document> GetLinks(string documentId);

        /// <summary>
        /// add link refernce both docs
        /// </summary>
        /// <param name="linkFromId"></param>
        /// <param name="linkToId"></param>
        void AddLink(string linkFromId, string linkToId);
    }

    public class Document
    {
        public string Id {get;set;}

        private IRepository repo;

        public Document(IRepository repo)
        {
            this.repo = repo;
        }

        public IReadOnlyList<Document> Links 
        { 
            get 
            { 
                return repo.GetLinks(this.Id).AsReadOnly();
            } 
        }

        public void AddLink(Document other)
        {
            repo.AddLink(this.Id,other.Id);
        }
    }