Flyweight Pattern

Flyweight pattern allow us to reuse memory space via reducing similar kind of object creation. Flyweight pattern falls under structural pattern of GOF (Gang of Four) patterns.

When to use –

Flyweight pattern can be used in scenarios where memory is major constraint. Flyweight pattern reuses already created similar objects and stores them and creates new object only when no similar object found. So by doing this it reduces number of new objects created and decrease memory usage. Flyweight pattern uses sharing mechanism to support large number of objects efficiently.

Major components of Flyweight pattern –

Flyweight – This is an interface defines the members of flyweight class.

Concrete Flyweight – This is concrete class which implements flyweight interface.

Unshared Concrete Flyweight – This is concrete class which implements flyweight interface and not shared.

Flyweight Factory – This class acts as factory and creates different types of objects as per client request. This class also ensures that it will return shared object if already created.

Client – This is client class and has reference to flyweight interface and request flyweight factory to get shared/unshared objects.

See below example of Flyweight pattern.

Code –

class Program

{

    //types of shape

    public enum ShapeType

    {

        Rectanlge,

        Circle,

        Triangle

    }

    //Flyweight

    public interface IShape

    {

        void Draw(int cordinates);

    }

    //concrete flyweight

    public class Rectangle : IShape

    {

        public void Draw(int size)

        {

            Console.WriteLine("Drawing rectangle of size {0}", size);

        }

    }

    //concrete flyweight

    public class Circle : IShape

    {

        public void Draw(int size)

        {

            Console.WriteLine("Drawing circle of size {0}", size);

        }

    }

    //unshared concrete flyweight

    public class Triangle : IShape

    {

        public void Draw (int size)

        {

            Console.WriteLine("Drawing triangle of size {0}", size);

        }

    }

    //Flyweight factory class

    public class ShapeFactory

    {

        public Dictionary<ShapeType, IShape> myShapes = new Dictionary<ShapeType, IShape>();

        public IShape GetShape(ShapeType shapeType)

        {

            if (myShapes.Keys.Contains(shapeType))

            {

                //reusing existing object

                Console.WriteLine("Similar type of object is already exist and reusing the same");

                return myShapes[shapeType];

            }

            else

            {

                //if object is not created yet, create using factory pattern

                switch (shapeType)

                {

                    case ShapeType.Rectanlge:

                        IShape rectangle = new Rectangle();

                        myShapes.Add(ShapeType.Rectanlge, rectangle);

                        break;

                    case ShapeType.Circle:

                        IShape circle = new Circle();

                        myShapes.Add(ShapeType.Circle, circle);

                        break;

                    case ShapeType.Triangle:

                        IShape triangle = new Triangle();

                        return triangle;

                    default:

                        Console.WriteLine("No shape found");

                        break;

                }

                return myShapes[shapeType];

            }

        }

    }

    //Client

    static void Main(string[] args)

    {

        ShapeFactory shapeFactory = new ShapeFactory();

        IShape rectangle = shapeFactory.GetShape(ShapeType.Rectanlge);

        rectangle.Draw(100);

        IShape circle = shapeFactory.GetShape(ShapeType.Circle);

        circle.Draw(50);

        //Shape factory returns already existing objects instead of creating new

        IShape rect_exist = shapeFactory.GetShape(ShapeType.Rectanlge);

        rect_exist.Draw(80);

        IShape circ_exist = shapeFactory.GetShape(ShapeType.Circle);

        circ_exist.Draw(40);

        //triangle object is not shared so new object will be created everytime

        IShape triangle1 = shapeFactory.GetShape(ShapeType.Triangle);

        triangle1.Draw(30);

        IShape triangle2 = shapeFactory.GetShape(ShapeType.Triangle);

        triangle2.Draw(31);

        Console.ReadLine();

    }

}

Output –

As you can see in above example, Flyweight pattern uses flyweight factory to create object and manage them. Flyweight factory creates objects and store them, if object is already created it will return the existing object and if not then it will create new object and return. Flyweight factory also manages unshared objects which will be always created returned and never stored. This way flyweight enforces reusability of existing object and reduce memory usage.

I hope this article helps you to know more about Flyweight Pattern. Please leave your feedback in comments section below.

References –

DoFactory

See Also –

Creational Patterns	Structural Patterns	Behavioral Patterns
Singleton Pattern	Adapter Pattern	Chain of Responsibility Pattern
Thread safe singleton pattern	Bridge Pattern	Command Pattern
Factory Pattern	Composite Pattern	Interpreter Pattern
Abstract Factory Pattern	Decorator Pattern	Iterator Pattern
Builder Pattern	Facade Pattern	Mediator Pattern
Prototype Pattern	Flyweight Pattern	Memento Pattern
	Proxy Pattern	Observer Pattern
		State Pattern
		Strategy Pattern
		Template Method Pattern
		Visitor Pattern