| public abstract Operation ( int extrinsicstate ) : void | ||
| extrinsicstate | int | |
| return | void | |
static void Main(string[] args)
{
//定义外部状态，
int externalstate = 10;
//初始化享元工厂
FlyweightFactory factory = new FlyweightFactory();
//判断是否已经创建了字母A，如果已经创建就直接使用床架你的对象A
Flyweight fa = factory.GetFlyweight("A");
if (fa != null)
{
//把外部状态作为享元对象的方法调用参数
fa.Operation(externalstate);
}
//判断是否已经创建了字母D
Flyweight fd = factory.GetFlyweight("D");
if (fd != null)
{
fd.Operation(externalstate);
}
else
{
Console.WriteLine("驻留池中不存在对象D");
//这时候就需要创建一个对象并放入驻留池中
ConcreteFlyweight d = new ConcreteFlyweight("D");
factory.flyweights.Add("D", d);
}
Console.ReadKey();
}
static void Main(string[] args)
{
//externo
int ext = 10;
FlyweightFactory fabrica = new FlyweightFactory();
Flyweight f1 = fabrica.getFlyweight("A");
f1.Operation(ext++);
Flyweight f2 = fabrica.getFlyweight("B");
f2.Operation(ext++);
Flyweight f3 = fabrica.getFlyweight("C");
f3.Operation(ext++);
Flyweight f4 = fabrica.getFlyweight("A");
f4.Operation(ext++);
Flyweight f5 = new UnsharedConcreteFlyweight();
f5.Operation(ext++);
Console.ReadLine();
}
static void Main(string[] args)
{
// Arbitrary extrinsic state
int extrinsicstate = 22;
FlyweightFactory factory = new FlyweightFactory();
// Work with different flyweight instances
Flyweight fx = factory.GetFlyweight("X");
fx.Operation(--extrinsicstate);
Flyweight fy = factory.GetFlyweight("Y");
fy.Operation(--extrinsicstate);
Flyweight fz = factory.GetFlyweight("Z");
fz.Operation(--extrinsicstate);
UnsharedConcreteFlyweight fu = new
UnsharedConcreteFlyweight();
fu.Operation(--extrinsicstate);
// Wait for user
Console.ReadKey();
}
static void Main(string[] args)
{
try
{
int extrinsicstate = 22;
FlyweightFactory factory = new FlyweightFactory();
Flyweight fx = factory.GetFlyweight("X");
fx.Operation(--extrinsicstate);
Flyweight fy = factory.GetFlyweight("Y");
fy.Operation(--extrinsicstate);
Flyweight fz = factory.GetFlyweight("Z");
fz.Operation(--extrinsicstate);
UnsharedConcreteFlyweight fu = new
UnsharedConcreteFlyweight();
fu.Operation(--extrinsicstate);
}
finally
{
Console.ReadKey();
}
}
public static void Run()
{
Console.WriteLine("This structural code demonstrates the Flyweight pattern in which a relatively small number of objects is shared many times by different clients.");
int extrinsicstate = 22;
FlyweightFactory factory1 = new FlyweightFactory();
Flyweight fx = factory1.GetFlyweight("X");
fx.Operation(--extrinsicstate);
Flyweight fy = factory1.GetFlyweight("Y");
fy.Operation(--extrinsicstate);
Flyweight fz = factory1.GetFlyweight("Z");
fz.Operation(--extrinsicstate);
UnsharedConcreteFlyweight fu = new UnsharedConcreteFlyweight();
fu.Operation(--extrinsicstate);
/*
* ConcreteFlyweight: 21
* ConcreteFlyweight: 20
* ConcreteFlyweight: 19
* UnsharedConcreteFlyweight: 18
*/
}
static void Main()
{
int
extrinsicstate = 22;
FlyweightFactory
factory = new FlyweightFactory();
Flyweight
fx = factory.GetFlyweight("X");
fx.Operation(--extrinsicstate);
Flyweight
fy = factory.GetFlyweight("Y");
fy.Operation(--extrinsicstate);
Flyweight
fz = factory.GetFlyweight("Z");
fz.Operation(--extrinsicstate);
UnsharedConcreteFlyweight
fu = new UnsharedConcreteFlyweight();
fu.Operation(--extrinsicstate);
}
public override void Operation(string extrinsicState)
{
Console.WriteLine("UnsharedConcreteFlyWeight:");
foreach (Flyweight Flyweight in flyweights)
{
Flyweight.Operation(extrinsicState);
}
Console.WriteLine();
}
static void Main(string[] args)
{
int extrinsicstate = 22;
FlyweightFactory factory = new FlyweightFactory();
Flyweight fx = factory.GetFlyweight("X");
fx.Operation(--extrinsicstate);
Flyweight fy = factory.GetFlyweight("Y");
fy.Operation(--extrinsicstate);
Flyweight fz = factory.GetFlyweight("Z");
fz.Operation(--extrinsicstate);
Flyweight uf = new UnsharedConcreteFlyweight();
uf.Operation(--extrinsicstate);
Console.WriteLine();
WebSiteFactory webSiteFactory = new WebSiteFactory();
WebSite wx = webSiteFactory.GetWebSiteCategory("產品展示");
wx.Use(new User("小菜"));
WebSite wy = webSiteFactory.GetWebSiteCategory("產品展示");
wy.Use(new User("大鳥"));
WebSite wz = webSiteFactory.GetWebSiteCategory("產品展示");
wz.Use(new User("嬌嬌"));
WebSite wl = webSiteFactory.GetWebSiteCategory("部落格");
wl.Use(new User("老頭"));
WebSite wm = webSiteFactory.GetWebSiteCategory("部落格");
wm.Use(new User("明明"));
WebSite wn = webSiteFactory.GetWebSiteCategory("部落格");
wn.Use(new User("寶寶"));
Console.WriteLine($"網站分類總數為: {webSiteFactory.GetWebStieCount()}");
Console.ReadLine();
}
static void Main(string[] args)
{
// 定义外部状态，例如字母的位置等信息
int extrinsicstate = 10;
// 初始化享元工厂
FlyweightFactory factory = new FlyweightFactory();
// 判断是否创建了字母A，如果已经创建就直接使用创建的对象A
Flyweight fa = factory.GetFlyweight("A");
if (fa != null)
{
// 把外部对象作为享元对象的方法调用参数
fa.Operation(--extrinsicstate);
}
// 判断是否创建了字母B，如果已经创建就直接使用创建的对象B
Flyweight fb = factory.GetFlyweight("B");
if (fb != null)
{
fb.Operation(--extrinsicstate);
}
// 判断是否创建了字母C，如果已经创建就直接使用创建的对象C
Flyweight fc = factory.GetFlyweight("C");
if (fc != null)
{
fc.Operation(--extrinsicstate);
}
// 判断是否创建了字母D，如果已经创建就直接使用创建的对象D
Flyweight fd = factory.GetFlyweight("D");
if (fd != null)
{
fd.Operation(--extrinsicstate);
}
else
{
Console.WriteLine("驻留池中不存在字符串D");
// 这时候需要创建一个对象并放入驻留池中
ConcreteFlyweight d = new ConcreteFlyweight("D");
factory.flyweights.Add("D", d);
}
Console.ReadLine();
}
/*
* note que quando vou buscar um objeto eles já estão instanciados.
*
* A intenção desse padrão é usar compartilhamento para suportar um grande número de objetos semelhantes de forma eficiente. O padrão visa minimizar o uso
* de memória no armazenamento de vários objetos através do compartilhamento das informações em comum que essas instâncias possuem.
*
* Participantes:
* Flyweight - é a interface que define como devem ser as classes que trabalham neste padrão. é importante citar que ela descreve como os dados extrínsecos são objtidos,
* ou seja, as operações que fazem essa transposição de informações;
* ConcreteFlyweight - são as classes que implementam o contrato IFlyweight e que devem permitir o comportamento. Essas classes mantém dados intrínsecos;
* UnsharedConcreteFlyweight - possuem as mesmas características do ConcreteFlyweight, no entanto não são objetos compartilhados. Isso porque este padrão permite
* o compartilhamento, mas não obriga que isso seja sempre seguido;
* FlyweightFactory - Classe que é responsável pela criação dos objetos, além de manter o repositório de objetos que implementam o Flyweight;
* Client - É quem utiliza os objetos IFlyweight, sempre os obtendo através do FlyweightFactory
*/
public void Flyweight()
{
// externo
int ext = 10;
FlyweightFactory fabrica = new FlyweightFactory();
Flyweight.Flyweight f1 = fabrica.getFlyweight("A");
Response.Write(f1.Operation(ext++));
Flyweight.Flyweight f2 = fabrica.getFlyweight("B");
Response.Write("<br>" + f2.Operation(ext++));
Flyweight.Flyweight f3 = fabrica.getFlyweight("C");
Response.Write("<br>" + f3.Operation(ext++));
Flyweight.Flyweight f4 = fabrica.getFlyweight("A");
Response.Write("<br>" + f4.Operation(ext++));
Flyweight.Flyweight f5 = new UnsharedConcreteFlyweight();
Response.Write("<br>" + f5.Operation(ext++));
}
static public void Main()
{
//创建可共享内部状态的蝇量工厂，以一定数量初始化。
FlyweightFactory sff = new SharedFlyweightFactory(2);
//获取蝇量对象
Flyweight sf1 = sff.GetFlyweight(); //蝇量工厂初始化时创建的蝇量对象。
Flyweight sf2 = sff.GetFlyweight(); //蝇量工厂初始化时创建的蝇量对象。
Flyweight sf3 = sff.GetFlyweight(); //蝇量工厂中蝇量对象不足时，新建的蝇量对象。
//在Client中对蝇量对象的外部状态进行操作。
sf1.Operation("这个字符串代表变化、不共享的“一些”外部状态，123123123");
sf2.Operation("这个字符串代表变化、不共享的“一些”外部状态，456456456");
sf3.Operation("这个字符串代表变化、不共享的“一些”外部状态，789789789");
//将不使用的sf3放回蝇量工厂，以便之后进行复用。
sff.SetFlyweight(sf3);
//获取蝇量对象
Flyweight sf4 = sff.GetFlyweight(); //获取到了上一步放回的sf3, 达到复用的目的。
//------------------------------------------NRatel割------------------------------------------------
//创建不可共享内部状态的蝇量工厂，以一定数量初始化。
FlyweightFactory usff = new UnsharedFlyweightFactory(0);
//获取蝇量对象
Flyweight usf1 = sff.GetFlyweight(); //蝇量工厂中蝇量对象不足时，新建的蝇量对象。
//在Client中对蝇量对象的外部状态进行操作。
usf1.Operation("这个字符串代表变化、不共享的“一些”外部状态，789789789");
//将不使用的usf1放回蝇量工厂，以便之后进行复用。
usff.SetFlyweight(usf1);
//获取蝇量对象
Flyweight usf2 = sff.GetFlyweight(); //获取到了上一步放回的usf1, 达到复用的目的。
}
static void Main()
{
int brick = 10;
FlyweightFactory factory = new FlyweightFactory();
Flyweight fx = factory.GetFlyweight("X");
fx.Operation(--brick);
Flyweight fy = factory.GetFlyweight("Y");
fy.Operation(--brick);
Flyweight fz = factory.GetFlyweight("Z");
fz.Operation(--brick);
UnsharedBrickFlyweight fu = new UnsharedBrickFlyweight();
fu.Operation(--brick);
Console.ReadKey();
}
//将不使用的蝇量对象放回蝇量工厂
public void SetFlyweight(Flyweight flyweight)
{
//重置外部状态
flyweight.Operation(null);
flyweights.Add(flyweight);
}
