Le patron de conception stratégie couramment utilisé pour des situations où il est nécessaire de permuter dynamiquement les algorithmes utilisés dans une application. Il est ainsi est prévu pour fournir le moyen de définir une famille d’algorithmes, encapsuler chacun d’eux en tant qu’objet, et les rendre interchangeables.

Une classe utilisant ce pattern reste fermée à la modification mais ouverte a l’extension et ne fais ne fais que moduler un comportement deja existant.

Exemple d’implémentation en actionScript 3 :

public function set animatorOpen(value:ContentAnimator):void
{
	_animatorOpen = value;
	_animatorOpen.contentToAnim = _content;
}

public function set animatorClose(value:ContentAnimator):void
{
	_animatorClose = value;
	_animatorClose.contentToAnim = _content;
}

Dans le dernier article portant sur les design patterns en ActionScript3 , nous avons abordée la factory. Aujourd’hui voyons l’Abstract factory (fabrique abstraite). Elle encapsule un groupe de factory ayant une thématique commune. Le code crée une implémentation concrète de la fabrique abstraite, puis utilise les interfaces génériques pour créer des objets concrets de la thématique. Le client ne se préoccupe pas de savoir laquelle de ces fabriques a donné un objet concret, car il n’utilise que les interfaces génériques des objets produits. Ce patron de conception sépare les détails d’implémentation d’un ensemble d’objets de leur usage générique.

Exemple de mise en œuvre :

private var _contenu0:IContenu;
private var _contenu1:IContenu;
private var _contenu2:IContenu;

public function creator(content:Object)
{

/*
ABSTRACT FACTORY
factory utilise d'autres factory , cache les classes fabricant l'objet
*/

_contenu1 = FactoryContent.prebuild(content);
_contenu2 = FactoryContent.prebuild(_content);

}

Contenu de la classe FactoryContent :

public class FactoryContent
{
public function FactoryContent()
{
}

public static function prebuild(content:Object):IContenu
{
var resultatContenu:IContenu;

resultatContenu = BContenu.prebuildContent(content);

return resultatContenu;
}

}

on peut toujours construire des contenus “from scratch”  sans factory :

_contenu0 = BContenu.prebuildContent(_content);
_contenu1 = BContenu.prebuildContent(_content);
_contenu2 = BContenu.prebuildContent(_content]);

public static function prebuildContent(content:Object):IContenu
{
var resultatContenu:IContenu;
resultatContenu = new BContenu(content);

return resultatContenu;
}

La fabrique (factory) est un patron de conception de création utilisé en programmation orientée objet.
Une fabrique de création est une classe qui n’a pour rôle que de construire des objets. Cette classe utilise des interfaces ou des classes abstraites pour masquer l’origine des objets.Les objets créés n’ont pas de types prédéfinis.

un exemple de factory :

public static function prebuildContent(aDecoIdentif:Array = null):IContenu
{
      var resultatContenu:IContenu;
       if(aDecoIdentif != null)
	{
	    for (var i:int = 0; i< aDecoIdentif.length ; i++)
	   {
		if(aDecoIdentif[i] == DECO_DRAG)
		{
			resultatContenu = new DragContenu(resultatContenu);
		}
		else if(aDecoIdentif[i] == DECO_DB_CLOSE)
		{
			resultatContenu = new DoubleClickContenu(resultatContenu);
		}
	}
   }
   return resultatContenu;
}

L’utilisation de switch / case est courante dans l’utilisation d’une fabrique :

static public function createVue(type:String):AbstractView
{
switch(type)
{
case "type1":
return new ViewOne();
break;
default:
break;
}
return null;
}

ici la méthode de création d’objet renvoie une instance étendue d’abstractView (classe abstraite)

En développement logiciel , le pattern delegate (ou délégation) est un design pattern en programmation objet ou un objet au lieu de traiter l’une de ces taches , délègue cette tache à un objet associé. Il crée ainsi  une inversions de responsabilité. L’objet aidant est appelé le delegate. Le patron de délégation est l’un des patron fondamental d’abstraction qui implique d’autres modèles tels la composition (appelle aussi agrégation).

Exemple de mise en place :

public function addEventListener(type:String, listener:Function, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean=false):void
{
// pattern DELEGATE
_eventDispatcher.addEventListener(type,listener,useCapture,priority,useWeakReference);
}

Cet article sera le premier d’une série de 7 articles traitant de l’implémentation des principaux design pattern en ActionScript 3, avec une présentation théorique et un exemple pratique.

Aujourd’hui le Singleton

Le singleton est le design pattern le plus simple à mettre en place. Le but est de restreindre l’instanciation d’une classe à un seul objet (ou bien à quelques objets seulement). Il est utilisé lorsque l’on a besoin d’exactement un objet pour coordonner des opérations dans un système.Il sera surtout utilisé pour un contrôleur présent dans un MVC (Modèle Vue Contrôleur) qui sera compose d’autres objets de contrôleurs. Le modèle est parfois utilisé pour son efficacité, lorsque le système est plus rapide ou occupe moins de mémoire avec peu d’objets qu’avec beaucoup d’objets similaires.

On implémente le singleton en écrivant une classe qui possèdera une méthode créant une instance uniquement s’il n’en existe pas encore. Sinon elle renvoie une référence vers l’objet qui existe déjà.

Le singleton doit être implémenté avec précaution dans les applications multi-thread. Si deux threads exécutent en même temps la méthode de création alors que l’objet unique n’existe pas encore, il faut absolument s’assurer qu’un seul créera l’objet, et que l’autre obtiendra une référence vers ce nouvel objet.
La solution classique à ce problème consiste à utiliser l’exclusion mutuelle pour indiquer que l’objet est en cours d’instanciation.

Voici un exemple d’implémentation :

package
{
public class example
{
// on définit une variable statique Booléenne permettant de savoir si l'objet est créé
private static var _fromGetInstance:Boolean = false;

// c'est l'objet en lui même , il est statique et private pour que seule la classe puisse y accéder
private static var _uniqueInstance:example;

// méthode d'accès à l'objet du singleton , il peut être remplacé par un getter qui sera lui aussi en public static.
// la méthode retourne l'objet et vérifie sa disponibilité
public static function getInstance():LoadingModal
{
if(! _uniqueInstance)
{
_fromGetInstance = true;
_uniqueInstance = new LoadingModal();
}
return _uniqueInstance;

}

// constructeur de la classe
// on ne peut pas créer de nouveaux objets par le constructeur sinon cela renvoie une erreur
public function example()
{
if(!_fromGetInstance)
{
throw new Error("interdit");
}
_fromGetInstance = false;

}

}
}