Using The Flyweight Pattern In C#

Introduction

 

In today’s article we will look at the Flyweight pattern in C#. This pattern is used to create reusable objects in an efficient manner which can be consumed by different clients.

 

We will also look at a practical example of using this pattern.

What is the Flyweight pattern and when to use it?

 

The Flyweight pattern is one of the structural patterns in C#. This means that it is defined by its structure which is at design time. In the flyweight pattern we simply create a number of related classes and provide the calling client one of the instances based upon the request type of the client. These instances are maintained in an object e.g., Dictionary etc. and provided to the calling client on demand. Hence, we use another pattern inside the flyweight pattern, and this is the factory pattern. Let us look at an example which will make things much clear about this pattern.

 

Using the Flyweight pattern

 

Let us create a simple console application using Visual Studio 2019 Community Edition. We will select the .NET 5 framework for this project.

 

 

 

 

 

After this step, remember to select the .NET 5 framework.

 

 

 

After this, add a new class called “Flyweight.cs”

 

 

 

 

Now, update the code in the two files as below,

 

(Program.cs)

using ConsoleAppFlyWeight;
using System;
string empType = "FullTime";
var factory = new EmployeeTaxFactory();
var employeeTax = factory.GetEmployeeTaxBracket(empType);
employeeTax.DisplayTaxBracket();
empType = "PartTime";
employeeTax = factory.GetEmployeeTaxBracket(empType);
employeeTax.DisplayTaxBracket();
empType = "FullTime";
employeeTax = factory.GetEmployeeTaxBracket(empType);
employeeTax.DisplayTaxBracket();
Console.ReadKey();

(Flyweight.cs)

using System;
using System.Collections.Generic;
namespace ConsoleAppFlyWeight {
    public interface IEmployeeTax {
        string EmployeeType {
            get;
            set;
        }
        int TaxBracket {
            get;
            set;
        }
        void DisplayTaxBracket();
    }
    public class EmployeeTaxFactory {
        private Dictionary < string, IEmployeeTax > _employeesTax = new();
        public IEmployeeTax GetEmployeeTaxBracket(string key) {
            IEmployeeTax employeeTax = null;
            if (_employeesTax.ContainsKey(key)) {
                employeeTax = _employeesTax[key];
            } else {
                switch (key) {
                    case "FullTime":
                        employeeTax = new FullTimeEmployee();
                        break;
                    case "PartTime":
                        employeeTax = new PartTimeEmployee();
                        break;
                }
                _employeesTax.Add(key, employeeTax);
            }
            return employeeTax;
        }
    }
    public class FullTimeEmployee: IEmployeeTax {
        public string EmployeeType {
            get;
            set;
        }
        public int TaxBracket {
            get;
            set;
        }
        public FullTimeEmployee() {
            EmployeeType = "FullTime";
            TaxBracket = 1;
        }
        public void DisplayTaxBracket() {
            Console.WriteLine($ "The Tax Bracket is {TaxBracket}");
        }
    }
    public class PartTimeEmployee: IEmployeeTax {
        public string EmployeeType {
            get;
            set;
        }
        public int TaxBracket {
            get;
            set;
        }
        public PartTimeEmployee() {
            EmployeeType = "PartTime";
            TaxBracket = 2;
        }
        public void DisplayTaxBracket() {
            Console.WriteLine($ "The Tax Bracket is {TaxBracket}");
        }
    }
}

When we run the application, we see the below,

 

 

 

In the Flyweight.cs file, we create an interface and two concrete classes that each implement this interface. Finally, we create the factory class which is the heart of this pattern in which we check the request type (which can be full time or part time in our example code) and return the particular concrete class. The main difference from a simple factory pattern is that we also maintain this instance in a dictionary object and when a subsequent request comes for this class, we return it from the dictionary. You can put a break point in the factory class and see that when we request for the full-time class the second time it is returned from the dictionary. Hence, I would recommend this pattern only for simple, short span classes.

 

Summary

 

In this article, we looked at the flyweight pattern in C#. We also looked at a practical implementation of this pattern and when we should use this pattern over a standard factory pattern. Happy coding!