Aggregation And Composition In C#

Rahul Sahay

C#Aggregation CompositionC# FunctionC# Aggregation Composition

3 Comments

Join the conversation! Your thoughts help the community grow.

Raja T11y ago
Thanks for sharing...
Jasminder Singh11y ago
Hello @Rahul, I have a question regarding this concept. You have created DoctorInfo inside the Patient constructor and LifeInsurance object later on. The point is we could have also created the LifeInsurance object at the same time when the DoctorInfo was created OR create the DoctorInfo like LifeInsurance was created. Then how does this compares composition and aggregation. It seems like (not related to ur example, just a generic understanding), to implement this concept, we have to do more of logical thinking of when we should create the instance, rather then technial stuff. Correct me if I am missing any point here.
- Rahul Sahay11y ago
  off course. the point is “Composition is the idea that objects are made up of or composed of other objects. These are intrinsic parts of the containing objects. Here, DoctorInfo is intrinsic to Patient. Which is called composition. Aggregation says objects can bring together separate objects that have their own lifetime. Like, a patient can have an insurance policy or cannot have. However, whenever a patient visits hospital, one doctor gets assigned to patient. Hence, while creating patient object, doctorInfo automatically came into picture. Here, lifetime of Patient object is directly dependent on DoctorInfo. But, in case of aggregation, it is not mandatory. we can bring these objects at any point of time. Yes, this is just a generic example. In coming examples it will become more clear.

In today's discussion, we will discuss Aggregation and Composition in detail using C#. So, let's get started. Let me go ahead and create simple console App for demo purpose.

namespace CSharpStuffs
{
public class Patient
{
public string PatientName { get; set; }
public string AdmissionDate { get; set; }
public string ReleaseDate { get; set; }
public DoctorInfo DoctorInfo { get; set; }
public LifeInsurance Insurance { get; set; }
}
}

namespace CSharpStuffs
{
public class LifeInsurance
{
public string PolicyName;
public string CompanyName;
}
}

Once, the class gets created, It's time to feed the value via constructor. Hence, the following is the final code for the same.

namespace CSharpStuffs
{
public class Patient
{
public string PatientName { get; set; }
public string AdmissionDate { get; set; }
public string ReleaseDate { get; set; }
public DoctorInfo DoctorInfo { get; set; }
public LifeInsurance Insurance { get; set; }
public Patient(string patientName,string admissionDate,string releaseDate,string doctorName,string doctorSpeciality, string workingAt)
{
PatientName = patientName;
AdmissionDate = admissionDate;
ReleaseDate = releaseDate;
//Composition comes into picture now
//It also means when we construct Patient, we also constructed DoctorInfo
//Hence, scope of Doctorinfo is dependent on Patient
DoctorInfo = new DoctorInfo
{
DoctorName = doctorName,
DoctorSpeciality = doctorSpeciality,
WorkingAt = workingAt
};
}
//Overrideenn ToString() for convience
public override string ToString()
{
string result = PatientName + " " +
AdmissionDate + " " +
ReleaseDate + " ";
//Filling Other objects
if (DoctorInfo != null)
{
result += DoctorInfo.DoctorName + " "
+ DoctorInfo.DoctorSpeciality + " "
+ DoctorInfo.WorkingAt;
}
if (Insurance != null)
{
result += " "+ Insurance.PolicyName + " "
+ Insurance.CompanyName;
}
return result;
}
}
}

You will also notice that here, I have used Composition concept. Composition is tied with actual object which is patient here and hence DoctorInfo also got constructed.

Now, main program looks like the following:

using System;
namespace CSharpStuffs
{
class Program
{
static void Main(string[] args)
{
Patient patient = new Patient("Tim","12-08-2015","20-08-2015","Cook","Physician","Fortis");
Console.WriteLine(patient.ToString());
Console.ReadLine();
}
}
}

And, when I run the program, it will produce the following output.

run

However, I can modify the main program to add more info to this via aggregation as shown below.

using System;
namespace CSharpStuffs
{
class Program
{
static void Main(string[] args)
{
Patient patient = new Patient("Tim","12-08-2015","20-08-2015","Cook","Physician","Fortis");
Console.WriteLine(patient.ToString());
//Now, we can add insurance by aggregation
patient.Insurance = new LifeInsurance
{
CompanyName = "HDFC",
PolicyName = "LIFE-AXA"
};
Console.WriteLine(patient.ToString());
Console.ReadLine();
}
}
}

With the above change in place, it will display the following info.

display

Therefore, in a nutshell, Aggregation is the stuff which can be added at later point of time to the object, but composition gets constructed with object creation itself.

Thanks!