Curriculum
Association, Aggregation, and Composition in C# are important Object-Oriented Programming concepts that define relationships between classes and objects. Association, Aggregation, and Composition in C# help developers model real-world relationships, improve software design, increase maintainability, and build scalable enterprise applications. Every professional .NET developer uses Association, Aggregation, and Composition in C# while developing ASP.NET Core Applications, MVC Projects, Web APIs, Desktop Applications, Microservices, Cloud Solutions, and Enterprise Software Systems.
Understanding Association, Aggregation, and Composition in C# is essential because real-world software applications consist of multiple interacting objects rather than isolated classes.
Object relationships describe how classes interact with one another.
Examples:
Student and Course
Customer and Order
Doctor and Patient
Teacher and DepartmentThese relationships help developers model real-world systems effectively.
The three major relationship types are:
Understanding these relationships is important for software architecture and interview preparation.
Association in C# represents a relationship where two independent objects are connected and interact with each other.
Association represents:
Uses-A RelationshipThe objects can exist independently.
Example:
Teacher and StudentA Teacher can exist without a Student.
A Student can exist without a Teacher.
This is Association.
Association in C#:
Association is the most general relationship type.
Student Class:
public class Student
{
public string Name
{
get;
set;
}
}Teacher Class:
public class Teacher
{
public void Teach(
Student student)
{
Console.WriteLine(
"Teaching " +
student.Name);
}
}Usage:
Student student =
new Student();
student.Name = "Rahul";
Teacher teacher =
new Teacher();
teacher.Teach(student);Output:
Teaching RahulThe Teacher and Student are associated but independent.
Example:
Person ↔ PassportOne person has one passport.
Example:
Teacher → StudentsOne teacher teaches many students.
Example:
Students ↔ CoursesStudents enroll in multiple courses.
Courses contain multiple students.
These relationships are common in database and software design.
Aggregation in C# is a specialized form of Association that represents a:
Has-A RelationshipIn Aggregation:
Example:
Department Has EmployeesEmployees can exist even if the Department is removed.
This is Aggregation.
Aggregation in C#:
Aggregation is widely used in enterprise applications.
Employee Class:
public class Employee
{
public string Name
{
get;
set;
}
}Department Class:
public class Department
{
public Employee Employee
{
get;
set;
}
public Department(
Employee employee)
{
Employee = employee;
}
}Usage:
Employee employee =
new Employee();
employee.Name = "Rahul";
Department department =
new Department(employee);The Employee object exists independently.
This demonstrates Aggregation.
Examples:
Department → Employees
School → Teachers
Company → Departments
Library → BooksEven if the parent object is removed, child objects can continue to exist.
Composition in C# is a stronger form of Aggregation.
Composition represents:
Strong Has-A RelationshipIn Composition:
Example:
House → RoomsIf the House is destroyed, the Rooms cease to exist.
This is Composition.
Composition in C#:
Composition is commonly used in domain-driven design.
Engine Class:
public class Engine
{
public void Start()
{
Console.WriteLine(
"Engine Started");
}
}Car Class:
public class Car
{
private Engine engine;
public Car()
{
engine =
new Engine();
}
public void StartCar()
{
engine.Start();
}
}Usage:
Car car =
new Car();
car.StartCar();Output:
Engine StartedThe Engine is created inside the Car.
The Engine depends on the Car.
This is Composition.
Examples:
House → Rooms
Car → Engine
Computer → Motherboard
Order → Order ItemsThe child object’s lifetime depends on the parent.
| Feature | Association | Aggregation | Composition |
|---|---|---|---|
| Relationship Type | Uses-A | Has-A | Strong Has-A |
| Ownership | No Ownership | Weak Ownership | Strong Ownership |
| Lifetime Dependency | Independent | Independent | Dependent |
| Reusability | High | High | Limited |
| Coupling | Loose | Moderate | Strong |
This comparison is frequently asked during interviews.
Teacher -------- StudentDepartment ◇------ EmployeeEmpty diamond represents Aggregation.
Car ◆------ EngineFilled diamond represents Composition.
Understanding UML relationships helps in software design documentation.
Association:
Teacher ↔ StudentAggregation:
School → TeacherComposition:
Student Report Card → Subject MarksThese relationships model real-world educational systems effectively.
Association:
Customer ↔ ProductAggregation:
Store → ProductsComposition:
Order → Order ItemsEnterprise systems heavily use these relationships.
Relationships become clear and meaningful.
Classes remain organized.
Objects can be reused efficiently.
Applications can grow systematically.
Software reflects actual business structures.
These benefits are essential for professional software development.
Always consider object lifetime dependency.
Strong ownership is not always appropriate.
Poor relationships create maintenance issues.
Keep relationships as loose as possible.
Association, Aggregation, and Composition in C# are heavily used in:
A strong understanding of Association, Aggregation, and Composition in C# helps developers build scalable, maintainable, and professional software architectures.
Association is a relationship where two independent objects interact with each other.
Aggregation is a weak Has-A relationship where child objects can exist independently.
Composition is a strong Has-A relationship where child objects depend on the parent object.
In Aggregation, child objects can exist independently. In Composition, child objects depend on the parent.
They help model real-world systems and improve software architecture.
These relationships form the foundation of scalable and maintainable enterprise application design.