Composite style pattern is a tree structure including specific things combined with structures of things. That implies, things that have other things as their kids.

This pattern permits us to have a tree structure and ask each node in the tree structure to carry out a job. It produces a tree structure of a group of things.

A composite item is an item which include other things. Other things might include other composite things. The item which does not include any other item is easy dealt with as leaf of item.

Think about the above diagram. Here Computer system, Cabinet, Peripherals, Mom Boards are composite item. HDD, CUP, RAM, mouse’s are leaf item.

For mouse cost we require to reveal the mouse cost just. However for mom board cost we require to reveal the CPU & & RAM cost.

The essential concept is if you carry out some operation on the leaf item then the very same operation ought to be carried out on the composite things. For instance, if we able to get the cost of a mouse, then we ought to have the ability to get the cost of mom board and even we ought to have the ability to get the cost of the computer system item. If we wish to execute something like this, then we require to utilize the composite style pattern.

 public user interface IComponent
{
space DisplayPrice();.
} 

 public class Leaf: IComponent.
{
public int Rate {get; set;}
public string Call {get; set;}
public Leaf( string name, int cost).
{
this.Price = cost;.
this.Name = name;.
}

public space DisplayPrice().
{
Console.WriteLine( Name +": "+ Rate);.
}
} 

 public class Composite: IComponent.
{
public string Call {get; set;}
List<< IComponent> > parts = brand-new List<< IComponent>>();.
public Composite( string name).
{
this.Name = name;.
}
public space AddComponent( IComponent part).
{
components.Add( part);.
}

public space DisplayPrice().
{
Console.WriteLine( Name);.
foreach (var product in parts).
{
item.DisplayPrice();.
}
}
} 

 public class Program.
{
fixed space Main( string[] args).
{
// Developing Leaf Objects.
IComponent hardDisk = brand-new Leaf(" Hard Drive", 2000);.
IComponent ram = brand-new Leaf(" RAM", 3000);.
IComponent cpu = brand-new Leaf(" CPU", 2000);.
IComponent mouse = brand-new Leaf(" Mouse", 2000);.

// Developing composite things.
Composite motherBoard = brand-new Composite(" Peripherals");.
Composite cabinet = brand-new Composite(" Cabinet");.
Composite peripherals = brand-new Composite(" Peripherals");.
Composite computer system = brand-new Composite(" Computer System");.

// Developing tree structure.
// Ading CPU and RAM in Mom board.
motherBoard.AddComponent( cpu);.
motherBoard.AddComponent( ram);.

// Ading mom board and hard drive in Cabinet.
cabinet.AddComponent( motherBoard);.
cabinet.AddComponent( hardDisk);.

// Ading mouse in peripherals.
peripherals.AddComponent( mouse);.

// Ading cabinet and peripherals in computer system.
computer.AddComponent( cabinet);.
computer.AddComponent( peripherals);.

// To show the Rate of Computer system.
computer.DisplayPrice();.
Console.WriteLine();.

// To show the Rate of Mouse.
mouse.DisplayPrice();.
Console.WriteLine();.

// To show the Rate of Cabinet.
cabinet.DisplayPrice();.
Console.Read();.
}
} 

In composite style pattern there are 3 individuals.

Element
An abstract class or user interface including the members that will be carried out by all the kid things in the hierarchy. It likewise executes a few of the habits that prevails to all things in the structure. This abstract class serves as the base class for all the things within the hierarchy. In our example, it is the IComponent user interface.

Leafs
A class to represent the leaf habits in the structure. In our example, it is the Leaf class.

Composite
The Composite specifies the habits for the parts which have kids (i.e. Leaves). It likewise saves its kid parts and executes Include, Get rid of, Discover and Get techniques to do operations on kid parts. In our example, it is the Composite class.