la mise en œuvre de composition et agrégation en C#?

C'est un peu abstrait question, étant donné que les deux composition & agrégation sont assez similaires, & vraiment ne différent point de vue conceptuel et pas nécessairement au niveau du code. (c'est à dire que vous pourriez envisager une Voiture ayant un Moteur pour la composition, et un Chien ayant des puces à l'agrégation, mais il n'y a rien qui vous empêche de mise en œuvre de la même manière que si vous étiez à la modélisation dans le code).

Toutefois, si vous voulez briser les différences & essayer & forcé d'ajouter des logiciels les décisions de conception pour mettre en évidence ces différences, je suppose que vous pourriez faire quelque chose comme cela... en prenant un exemple de Wikipedia:

Agrégation diffère de l'ordinaire de la composition, en ce qu'elle n'implique pas la propriété. Dans la composition, lorsque le propriétaire de l'objet est détruit, ainsi que les objets contenus. Dans l'agrégation, ce n'est pas nécessairement vrai. Par exemple, une université est propriétaire de divers ministères (p. ex., chimie), et chaque département a un certain nombre de professeurs. Si l'université se ferme, les ministères n'existe plus, mais les professeurs dans les départements continueront à exister. Par conséquent, une Université peut être vu comme une composition de départements, alors que les ministères ont une agrégation des professeurs. En outre, un Professeur peut travailler dans plus d'un département, mais un ministère ne peut pas faire partie de plus d'une université.

Vous pouvez créer ce code pour le représenter (avec autant de inventée indications 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
{
}

OriginalL'auteur Alconja