Bonjour à tous,

Au sein de mon application, j'utilise plusieurs Singletons. Chacun de ces Singleton contiens une ou plusieurs listes (des Vectors) contenant des informations fournies par le serveur via une requête AMF.

Afin d'être sûr que mes singletons ont étés instanciés, je les charge au démarrage de l'application. Seulement voila, c'est pas propre de faire ça. Je fais le paris qu'au moment de les nécessiter, le serveur aura déjà renvoyé son information et que la liste sera donc instanciée.

Afin d'optimiser ce traitement, je pensais ajouter une variable booléenne pour chacune des informations de mon singleton. si cette variable contiens la valeur vrai, j'utilise le champ souhaité.

Pensez vous que cette approche est cohérente ? y'a-t'il une démarche plus propre à mettre en place ?

voici le code type d'un singleton.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
public class SingletonClass
{
	private static var _instance : SingletonClass ;
	private static var canInstanciate : Boolean = false ;
 
	private var someList : Vector.<someObject>  ;
 
	private static var _someListAvailable : Boolean = false ;
 
 
	public function SingletonClass()
	{
		if (!canInstanciate)
		{ trace ("LCFormatList Singleton instanciation fail , use getInstance"); }
		else
		{ 
			var remoteObject : LCCoreConnectionManager ;
			remoteObject = LCCoreConnectionManager.getInstance() ;
 
			remoteObject.getSomeList(onGetSomeList,onGetSomeListFault); 
		} 
	}
	public static function getInstance() : LCFormatList
	{
		if (!_instance)
		{
			canInstanciate = true ;
			_instance = new SingletonClass() ;
			canInstanciate = false ;
		}
		return _instance ;
	}
 
	public function getSomeList() : Vector.<someObject>
	{ return someList ; }	
 
	private function onGetSomeList ( AResult : ResultEvent) : void
	{
		if (AResult.result[0] is LCFormats)
		{
			maquetteFormatList = new Vector.<LCFormats>() ;
			for each ( var anElement : LCFormats in AResult.result)
			{ maquetteFormatList.push( anElement) ; }	
			dispatchEvent (new LCRemoteEvents(LCRemoteEvents.MAQUETTE_AVAILABLE));			
		}
		_someListAvailable = true ;
	}
 
	private function onGetSomeListFault (AEvent : FaultEvent) : void
	{ Alert.show("echec de recupération des formats. \n Details : \n" + AEvent.fault.faultDetail); }
}
Avec cette méthode, la fonction getSomeList() serais modifiée de la façon suivante :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
 
public function getSomeList() : Vector.<someObject>
{
	while (!_someListAvailable) 
	{ }
	return someList ; 
}
Ou alors dans la méthode appelante :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
 
var monInstance : SingletonClass = SingletonClass.getInstance()
while (!_someListAvailable) 
{ }
 
var maListe : Vector.<someObject> = SingletonClass.getSomeList();

Ces deux approches me semblent bien brouillonne et sont susceptible d'entraîner des boucles infinies. Quelle approche préconiseriez vous ?