Design patterns 飞锤模式困境

这很好地解释了Flyweight模式

无论如何，假设我们想要更改

this.height=200的字体大小（假定属性不受保护）。这意味着所有字体大小都将更改，因为对象是引用类型

假设这是一个文本编辑器，我们只想更改特定字母的字体大小（字母的单个实例，而不是全部）。所以现在出现了一个问题，因为如果我们以某种方式改变字典中对象的字体大小，所有出现的情况都会改变。我该如何处理这个问题？
我认为这是一个合适的解决方案。它是飞锤中的飞锤，但在C#中，它有点简化，但我认为你应该了解这个概念。我们的想法是在适当的地方放置一个facade来获得参数化的类。在这面墙里面，我有一本字典，可以为新的尺寸建造新的工厂。这可能看起来很奇怪，但请注意，flyweight是一种创造性的设计模式，它不会存储文本本身，只允许您访问相同的对象。州政府显然不一样，所以我认为换一家工厂是有道理的

    public class AlphabetFacade
    {
        private Dictionary<int, AlphabetFactory> _alphabetFactories = new Dictionary<int, AlphabetFactory>();

        private Character GetChar(string character, int fontSize)
        {
            if (_alphabetFactories.ContainsKey(fontSize)) return _alphabetFactories[fontSize].GetCharacter(character);
            var factoryNew = new AlphabetFactory(fontSize);
            _alphabetFactories.Add(fontSize, factoryNew);
            return factoryNew.GetCharacter(character);
        }
    }

    internal class AlphabetFactory
    {
        private readonly int _fontSize;

        private readonly Dictionary<string, Character> _characters = new Dictionary<string, Character>();

        public AlphabetFactory(int fontSize)
        {
            _fontSize = fontSize;
        }

        public Character GetCharacter(string character)
        {
            if (_characters.ContainsKey(character)) return _characters[character];
            var characterNew = new Character(_fontSize, character);
            _characters.Add(character, characterNew);
            return characterNew;
        }
    }

     class Character
     {
         public Character(int size, string @char)
         {
            Size = size;
            Char = @char;
         }

         public int Size { get; }
         public string Char { get; }
     }

公共类AlphabetFacade
{
专用词典_alphabetFactories=新词典（）；
私有字符GetChar（字符串，int-fontSize）
{
if（_alphabetFactories.ContainsKey（fontSize））返回_alphabetFactories[fontSize].GetCharacter（character）；
var factoryNew=新的AlphabetFactory（fontSize）；
_添加（fontSize，factoryNew）；
返回factoryNew.GetCharacter（字符）；
}
}
内部类字母工厂
{
私有只读int_fontSize；
专用只读词典_characters=新词典（）；
公共AlphabetFactory（内部字体大小）
{
_fontSize=fontSize；
}
公共字符GetCharacter（字符串字符）
{
if（_characters.ContainsKey（character））返回_个字符[character]；
var characterNew=新字符（_fontSize，Character）；
_characters.Add（character，characterNew）；
返回字符new；
}
}
类字符
{
公共字符（整数大小，字符串@char）
{
大小=大小；
Char=@Char；
}
公共整数大小{get；}
公共字符串字符{get；}
}
在我的头顶上，我会创建一个可参数化的工厂，并将字体大小传递给构造函数。然后会有不同规模的工厂。您可以将工厂包装在一个只提供像
get（“a”，12）
这样的干净界面的外观中。这可能看起来很奇怪，但请注意，flyweight是一种创造性的设计模式，它不会存储文本本身，只允许您访问相同的对象。而且状态显然不同，因此我认为另一个工厂可能是合理的。但现在我不确定是否有一个明显的缺点，我错过了。。。