OOP Design Smell?

Question

Résumé
J'écris en fait une bibliothèque de classes orientée objet pour faire face à l'Active Directory en .NET 2005. Visual Basic

La bibliothèque permet de gérer les unités organisationnelles, groupes et utilisateurs.

Je me suis efforcé de généraliser autant que je pouvais faire mon regard de code comme (simplifié):

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 

Maintenant, quand je l'ai ajouté mes instances de quel type dans mon Domain.Entries par mon Domain.Add Method, je peux appelez le Domain.AcceptChanges Method pour que toutes les instances soient traitées.

Mon Domain.Entries propriété est un ICollection(Of DirectoryEntryBase).

Question
Il est quand je l'appelle mon Domain.AcceptChanges Method que je me trouve menotté en ayant à savoir ce schéma ou quel type je travaille avec, car je dois accéder au OrganizationalUnit.Children ou les Group.Members collections en fonction de leur type. J'ai pensé à généraliser cette collection, mais le vocabulaire change d'un objet à l'autre. Comme pour une OU, nous pourrions parler de Enfants, quand pour un Groupe, nous dirons Membres, etc. En fait, ceux-ci ne se réfèrent pas à la même réalité, donc je vais généraliser cette collection pour une mauvaise raison, J'imagine.

Des pensées?

Merci!

Answer 1

Je pense que vous devriez genralize la collection comme, par exemple, un « BaseList » qui abritera les propriétés communes pour les OrganizationalUnit.Children et Group.Members.

Ensuite, les enfants et les classes membres pourraient étendre cette classe de base et ajouter d'autres fonctionnalités personnalisées qui doit se produire lorsque vous acceptez les modifications.

Donc, en résumé:

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 
} 
} 

boucle Vous pouvez ensuite à travers une collection de « BaseList » et appeler chaque méthode individuelle persistera.