Question

In a software system a one-to-one relationship must be modeled between two objects where an active status exists for the relationship.

In other words, ObjectA has a one-to-one relationship to ObjectB (without a back pointer) where the relationship can be either active or inactive. There might also be additional attributes associated with the relationship.

What is the best way to model this scenario using object orientation in .NET?

Answer 1

It depends if the activation of a relationship is part of the behavior of the system you want to model.

‘There might also be additional attributes associated with the relationship.’

So that sounds like you would want to model more than just a reference. The a containing instance of b will work in simple situations, where the relationship is not part of the behavior of the system, but just a technical implementation.

If you want to activate/deactivate/activate (without knowing/remembering the objectB activated), the ‘null modeling’ will not work (because you would have lost the reference, and you would lose the information about the relationship). Or for instance where, at a later stage, you would want to reactivate the relationship, without a reference to both a and b, but to the relationship. So seeing the relationship as a first class citizen of the model.

You could then do something like this (but this could be complete overkill, and just to show a modelling of relationships as part of your domain):

_{(source: googlecode.com)}

The objectA uses an ObjectB proxy, that will act as an ObjectB, but it actually has a reference to the unidirectional relationship to ObjectB. The ObjectB proxy can implement behavior on what to do when the relationship is not active.

In code:

using System; using System.Collections.Generic; using System.Linq; using System.Text;  namespace ActivatableRelationshipExample {     public interface IActivatable     {         void Activate();         void Deactivate();         bool IsActive { get; }     } }  using System; using System.Collections.Generic; using System.Linq; using System.Text;  namespace ActivatableRelationshipExample {     public interface IRelationShip<TSource,TDestination> : IActivatable     {         TDestination Destination { get; }         TSource Source { get; }     } }  using System; using System.Collections.Generic; using System.Linq; using System.Text;  namespace ActivatableRelationshipExample {     public class ObjectA     {         // you could also have an ObjectB reference here         // and fill it with an ObjectBProxy instance         // in the constructor. thought this would         // explain the example a bit better         private readonly ObjectBProxy proxy;          public ObjectA(ObjectB b)         {             proxy = new ObjectBProxy(b);         }         public void AMethodUsingB()         {             proxy.BMethod();         }     } }  using System; using System.Collections.Generic; using System.Linq; using System.Text;  namespace ActivatableRelationshipExample {     public class ObjectB     {         public virtual void BMethod()         {          }     } }  using System; using System.Collections.Generic; using System.Linq; using System.Text;  namespace ActivatableRelationshipExample {     public class ObjectBProxy : ObjectB, IActivatable     {         private readonly UniDirectionalRelationship<ObjectB> relation;          public ObjectBProxy(ObjectB to)         {             this.relation = new UniDirectionalRelationship<ObjectB>(to);         }          public override void BMethod()         {             if (relation.IsActive)             {                 relation.Destination.BMethod();             } else             {                 // do some specific logic here             }         }          public void Activate()         {             relation.Activate();         }          public void Deactivate()         {             relation.Deactivate();         }          public bool IsActive         {             get { return relation.IsActive; }         }     } }  using System; using System.Collections.Generic; using System.Linq; using System.Text;  namespace ActivatableRelationshipExample {     public class RelationshipNotActiveException : Exception     {         public RelationshipNotActiveException(string message) : base(message)         {         }          public RelationshipNotActiveException(string message, Exception innerException) : base(message, innerException)         {         }     } }   using System; using System.Collections.Generic; using System.Linq; using System.Text;  namespace ActivatableRelationshipExample {     public class UniDirectionalRelationship<TDestination> : IRelationShip<object,TDestination> where TDestination :class     {         private bool active = true;         private readonly TDestination destination;          public UniDirectionalRelationship(TDestination destination)         {             if(destination == null)             {                 throw new ArgumentNullException('destination','destination cannot be null');             }             this.destination = destination;         }         public void Activate()         {             active = true;         }         public void Deactivate()         {             active = false;         }          public virtual bool IsActive         {             get { return active; }         }          public virtual TDestination Destination         {             get             {                 if (active)                 {                     return destination;                 }                  throw new RelationshipNotActiveException('the relationship is not active');             }         }          public virtual object Source         {             get { throw new NotSupportedException('Source is not supported'); }         }     } }