** Composite **is a structural design patterns.

Via wikipedia:

The composite pattern describes that a group of objects is to be treated in the same way as a single instance of an object. The intent of a composite is to “compose” objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

**Component** – An interface that defines the behavior for a particular object or group of objects

**Leaf** – Single object that has no descendants, implements the interface Component

**Composite**-Group of objects, consiting of leaves, implements the interface Component

# Example

Let’s see how it works on a simple example of how to solve the equation *((((2+5)-1)*4)/3).*

// Component - Common interface for nodes and leafs public interface IOperation { // Calculate the value of expresseion double Calculate(); // display expression string Show(); }

//leaf public class Number : IOperation { public double a { get; set; } public Number(double _a) { a = _a; } public double Calculate() { return a; } public string Show() { return a.ToString(); } }

Now we implement classes(composite) that represent arithmetic operations like addition, multiplication, divide and subtraction.

//composite public class Add : IOperation { public IOperation b1 { get; set; } public IOperation b2 { get; set; } public Add(IOperation a1, IOperation a2) { b1 = a1; b2 = a2; } public double Calculate() { return b1.Calculate() + b2.Calculate(); } public string Show() { return "(" + b1.Show() + "+" + b2.Show() + ")"; } }

And the same will be in other classes with arithmetic operations only difference is a method of *Calculate* and *Show*

Divide:

public double Calculate() { return b1.Calculate() / b2.Calculate(); } public string Show() { return "(" + b1.Show() + "/" + b2.Show() + ")"; }

Multiplication:

public double Calculate() { return b1.Calculate() * b2.Calculate(); } public string Show() { return "(" + b1.Show() + "*" + b2.Show() + ")"; }

Subtraction:

public double Calculate() { return b1.Calculate() - b2.Calculate(); } public string Show() { return "(" + b1.Show() + "-" + b2.Show() + ")"; }

Now let’s apply our pattern for the calculation of expression ((((2 + 5) -1) * 4) / 3)

static void Main(string[] args) { // build the following expression ((((2+5)-1)*4)/3) Number a = new Number(2); Number b = new Number(5); Add addition = new Add(a, b); Number c = new Number(1); Sub subtraction = new Sub(addition, c); Number d = new Number(4); Multi multiplication = new Multi(subtraction, d); Number e = new Number(3); Div divide = new Div(multiplication, e); Console.WriteLine("Result of: {0} is: {1}", divide.Show(), divide.Calculate()); Console.WriteLine("Result of: {0} is: {1}", multiplication.Show(), multiplication.Calculate()); Console.ReadKey(); }

As u see in this approach we combine multiple objects into a single object and we perform methods on it. We can also refer to any of these objects.

# Summary

Link to the project : here

Nice post, but you should change description of operations, because you made a little mistake there 😉

What mistake? 😉

Subtraction: is twice in description

Corrected. Thank You 😉