Discussion :

[snopims]

Bonjour,
dans mon application je gere des managers afin de simplifier mon code et d'optimiser. L'ensemble de mes managers hérite d'une classe qui me permet de créer mes managers avec le template 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
 
       /// <summary>
        /// Stockage des différentes instance de managers, utilisées chacune par un thread
        /// </summary>
        protected static Dictionary<int, T> managers = new Dictionary<int, T>();
 
        /// <summary>
        /// Instance unique du manager pour toute la durée de vie du thread courant
        /// </summary>
        public static T Instance
        {
            get
            {
                int threadId = Thread.CurrentThread.ManagedThreadId;
                lock (managers)
                {
                    if (!managers.ContainsKey(threadId))
                    {
                        managers.Add(threadId, new T());
                    }
                    return managers[threadId];
                }
            }
        }
 
        /// <summary>
        /// Libération de l'instance liée au thread courant
        /// </summary>
        internal static void LibererInstance()
        {
            int threadId = Thread.CurrentThread.ManagedThreadId;
            lock (managers)
            {
                if (managers.ContainsKey(threadId))
                {
                    managers.Remove(threadId);
                }
            }
        }

Le prinicipe étant que les instances de mes différents managers sont créés au fil de l'eau si on en a besoin dans la page... et je libere mes managers sur l'évenement dispose de la page. Le problème est que dans le cas d'un response.redirect(..,true) par exemple le thread est avorté et donc je ne libere mes managers, peut etre dans d'autres cas.
Et donc j'ai deux solutions soit je change de clé pour identifier mes managers soit j'arrive à les libérer juste avant le fin du thread, y a t'il un évenement sur le thread sur lequel je peux jouer à coup sur....
par avance merci

[NicoL__]

ça à l'air pas mal ton truc mais je ne comprends pas pourquoi gérer des manager par thread. Si le manager est threadsafe alors un pour toute l'appli suffit (c'est comme ça que ça marche avec Spring en java), s'il sont treadsafe mais propre à un utilisateur tu les mets en session. Et s'il sont pas thread safe tu en créé un par requête donc en asp.net : un par page, en propriété.
Je suppute que les manager ne sont pas threadsafe et que tu veux minimiser leur création, est pertinant ? Sont-ils si coûteux ?

Enfin tout cela ne répond par à ta question (car je suis peut-être passé à coté de particularité propre à ton application).

La solution a ton problème c'est de laisser le garbage collector faire son job sur tes manager et ne pas utiliser le dispose et le LibererInstance pour cela il suffit de les gérer dans une collection de weakreference

Et vérifier que la référence est toujours "vivante" :

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
 
protected static Dictionary<int, WeakReference> managers
 public static T Instance
        {
            get
            {
                int threadId = Thread.CurrentThread.ManagedThreadId;
                lock (managers)
                { 
 
                   if(!managers[threadId].isAlive)
                   {
                           managers.remove(threadId);
                    }
 
                    if (!managers.ContainsKey(threadId))
                    {                      
                        managers.Add(threadId, new WeakReference(new T()));
                    }                  
                    return managers[threadId].Target;
                }
            }
        }