本文共 4923 字，大约阅读时间需要 16 分钟。

享元模式（Flyweight Pattern）是一种结构型设计模式，旨在在消耗较少内存的情况下支持大量对象的创建。这种模式通过共享已存在的对象实例来减少内存占用，从而提高系统资源的利用率。在现实生活中，我们可以看到许多重复的对象，如棋子、电脑等。在程序设计中，传统的方法会为每个对象分配独立的内存空间，导致内存占用大量增加，造成资源浪费。享元模式通过共享这些对象的状态，避免重复创建，从而解决了这一问题。

享元模式的意图

享元模式的核心意图是通过共享技术，有效地支持大量细粒度的对象。通过这种方式，可以在保持功能一致性的同时，显著减少内存占用。

享元模式的主要优点

相同对象只需保存一份，降低了系统中对象数量，从而减轻了内存压力。这种共享机制使得系统能够支持更多的细粒度对象，提升了资源利用率。

享元模式的主要缺点

为使对象可以共享，需要将某些状态外部化，这会增加程序的复杂性。此外，由于状态的外部化，读取外部状态的开销也会稍微增加运行时间。

享元模式的实现示例

以下是一个使用C#语言实现享元模式的示例代码：

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
namespace _11_FlyWeight
{
    class Program
    {
        static void Main(string[] args)
        {
            var factory = new FlyweightFactory(
                new Car { Company = "Chevrolet", Model = "Camaro2018", Color = "pink" },
                new Car { Company = "Mercedes Benz", Model = "C300", Color = "black" },
                new Car { Company = "Mercedes Benz", Model = "C500", Color = "red" },
                new Car { Company = "BMW", Model = "M5", Color = "red" },
                new Car { Company = "BMW", Model = "X6", Color = "white" }
            );
            factory.ListFlyweights();
            AddCarToPoliceDatabase(factory, new Car
            {
                Number = "CL234IR",
                Owner = "James Doe",
                Company = "BMW",
                Model = "BMW",
                Color = "red"
            });
            AddCarToPoliceDatabase(factory, new Car
            {
                Number = "CL234IR",
                Owner = "James Doe",
                Company = "BMW",
                Model = "X1",
                Color = "red"
            });
            factory.ListFlyweights();
            Console.ReadKey();
        }
        public static void AddCarToPoliceDatabase(FlyweightFactory factory, Car car)
        {
            Console.WriteLine("\nClient: Adding a car to database.");
            var flyweight = factory.GetFlyweight(new Car
            {
                Color = car.Color,
                Model = car.Model,
                Company = car.Company
            });
            flyweight.Operation(car);
        }
    }
    public class Flyweight
    {
        private Car _sharedState;
        public Flyweight(Car car)
        {
            _sharedState = car;
        }
        public void Operation(Car uniqueState)
        {
            string s = JsonConvert.SerializeObject(_sharedState);
            string u = JsonConvert.SerializeObject(uniqueState);
            Console.WriteLine($"Flyweight: Displaying shared {s} and unique {u} state.");
        }
    }
    public class FlyweightFactory
    {
        private List
   
    
     > flyweights = new List
     
      
       >();
        public FlyweightFactory(params Car[] args)
        {
            foreach (var item in args)
            {
                flyweights.Add(Tuple.Create(new Flyweight(item), GetKey(item)));
            }
        }
        public string GetKey(Car key)
        {
            var elements = new List
       
        ();
            elements.Add(key.Model);
            elements.Add(key.Color);
            elements.Add(key.Company);
            if (key.Owner != null && key.Number != null)
            {
                elements.Add(key.Number);
                elements.Add(key.Owner);
            }
            elements.Sort();
            return string.Join("_", elements);
        }
        public Flyweight GetFlyweight(Car sharedState)
        {
            string key = GetKey(sharedState);
            Flyweight flyweight = flyweights.Where(t => t.Item2 == key).FirstOrDefault().Item1;
            if (flyweight == null)
            {
                flyweight = new Flyweight(sharedState);
                flyweights.Add(Tuple.Create(flyweight, key));
                Console.WriteLine("FlyweightFactory: Creating new flyweight.");
            }
            else
            {
                Console.WriteLine("FlyweightFactory: Reusing existing flyweight.");
            }
            return flyweight;
        }
        public void ListFlyweights()
        {
            int count = flyweights.Count;
            Console.WriteLine("\nFlyweightFactory: I have {0} flyweights:", count);
            foreach (var flyweight in flyweights)
            {
                Console.WriteLine(flyweight.Item2);
            }
        }
    }
    public class Car
    {
        public string Owner { get; set; }
        public string Number { get; set; }
        public string Company { get; set; }
        public string Model { get; set; }
        public string Color { get; set; }
    }
}
       
      
     
    
   

代码解释

通过这种方式，系统可以在保持功能一致性的同时，显著减少内存占用，提高资源利用率。