{"id":1658,"date":"2023-04-22T23:11:09","date_gmt":"2023-04-22T16:11:09","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1658"},"modified":"2023-04-22T23:14:49","modified_gmt":"2023-04-22T16:14:49","slug":"csharp-flyweight-pattern","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-design-patterns\/csharp-flyweight-pattern\/","title":{"rendered":"C# Flyweight Design Pattern"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn how to use the C# flyweight pattern to reduce memory usage by sharing data across similar objects.<\/p>\n\n\n\n

Introduction to the C# Flyweight pattern<\/h2>\n\n\n\n

The Flyweight pattern is a structural design pattern that aims to reduce memory usage by sharing data across similar objects.<\/p>\n\n\n\n

In this pattern, you create a set of lightweight objects to represent common data shared across multiple objects. These lightweight objects are also called flyweights, which contain only the data that is unique to each object.<\/p>\n\n\n\n

In practice, you use the Flyweight pattern when you have to create a large number of objects, but each object has only a small amount of unique data. By using the Flyweight pattern, you can reduce the memory usage of the application significantly.<\/p>\n\n\n\n

One practical example of using the Flyweight pattern is in a rich text editor application where you need to manage a large number of character objects that represent the text. In this application, each character object has font, size, and color, which are the same for all characters of the same style.<\/p>\n\n\n\n

To manage flyweights, you can create a pool of flyweights to represent the common data (font, size, and color) shared among many characters. Each character object then contains a reference to the corresponding flyweight object, rather than duplicating the same data.<\/p>\n\n\n\n

For example, imagine that you want to create a document that contains a lot of text with different font styles, sizes, and colors. Instead of creating a new object for each character, you can create a flyweight object for each style and size combination, and then assign a reference to that flyweight object to each character object that shares that style and size combination.<\/p>\n\n\n\n

By doing this, you can reduce the memory usage of the rich text application significantly. Because the application doesn’t create many duplicate objects for the same style and size combinations. <\/p>\n\n\n\n

On top of that, the flyweight pattern can improve the performance of the application because it may reduce the time for creating and initializing many objects.<\/p>\n\n\n\n

This UML diagram illustrates how the flyweight pattern:<\/p>\n\n\n

\n
\"c<\/figure>\n<\/div>\n\n\n

C# Flyweight pattern example<\/h2>\n\n\n\n

The following program demonstrates how to implement the Flyweight design pattern in C#:<\/p>\n\n\n

namespace<\/span> FlyweightPattern<\/span>;\n\n\/\/ Flyweight interface<\/span>\npublic<\/span> interface<\/span> ICharacter<\/span>\n{\n    void<\/span> Display<\/span>(<\/span>)<\/span>;\n}\n\n\/\/ Concrete flyweight class<\/span>\npublic<\/span> class<\/span> Character<\/span> : ICharacter<\/span>\n{\n    private<\/span> readonly<\/span> char<\/span> _symbol;\n    private<\/span> readonly<\/span> int<\/span> _size;\n    private<\/span> readonly<\/span> string<\/span> _font;\n\n    public<\/span> Character<\/span>(char<\/span> symbol, int<\/span> size, string<\/span> font<\/span>)<\/span>\n    {\n        _symbol = symbol;\n        _size = size;\n        _font = font;\n    }\n\n    public<\/span> void<\/span> Display<\/span>(<\/span>)<\/span>\n    {\n        Console.WriteLine($\"Symbol: {_symbol}<\/span>, Size: {_size}<\/span>, Font: {_font}<\/span>\"<\/span>);\n    }\n}\n\n\/\/ Flyweight factory class<\/span>\npublic<\/span> class<\/span> CharacterFactory<\/span>\n{\n    private<\/span> readonly<\/span> Dictionary<string<\/span>, ICharacter> _characters = new<\/span>();\n\n    public<\/span> ICharacter GetCharacter<\/span>(char<\/span> symbol, int<\/span> size, string<\/span> font<\/span>)<\/span>\n    {\n        var<\/span> key = symbol.ToString() + size.ToString() + font;\n\n        if<\/span> (!_characters.ContainsKey(key))\n        {\n            _characters.Add(key, new<\/span> Character(symbol, size, font));\n        }\n\n        return<\/span> _characters[key];\n    }\n}\n\n\/\/ Client code<\/span>\npublic<\/span> class<\/span> Client<\/span>\n{\n    static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        var<\/span> factory = new<\/span> CharacterFactory();\n\n        var<\/span> char1 = factory.GetCharacter('A'<\/span>, 12<\/span>, \"Arial\"<\/span>);\n        char1.Display();\n\n        var<\/span> char2 = factory.GetCharacter('B'<\/span>, 14<\/span>, \"Times New Roman\"<\/span>);\n        char2.Display();\n\n        var<\/span> char3 = factory.GetCharacter('A'<\/span>, 12<\/span>, \"Arial\"<\/span>);\n        char3.Display();\n\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define the ICharacter<\/code> interface that has a method Display() that shows a character to the console: <\/p>\n\n\n
public<\/span> interface<\/span> ICharacter<\/span>\n{\n    void<\/span> Display<\/span>(<\/span>)<\/span>;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, define the Character<\/code> class that implements the ICharacter<\/code> interface:<\/p>\n\n\n
public<\/span> class<\/span> Character<\/span> : ICharacter<\/span>\n{\n    private<\/span> readonly<\/span> char<\/span> _symbol;\n    private<\/span> readonly<\/span> int<\/span> _size;\n    private<\/span> readonly<\/span> string<\/span> _font;\n\n    public<\/span> Character<\/span>(char<\/span> symbol, int<\/span> size, string<\/span> font<\/span>)<\/span>\n    {\n        _symbol = symbol;\n        _size = size;\n        _font = font;\n    }\n\n    public<\/span> void<\/span> Display<\/span>(<\/span>)<\/span>\n    {\n        Console.WriteLine($\"Symbol: {_symbol}<\/span>, Size: {_size}<\/span>, Font: {_font}<\/span>\"<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The Character<\/code> class has three properties symbol, size, and font. It also implements the Display()<\/code> method that shows these properties to the console.<\/p>\n\n\n\n
Third, define the CharacterFactory<\/code> class that is responsible for managing the creation and sharing of flyweight objects:<\/p>\n\n\n
public<\/span> class<\/span> CharacterFactory<\/span>\n{\n    private<\/span> readonly<\/span> Dictionary<string<\/span>, ICharacter> _characters = new<\/span>();\n\n    public<\/span> ICharacter GetCharacter<\/span>(char<\/span> symbol, int<\/span> size, string<\/span> font<\/span>)<\/span>\n    {\n        var<\/span> key = symbol.ToString() + size.ToString() + font;\n\n        if<\/span> (!_characters.ContainsKey(key))\n        {\n            _characters.Add(key, new<\/span> Character(symbol, size, font));\n        }\n\n        return<\/span> _characters[key];\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Finally, define the Client<\/code> class that uses the CharacterFactory<\/code> to obtain flyweight objects for different characters with different sizes and fonts:<\/p>\n\n\n
public class<\/span> Client<\/span>\r\n<\/span>{\r\n    static<\/span> void<\/span> Main(string[] args)\r\n    {\r\n        var<\/span> factory = new<\/span> CharacterFactory();\r\n\r\n        var<\/span> char1 = factory.GetCharacter('A'<\/span>, 12<\/span>, \"Arial\"<\/span>);\r\n        char1.Display();\r\n\r\n        var<\/span> char2 = factory.GetCharacter('B'<\/span>, 14<\/span>, \"Times New Roman\"<\/span>);\r\n        char2.Display();\r\n\r\n        \/\/ use the flyweight instead of creating new object<\/span>\r\n        var<\/span> char3 = factory.GetCharacter('A'<\/span>, 12<\/span>, \"Arial\"<\/span>); \r\n        char3.Display();\r\n\r\n    }\r\n}\r<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Notice that when you request a flyweight object, the CharacterFactory<\/code><\/code><\/code> first checks if an object with the same key (symbol, size, and font) already exists in its internal dictionary.<\/p>\n\n\n\n
If the object does not exist, the CharacterFactory<\/code><\/code><\/code> creates a new Character<\/code> object and adds it to the dictionary. Otherwise, CharacterFactory<\/code><\/code><\/code> returns the existing object.<\/p>\n\n\n\n
When you run the program, you should see the output displaying the symbol, size, and font of each character object. <\/p>\n\n\n\n
Because the third character object is a duplicate of the first one, the CharacterFactory<\/code> returns the existing object instead of creating a new one.<\/p>\n\n\n\n
Summary<\/h2>\n\n\n\n
    \n
  • Use the C# flyweight pattern to reduce memory usage by sharing data across similar objects.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t