Question

I have a main object which has some properties and methods. This object can have multiple parts. These parts are required. The amount of these parts is variable.

Each part has different properties and is referenced to the main object.

To accomplish this in my GUI I have a tabcontrol. The first tab is the main object. The other tabs describes the main object further. These ‘other’ tabs are the parts I mentioned above.

I am trying to design an architecture, but I can’t figure I hope yoy can help me.

As suggested from the answers, the part-tabs inherit from an interface. But how does the main know about it’s parts? The parts can’t be hardcoded because it is variable. To hardcode the parts is a violation of the OCP principle.

Also, when loading the main object, again, how does it knows about it parts? I have to ‘register’ them somewhere, but where?

Answer 1

Create interface for your parts, that can have reference to main object. And main object will contain collection of parts as Collection<IPart>

class MainObject
{
    Collection<IPart> Parts {get;set;}
}

interface IPart
{
    MainObject MainObject {get;set;}
}

class SomePartImpl : IPart
{
    //properties of this IPart implementation
}

This classes is entities. Your data service must implement logic for saving and cascade operations.
Sample wcf service(from my project):

[EnableClientAccess]
public class ModelService : LinqToEntitiesDomainService<dpirtEntities>
{
    public void InsertZone(Zone zone)
        {
            if ((zone.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(zone, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Zones.AddObject(zone);
            }
        }

        public void UpdateZone(Zone currentZone)
        {
            Zone originalZone = this.ChangeSet.GetOriginal(currentZone);
            if ((currentZone.EntityState == EntityState.Detached))
            {
                if (originalZone != null)
                {
                    this.ObjectContext.Zones.AttachAsModified(currentZone, originalZone);
                }
                else
                {
                    this.ObjectContext.Zones.Attach(currentZone);
                }
            }

            foreach (Document doc in this.ChangeSet.GetAssociatedChanges(currentZone, o => o.Documents))
            {
                ChangeOperation op = this.ChangeSet.GetChangeOperation(doc);
                switch (op)
                {
                    case ChangeOperation.Insert:
                        if ((doc.EntityState != EntityState.Added))
                        {
                            if ((doc.EntityState != EntityState.Detached))
                            {
                                this.ObjectContext.ObjectStateManager.ChangeObjectState(doc, EntityState.Added);
                            }
                            else
                            {
                                this.ObjectContext.AddToDocuments(doc);
                            }
                        }
                        break;
                    case ChangeOperation.Update:
                        this.ObjectContext.Documents.AttachAsModified(doc, this.ChangeSet.GetOriginal(doc));
                        break;
                    case ChangeOperation.Delete:
                        if (doc.EntityState == EntityState.Detached)
                        {
                            this.ObjectContext.Attach(doc);
                        }
                        this.ObjectContext.DeleteObject(doc);
                        break;
                    case ChangeOperation.None:
                        break;
                    default:
                        break;
                }
            }
        }

        public void DeleteZone(Zone zone)
        {
            if ((zone.EntityState == EntityState.Detached))
            {
                this.ObjectContext.Zones.Attach(zone);
            }
            this.ObjectContext.Zones.DeleteObject(zone);
        }
}