Discussion :

[istace.emmanuel]

Salut j'ai un petit soucis,

J'ai une liste d'objet Key qui contiennent chacun un DateTime et une GUID (string).
Je me base sur le dateTime pour savoir si la key est encore valide le soucis c'est que je cherche un moyen pour que l'item s'auto delete une fois X secondes/minutes/heures passé.

J'ai regardé du coté des DP mais rien trouvé (mal cherché ?)

J'ai cependant une solution, mais que je trouve très inélégante. Un bgWorker qui lock la liste, check les items une a une et supprime celle qui doivent l'être.

Quelqu'un a une idée plus élégante ? ou une DP ?

Infor@tiquement

[Nathanael Marchand]

Je vois pas trop de solution propre la dessus.
Peut être une classe qui encapsule une List<T>.
Apres tu surcharges les membres pour qu'a chaque accès à un item il y'ait un nettoyage de la collection

[olibara]

Salut

Moi en gros j'utiliserais un timer une liste triée sur date a partir des element de ta liste originale (en definissant un compareur)

Si tu gere bien le tri a partir des insertions dans ta liste, tu ne dois pas reparcourir toute ta liste a chaque intervale du timer

[istace.emmanuel]

Alors, j'ai fait un mix des deux en attendant.

L'avantage de la première solution est que lorsque l'on contacte mon service, le nettoyage ayant été fait, je suis sur que si true est renvoyé, c'est true.
Alors que sur le timer, si il est exec toute les 10sec par exemple, rien ne me dis que 3sec après une clef ne sera pas devenue invalide, mais considéré valide tout de même étant encore présente dans ma liste.

Par contre le désavantage de la première est que si pendant 2 heures plus aucune demande n'est effectué, je conserve un (grand?) nombre d'objet en mémoire inutilement.

J'ai donc pour le moment a chaque insert un clean, à la demande de validation un clean et toutes les X minutes un clean au cas ou il n'y aurais plus eu de request depuis longtemp.

Chaque méthode me permettant de couvrir les inconvenants de l'autre.

Par contre je me demandais si, encapsuler un timer dans les objets de ma liste qui lève un event auquel est abonné mon objet parent (celui contenant la list<>) ne serait pas une solution.
Ainsi ma objet parent serait notifié par les objets de la liste "Hé ho, je suis plus valide, delete moi !"
Qu'en pensez vous ?

[Nathanael Marchand]

Ca me parait dangereux de mettre la responsabilité aux enfants et ca risque de faire beaucoup de timers!

[swif79]

J'avais cru comprendre que la DateTime contenue dans Key était la date d'expiration de son élément, du coup j'ai gratté ce qui suit, vous en pensez quoi ? j'ai pas trop tester et je me demande si ça n'est pas risqué.

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
public class TimerList : IEnumerable<Key>
    {
        internal readonly List<Key> list = new List<Key>();
        internal List<DateTime> dateList = new List<DateTime>();
        internal System.Windows.Forms.Timer tmr = new System.Windows.Forms.Timer();
        bool CanAttach = true;
 
        public TimerList()
        {
            this.tmr.Tick += new EventHandler(tmr_Tick);
        }
 
        private void tmr_Tick(object sender, EventArgs e)
        {
            this.tmr.Enabled = false;
            DateTime date = (DateTime)this.tmr.Tag;
 
            lock (this.list)
            {
                varToRemove = 
                                from key in this.list
                                where key.EndDate == date
                                select key;
 
                CanAttach = false;
 
                foreach(Key k in ToRemove)
                      this.Remove(k);
 
                CanAttach = true;
                this.AttachTimer();
            }          
        }
 
        private int _Count = 0;
        public int Count
        {
            get { return _Count; }
        }
 
        public Key this[int n]
        {
            get
            {
                if (n < this._Count)
                    return this.list[n];
                else
                    throw new ArgumentOutOfRangeException();
            }
        }
 
        public bool Add(Key item)
        {
            if (this.list.Contains(item))
                return false;
 
            this.list.Add(item);
            this.dateList.Add(item.EndDate);
            this.AttachTimer();
 
            _Count++;
 
            return true;
        }
 
        private void AttachTimer()
        {   
            this.dateList.Sort();
            if (this.dateList.Count > 0)
            {
                DateTime Now = DateTime.Now;
                this.tmr.Tag = this.dateList[0];
 
                if(Now < this.dateList[0])
                      this.tmr.Interval = (int)(this.dateList[0] - DateTime.Now).TotalMilliseconds;
                else
                      this.tmr.Interval = 10;
                this.tmr.Enabled = true;
            }
        }
 
        public bool Remove(Key item)
        {
            if (!this.list.Contains(item))
                return false;
 
            this.list.Remove(item);
 
            this.dateList.Remove(item.EndDate);
            if(CanAttach)
                  this.AttachTimer();
 
            _Count--;
            return true;
        }
 
        public bool Contains(Key item)
        {
            return this.list.Contains(item);
        }
 
        public Key[] ToArray()
        {
            return this.list.ToArray();
        }
 
        public IEnumerator<Key> GetEnumerator()
        {
            return this.list.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.list.GetEnumerator();
        }
    }

[tomlev]

Voilà l'approche que je choisirais :

- Créer une interface IExpirable qui expose la date de création de l'objet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
public interface IExpirable
{
    DateTime CreationDate { get; }
}

- Créer une classe héritée de Collection<T>, avec une contrainte sur T pour qu'il implémente IExpirable. Dans cette classe, tu lances un timer qui va purger la collection à la fréquence que tu veux :

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
public class AutoPurgeCollection<T> : Collection<T>, IDisposable
    where T : IExpirable
{
    private readonly TimeSpan _itemLifeTime;
    private readonly System.Timers.Timer _purgeTimer;
 
    public AutoPurgeCollection(TimeSpan itemLifeTime, TimeSpan purgeInterval)
    {
        _itemLifeTime = itemLifeTime;
        _purgeTimer = new System.Timers.Timer(purgeInterval.TotalMilliseconds);
        _purgeTimer.Elapsed += (sender, e) => Purge();
        _purgeTimer.AutoReset = true;
        _purgeTimer.Start();
    }
 
    protected virtual void Purge()
    {
        DateTime now = DateTime.Now;
        var itemsToRemove = Items.Where(i => now - i.CreationDate > _itemLifeTime).ToArray();
        foreach (var item in itemsToRemove)
        {
            Items.Remove(item);
        }
    }
 
    public void Dispose()
    {
        _purgeTimer.Dispose();
    }
}

Je pense qu'il vaut mieux purger la collection à intervalle régulier, plutot qu'à chaque accès à un de ces membres, parce que sinon ça va tuer les perfs (la recherche des éléments à supprimer étant en temps linéaire)

L'inconvénient c'est qu'il faudrait rajouter un mécanisme de synchro (lock par exemple) pour éviter que la collection ne soit purgée pendant qu'on l'énumère...