Enjoy meta mode (Flyweight pattern)

Flyweight pattern: Use shared technology to effectively support a large number of fine-grained objects.

Flyweight is a shared object that can be used in multiple scenarios (context) at the same time, and Flyweight can act as a standalone object in each scene-this is no different from an instance of a non-shared object. Flyweight cannot make any assumptions about the scenario it is running, the key concept here is the difference between the internal state and the external state . The internal state is stored in flyweight, which contains information that is independent of the flyweight scene, which allows flyweight to be shared. The external state depends on the flyweight scene and changes according to the scene, so it is not shareable. the user object is responsible for passing the external state to flyweight when necessary. The flyweight model models a concept or entity that is often too large to be represented by objects.

Structure

Flyweight

--Describes an interface through which flyweight can accept and act on an external state.

Concreteflyweight

--Implement the flyweight interface and increase the storage space for the internal state (if any).

The Concreteflyweight object must be shareable. The state it stores must be internal, that is, it must be independent of the scene of the Concreteflyweight object.

Unsharedconcreteflyweight

-Not all flyweight subclasses need to be shared. A flyweight interface makes sharing possible, but it does not force sharing.

at some level of the flyweight object structure Unsharedconcreteflyweight objects typically use Concreteflyweight objects as child nodes.

Flyweightfactory

--Create and manage flyweight objects.

--Ensure that flyweight is properly shared. When the user requests a Flyweigh, the Flyweightfactory object provides a created instance or creates one (if it does not exist).

Client

--Maintain a reference to the flyweight.

-Calculates or stores the external state of a (multiple) flyweight.

Collaboration

The state required for flyweight execution must be internal or external. The internal state is stored in the Concreteflyweight object, while the external object is stored or computed by the client object. When the user invokes the action of the flyweight object, the state is passed to it. Users should not instantiate the Concreteflyweight class directly, but should get concreteflyweight objects from the Flyweightfactory object, which ensures that they are properly shared.

Effect

There are two ways to conserve storage: use sharing to reduce internal state consumption, and calculate time for external state storage. (Space change time)

Using the enjoy meta-mode requires maintaining a list of all the elements that are already in the system, which in itself consumes resources, and additional meta-mode makes the system more complex. In order for objects to be shared, some States need to be externally instantiated, which complicates the logic of the program.

Realize

1) Delete the external state;

2) Manage shared objects.

Reference Code

[CSharp] view plaincopy

2. Using System;
4. Using System.Collections.Generic;
6. Using System.Linq;
8. Using System.Text;
10. Using System.Collections;
14. Namespace Myflyweight
16. {
18. abstract class Flyweight
20. {
22. public abstract void operation (int extrinsicstate);
24. }
28. class Concreteflyweight:flyweight
30. {
32. private int intrinsicstate = 0;
36. public override void operation (int extrinsicstate)
38. {
40. Console.WriteLine ("Concrete flyweight:{0}",
42. Intrinsicstate + extrinsicstate);
44. }
46. }
50. class Unsharedconcreteflyweight:flyweight
52. {
54. private int allState = 0;
58. public override void operation (int extrinsicstate)
60. {
62. Console.WriteLine ("unshared Concrete flyweight:{0}", extrinsicstate);
64. }
66. }
70. class Flyweightfactory
72. {
74. private Hashtable flyweights = new Hashtable ();
78. Public flyweightfactory ()
80. {
82. Flyweights.  ADD ("X", new Concreteflyweight ());
84. Flyweights.  ADD ("Y", new Concreteflyweight ());
86. Flyweights.  ADD ("Z", new Concreteflyweight ());
88. }
92. Public Flyweight getflyweight (string key)
94. {
96. return ((Flyweight) flyweights[key]);
98. }
100. }
102. }

[CSharp] view plaincopy

2. Using System;
4. Using System.Collections.Generic;
6. Using System.Linq;
8. Using System.Text;
12. Namespace Myflyweight
14. {
16. Class Program
18. {
20. static void Main (string[] args)
22. {
24. int extrinsicstate = 23;
28. Flyweightfactory f = new Flyweightfactory ();
32. Flyweight FX = f.getflyweight ("X");
34. Fx. Operation (--extrinsicstate);
36. Flyweight fy = f.getflyweight ("Y");
38. Fy. Operation (--extrinsicstate);
40. Flyweight FZ = F.getflyweight ("Z");
42. Fz. Operation (--extrinsicstate);
46. var uf = new Unsharedconcreteflyweight ();
48. uf. Operation (--extrinsicstate);
52. Console.readkey ();
54. }
56. }
58. }

application . NET, the string class is using the flyweight pattern.

[CSharp] view plaincopy < param name= "Menu" value= "false" >

1. String Titlea = "Flyweight pattern";
2. String Titleb = "Flyweight pattern";
3. Console.WriteLine (Object.referenceequals (Titlea, Titleb));

Reference: "design mode", "Big Talk design mode"

Enjoy meta mode (Flyweight pattern)