implémentation de la composition et de l'agrégation en C#?

Question

Comment puis-je/(quelle est la meilleure façon de) implémenter la composition et l'agrégation en C#?

Merci 123Developer

Answer 1

C'est une question assez abstraite, étant donné que les deux composition & agrégation sont assez similaires & vraiment seulement différent conceptuellement et pas nécessairement au niveau du code. (c'est-à-dire que vous pourriez considérer une voiture ayant un moteur comme étant une composition, et un chien ayant des puces à agréger, mais rien ne vous empêche de les implémenter de la même manière si vous les modélisiez en code).

Cependant, si vous voulez briser les différences & essayer & ajouter la force des décisions de conception de logiciels pour mettre en évidence les différences que je suppose que vous pourriez faire quelque chose comme ça ... prendre an example from Wikipedia:

agrégation diffère de l'ordinaire composition en ce qu'elle n'implique pas la propriété. Dans la composition, lorsque l'objet propriétaire est détruit, les objets contenus le sont également. En agrégation, ce n'est pas nécessairement vrai. Par exemple, une université possède plusieurs départements (par exemple, la chimie), et chaque département a un certain nombre de professeurs. Si l'université ferme ses portes, les départements n'existeront plus, mais les professeurs de ces départements continueront d'exister. Par conséquent, une université peut être considérée comme une composition de départements, alors que les départements ont une agrégation de professeurs. En outre, un professeur peut travailler dans plus d'un département, mais un département ne peut pas faire partie de plus d'une université.

Vous pouvez construire ce code pour le représenter (avec autant d'indications contrived de composition/agrégation):

public class University : IDisposable 
{ 
    private IList<Department> departments = new List<Department>(); 

    public void AddDepartment(string name) 
    { 
     //Since the university is in charge of the lifecycle of the 
     //departments, it creates them (composition) 
     departments.Add(new Department(this, name)); 
    } 

    public void Dispose() 
    { 
     //destroy the university... 
     //destroy the departments too... (composition) 
     foreach (var department in departments) 
     { 
      department.Dispose(); 
     } 
    } 
} 

public class Department : IDisposable 
{ 
    //Department makes no sense if it isn't connected to exactly one 
    //University (composition) 
    private University uni; 
    private string name; 

    //list of Professors can be added to, meaning that one professor could 
    //be a member of many departments (aggregation) 
    public IList<Professor> Professors { get; set; } 

    // internal constructor since a Department makes no sense on its own, 
    //we should try to limit how it can be created (composition) 
    internal Department(University uni, string name) 
    { 
     this.uni = uni; 
     this.name = name; 
    } 

    public void Dispose() 
    { 
     //destroy the department, but let the Professors worry about 
     //themselves (aggregation) 
    } 
} 

public class Professor 
{ 
} 

Answer 2

Eh bien, dans un monde collecté des déchets où tous les objets sont accessibles via des références, la différence subtile (dans la propriété) entre la composition stricte et l'agrégation brouille un peu - donc dans générale (lors de l'utilisation les classes), il se résume à un champ pour l'autre objet ou collection:

class Building { 
    private readonly List<Room> rooms = new List<Room>(); 
    public IList<Room> Rooms {get {return rooms;}} 

    public Address Address {get;set;} 
    //... 
} 
class Address { 
    public string Line1 {get;set;} 
    public string PostCode {get;set;} 
    //... 
} 
class Room { 
    public string Name {get;set;} 
    public int Capacity {get;set;} 
    //... 
} 

Si j'ai raté le point, s'il vous plaît ... préciser

Les choses sont plus impliqués lorsque vous discutez struct s - mais généralement quand on parle de concepts OO, struct utilisation est limitée aux champs de valeur ...