OOP Design Geruch?

Question

Zusammenfassung
Ich bin mit dem Active Directory in Visual Basic .NET eine objektorientierte Klassenbibliothek tatsächlich das Schreiben 2005 für den Umgang

Die Bibliothek erlaubt Organisationseinheiten, Gruppen und Benutzer zu verwalten.

ich haben uns bemüht, so viel zu verallgemeinern, wie ich, wie mein Code aussehen machen könnte (vereinfacht):

Public Interface IDirectoryEntityBase 
    ReadOnly Property DistinguishedName As String 
    ReadOnly Property Domain As String 
    Property Name As String 
    ReadOnly Property Schema As String 
End Interface 

Public Interface IDirectoryEntity 
    Inherits IDirectoryEntryBase 

    Property Login As String 
End Interface 

Public MustInherit Class DirectoryEntity 
    Implements IDirectoryEntity 

    Private _distinguishedName As String 
    Private _domain As String 
    Private _name As String 
    Private _schema As String 

    Public Sub New(ByVal pName As String) 
     Name = pName 
    End Sub 

    Public ReadOnly Property DistinguishedName As String Implements IDirectoryEntryBase.Name 
     Get 
      Return _name 
     End Get 
    End Property 

    Public ReadOnly Property Domain As String Implements IDirectoryEntryBase.Domain 
     Get 
      Return _domain 
     End Get 
    End Property 

    Public Property Name As String Implements IDirectoryEntryBase.Name 
     Get 
      Return _name 
     End Get 
     Set(ByVal value As String) 
      If (String.IsNullOrEmpty(value)) Then Return 
      _name = value.Trim() 
     End Set 
    End Property 

    Public ReadOnly Property Schema As String Implements IDirectoryEntryBase.Schema 
     Get 
      Throw New NotImplementedException() 
     End Get 
    End Property 
End Class 

Public Interface IOrganizationalUnit 
    Inherits IDirectoryEntity 

    ReadOnly Property Children As ICollection(Of IDirectoryEntityBase) 
End Interface 

Public Class OrganizationalUnit 
    Inherits DirectoryEntity 
    Implements IOrganizationalUnit 

    Private _children As ICollection(Of IDirectoryEntityBase) 

    Public Sub New(ByVal pName As String) 
     MyBase.New(pName) 

     _children = new List(Of IDirectoryEntity)() 
    End Sub 

    Public ReadOnly Property Children As ICollection(Of IDirectoryEntityBase) Implements IOrganizationalUnit.Children 
     Get 
      Return _children 
     End Get 
    End Property 
End Class 

Public Interface IGroup 
    Inherits IDirectoryEntity 

    ReadOnly Property Members As ICollection(Of IDirectoryEntity) 
End Interface 

Public Class Group 
    Inherits DirectoryEntity 
    Implements IGroup 

    Private _members As ICollection(Of IDirectoryEntity) 

    Public Sub New(ByVal pName As String) 
     MyBase.New(pName) 

     _members = New List(Of IDirectoryEntity)() 
    End Sub 

    Public ReadOnly Property Members As ICollection(Of IDirectoryEntity) Implements IGroup.Members 
     Get 
      Return _members 
     End Get 
    End Property 
End Class 

Nun, wenn ich meine Instanzen immer geartetes in mein Domain.Entries durch meine Domain.Add Method, hinzugefügt haben, kann ich Rufen Sie die Domain.AcceptChanges Method, so dass alle Instanzen verarbeitet werden.

Meine Domain.Entries Eigenschaft ist eine ICollection(Of DirectoryEntryBase).

Frage
Es ist, wenn ich meine Domain.AcceptChanges Method nennen, die ich selbst, indem er in Handschellen finden wissen, welche Schema oder welche Art arbeite ich mit, da ich die OrganizationalUnit.Children oder die Group.Members Sammlungen auf je zugreifen müssen ihre Art.

Public Class Domain 
    Public Sub AcceptChanges() 
     For Each e As DirectoryEntry In Entries 
      'How may I find out what collection to work with here?' 
     Next 
    End Sub 
End Class 

Ich habe über eine Verallgemeinerung dieser Sammlung nachgedacht, aber dann ändert sich das Vokabular von einem Objekt zum anderen. Wie für eine OU, könnten wir über Kinder sprechen, wenn wir für eine Gruppe sagen Mitglieder usw. In der Tat beziehen sich diese nicht auf die gleiche Realität, so würde ich diese Sammlung aus einem schlechten Grund verallgemeinern, Ich vermute.

Irgendwelche Gedanken?

Danke!

Answer 1

Ich denke, Sie sollten die Sammlung als, sagen wir, 'BaseList', die die gemeinsamen Eigenschaften für OrganizationalUnit.Children und Group.Members enthalten würde.

Dann könnten die Klassen Children und Member diese Basisklasse erweitern und andere benutzerdefinierte Funktionen hinzufügen, die bei der Annahme von Änderungen erforderlich sind.

Also zusammenfassend:

public class BaseList 
{ 
public virtual void Persist(...); 
// Common stuff 
} 

public class Children 
{ 
public override void Persist(...) 
{ 
    // do custom stuff 
} 
} 

public class Members 
{ 
public override void Persist(...) 
{ 
    // do custom stuff 
} 
} 

Dann können Sie Schleife durch eine Sammlung von ‚BaseList‘ und rufen jedes einzelne bestehen Verfahren.