INTRODUCCIN

En este trabajo hablaremos del patrn de diseo Flyweight que usa el compartimiento
para permitir un gran nmero de objetos de grano fino de forma eficiente, Algunas
aplicaciones pueden usar objetos durante todo su diseo. La mayora de editores de
documentos tienen formato de texto y facilidades de edicin que son implementados por
alguna extensin. Tpicamente editores de documento orientados a objetos usan objetos
para representar elementos embebidos como tablas o figuras, as tambin utilizan
objetos para representar cada carcter, manejar el editor de esta manera ofrece
flexibilidad al sistema, pues pueden ser dibujados y formateados uniformemente, con
figuras y tablas, pero la desventaja es que un documento de texto puede tener miles de
caracteres, por eso tener un objeto por carcter implica un gran costo debido a la
memoria que puede consumir. Flyweight permite compartir objetos ligeros, para hacer
el programa ms liviano.

PATRN DE DISEO FLYWEIGHT

El patrn Flyweight describe cmo compartir objetos para permitir su uso y as sirve
para eliminar o reducir la redundancia cuando tenemos gran cantidad de objetos que
contienen informacin idntica, adems de lograr un equilibrio entre flexibilidad y
rendimiento (uso de recursos). Flyweight permite compartir objetos ligeros, para hacer
el programa ms liviano. Se le conoce como patrn peso ligero o patrn peso mosca.
Cada objeto flyweight es dividido en dos partes:
El estado dependiente (extrnseco)
El estado independiente (intrnseco).
El estado independiente (intrnseco).- Es almacenado (compartido) en el objeto
Flyweight.
El estado dependiente (extrnseco).- Es almacenado por el objeto cliente y
pasado al objeto Flyweight, cuando sus operaciones son invocadas.

PASOS PARA APLICAR EL PATRN

1. Asegrese que el rendimiento en los objetos es un tema primordial, y si el cliente est
dispuesto a asumir el reajuste

2. Divida el objetivo principal en estados: Estado Intrnseco (elementos que se puedan

compartir o son comunes) y Estado Extrnseco (elementos particulares a cada tipo)

3. Retire los elementos con estado extrnseco de los atributos de la clase, y adale ms
bien una llamada a mtodos

4. Crear una fbrica que pueda almacenar y reutilizar las instancias existentes de clases

5. El cliente debe usar la fbrica en vez de utilizar el operador new si requiere de

creacin de objetos

6. El cliente (o un tercero) debe revisar los estados extrnsecos, y reemplazar esos

estados a mtodos de la clase.

Ventajas: Reduce en gran cantidad el peso de los datos en un servidor. (Disminuyen

requisitos de almacenamiento).

Desventajas: Consume un poco ms de tiempo para realizar las bsquedas

PATRONES RELACIONADOS
Abstract Factory.
Composite.
State.
Strategy.

ESTRUCTURA
Los objetos Flyweight estn almacenados en un repositorio de tipo Factory. El cliente
se restringe de la crear directamente objetos Flyweight y lo solicita directamente
al Factory. Cada objeto Flyweight no puede valerse por s mismo. Cualquier atributo
que pudiera hacer imposible compartir debe ser proporcionado por el cliente siempre
que se realiza una solicitud al Flyweight. Si el contexto se presta para "economa a
escala" (es decir, el cliente puede calcular o ver fcilmente los atributos necesarios),
entonces
el
patrn Flyweight ofrece
un
apalancamiento
apropiado.

las clases Ant, Lotus y Cockroach pueden ser "livianas" porque el estado de sus
instancias especficas han sido desencapsuladas o expuestas y deben ser suministradas

por el cliente.

Ejemplo
El patrn Flyweight comparte para soportar un gran nmero de objetos de manera
eficiente. La red pblica de conmutadores telefnicos es un ejemplo de este patrn. Hay
gran cantidad de recursos tales como generadores de tono de marcado, generadores de
llamada y receptores de dgitos que deben ser compartidos entre todos los suscriptores.
Un suscriptor no tiene conocimiento de cuantos recursos se encuentran en el pool
cuando l o ella levanta el auricular para realizar una llamada. Todo lo que le importa a
los suscriptores es que se les proporcione el tono de marcado, que los dgitos sean
recibidos y que la llamada sea realizada.

Check list

1. Asegurarse que la sobrecarga de objeto es un tema que necesita atencin y el

cliente de la clase es capaz y est dispuesto a absorber la responsabilidad de
reajuste.

2. Dividir la clase de estado de destino en: Estado compartible (intrnseco) y estado

no compartible (extrnseco).
3. Quitar el estado no compartible de los atributos de clase y agregarlo como
argumento de llamada a la lista de mtodos afectados.
4. Crear un Factory que pueda almacenar en cach y reutilizar instancias de clases
existentes.
5. El cliente debe usar el Factory en lugar del operador new.
6. El cliente (o un tercero) debe observar o calcular el estado no compartible y
suministrar el estado a travs de mtodos de clase.

Reglas de oro
Mientras el patrn Flyweight muestra cmo hacer gran cantidad de pequeos
objetos, Facade cmo hacer un nico objeto representativo de un subsistema completo.
Flyweight es a menudo combinado con Composite para implementar nodos
compartidos.
Flyweight explica cmo y cundo objetos State pueden ser compartidos.

Ejemplo de cdigo C#
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

using System;
using System.Collections;
class MainApp
{
static void Main()
{
// Arbitrary extrinsic state
int extrinsicstate = 22;
FlyweightFactory f = new FlyweightFactory();
// Work with different flyweight instances
Flyweight fx = f.GetFlyweight("X");
fx.Operation(--extrinsicstate);
Flyweight fy = f.GetFlyweight("Y");
fy.Operation(--extrinsicstate);
Flyweight fz = f.GetFlyweight("Z");
fz.Operation(--extrinsicstate);
UnsharedConcreteFlyweight uf = new
UnsharedConcreteFlyweight();
uf.Operation(--extrinsicstate);
// Wait for user

29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.

Console.Read();
}
}
// "FlyweightFactory"
class FlyweightFactory
{
private Hashtable flyweights = new Hashtable();
// Constructor
public FlyweightFactory()
{
flyweights.Add("X", new ConcreteFlyweight());

fy.Operation(--extrinsicstate);
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.

flyweights.Add("Y", new ConcreteFlyweight());

flyweights.Add("Z", new ConcreteFlyweight());
}
public Flyweight GetFlyweight(string key)
{
return((Flyweight)flyweights[key]);
}
}
// "Flyweight"
abstract class Flyweight
{
public abstract void Operation(int extrinsicstate);
}
// "ConcreteFlyweight"
class ConcreteFlyweight : Flyweight
{
public override void Operation(int extrinsicstate)
{
Console.WriteLine("ConcreteFlyweight: " + extrinsicstate);
}
}
// "UnsharedConcreteFlyweight"
class UnsharedConcreteFlyweight : Flyweight
{
public override void Operation(int extrinsicstate)
{
Console.WriteLine("UnsharedConcreteFlyweight: " +
extrinsicstate);
}
}