Gestion des exceptions et multi couches. Non remonté dans DispatcherUnhandledException (App.xaml)

Version imprimable

31/07/2011, 20h46
takinelinfo

Gestion des exceptions et multi couches. Non remonté dans DispatcherUnhandledException (App.xaml)

Bonjour à tous,

Je suis en train de mettre en place la gestion des exceptions dans mon application WPF. Avant de gérer spécifiquement les exceptions, je voudrais dans un 1er temps les "logger" si elles ne sont pas "catchées".

J'ai donc déclarer une méthode pour DispatcherUnhandledException dans mon fichier App.xaml. Quand j'ai une exception dans ma couche GUI ça fonctionne, par contre si c'est dans ma couche DAL ou BLL, ça ne remonte pas dans cette fonction.

Y a t'il une subtilité pour pouvoir les faire remonter?
31/07/2011, 21h13
meziantou

Il vaut peut-être mieux utiliser AppDomain.UnhandledException pour récupérer toutes les exceptions non gérées.
http://msdn.microsoft.com/en-us/libr...exception.aspx
31/07/2011, 21h25
takinelinfo

Citation:

Envoyé par meziantou

Il vaut peut-être mieux utiliser AppDomain.UnhandledException pour récupérer toutes les exceptions non gérées.
http://msdn.microsoft.com/en-us/libr...exception.aspx

Effectivement ça à l'air de fonctionner. Par contre je ne vois pas la différence THEORIQUE qu'il y à entre DispatcherUnhandledException et UnhandledException . En tout cas merci à toi
31/07/2011, 21h45
meziantou

http://stackoverflow.com/questions/3...ception-in-net
31/07/2011, 22h03
takinelinfo
Ok un grand merci. SI j'implémente la méthode AppDomain, je peux donc oublier l'autre. C'est vraiment celle de AppDomain qui m'intéréssait car je voulais attraper toute les exceptions et pas seulement celle de la couche GUI.

Une dernière question concernant cette méthode. Je n'ai pas l'impression que ce soit possible mais peut on quitter l'application proprement (sans message d'erreur Windows?)

Avec l'autre gestionnaire il y avait la possibilité de faire:
Code:

1 2 3 MessageBox.Show("Mon message blablbla.......",......); e.Handled = true; //Annule le message de windows Current.Shutdown()
31/07/2011, 23h41
giova_fr

avec AppDomain.UnhandledException, c'est purement et simplement impossible "d'anuler" l'exception.

A moins de refaire un CLR :(

De plus, il ne catch pas forcément tout, certaines exception dans des threads placés dans le thread pool peuvent passer au travers de cette callback par exemple. J'ai également rencontré des problemes en utilisant plusieurs AppDomains.
01/08/2011, 00h23
takinelinfo

Citation:

Envoyé par giova_fr

avec AppDomain.UnhandledException, c'est purement et simplement impossible "d'anuler" l'exception.

A moins de refaire un CLR :(

De plus, il ne catch pas forcément tout, certaines exception dans des threads placés dans le thread pool peuvent passer au travers de cette callback par exemple. J'ai également rencontré des problemes en utilisant plusieurs AppDomains.

Et ceux qui sont passés à travers, tu as trouvé une solution pour les catcher ou non?

Et bien je limite au maximum l'utilisation de threads dans le thread pool. Entre autre je me suis fais ma propre classe Timer.

Je ne vous dis pas le nombre d'exception que j'ai découvert en basculant sur cette classe !!!!
Apres je ne dis pas que le thread pool est mauvais, il a plein d'avantages et peut se montrer indispensable, mais j'aime bien savoir ce qui se passe, ne pas laisser trainer les anomalies !

Sinon, il faut s'abonner au UnhandledException de l'appdomaine principale, et non à ses enfants (voir msdn).

Pour ceux que ca interresse, voici ma classe Timer:

Ses avantages :
-les execptions non traitées ne seront pas "avalées".
-Vous pouvez nommer le thread !

Code:

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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace FrameWork
{
    public class MonTimer : IDisposable
    {
        int m_interval;
        public int Interval
        {
            get { return m_interval; }
            set {
                if (m_interval < 0)
                    throw new ArgumentOutOfRangeException("Un thread ne peut pas avoir un interval de temps < 0");
                m_interval = value; }
        }
 
        private bool m_Enabled;
        readonly object lockgetter = new object();
        readonly object locksetter = new object();
        public bool Enable
        {
            get 
            {
                lock (lockgetter)
                {
                    m_enableLocker.WaitOne();
                    return m_Enabled;
                }
            }
            set
            {
                bool old;
                lock (locksetter)
                {
                    m_enableLocker.Reset();
                    old = m_Enabled;
                    m_Enabled = value;
 
                    m_enableLocker.Set();
                }
                if (old != m_Enabled)
                {
                    if (!m_Enabled)
                        Stop();
                    else
                        Start();
                }
            }
        }
 
        Thread m_thread;
        EventWaitHandle m_enableLocker;
 
 
 
        public event EventHandler Tick;
        readonly object lockStart = new object();
        public void Start()
        {
            lock (lockStart)
            {
                if (m_thread == null)
                {
                    m_thread = new Thread(Run);
                    m_thread.Name = "(MonTimer) "+m_threadName;
                    m_thread.IsBackground = true;
                    Enable = true;
                    m_thread.Start();
                }
            }
        }
        readonly object lockStop = new object();
        public void Stop()
        {
            lock (lockStop)
            {
                this.Enable = false;
                if (m_thread != null)
                {
                    if (m_thread != Thread.CurrentThread)
                    {
                        m_thread.Join(10000 + m_interval);
                        if (m_thread.IsAlive)
                        {
                            try
                            {
                                m_thread.Interrupt();
                            }
                            catch
                            {
                            }
                            String errmsg = String.Format("Le Thread '{0}' n'a pas su s'arretter apres 30 Secondes malgrés la demande d'interruption", m_thread.Name);
                            m_thread = null;
                            throw new ThreadInterruptedException(errmsg);
                        }
                        m_thread = null;
                    }
                    else //Si c'est le thread lui meme qui demande à se terminer on va créer un watcher
                        new Thread(delegate() { Stop(); }); //Ce thread annonyme jetera une exception dans Stop si le thread en cours ne se termine pas dans les 30 secondes
                }
            }
        }
 
        String m_threadName;
 
        private static readonly object s_lockConstruct = new object();
 
        public MonTimer(String nom)
        {
            lock (s_lockConstruct)
            {
                if (String.IsNullOrEmpty(nom))
                    throw new ArgumentOutOfRangeException("Le thread du timer doit forcement comporter un nom");
 
                m_interval = 0;
                m_threadName = nom;
                Init();
            }
        }
 
        public MonTimer(String nom,int interval)
        {
            lock (s_lockConstruct)
            {
                if (String.IsNullOrEmpty(nom))
                    throw new ArgumentOutOfRangeException("Le thread du timer doit forcement comporter un nom");
                m_interval = interval;
                m_threadName = nom;
                Init();
            }
        }
 
        private void Init()
        {
            m_Enabled = true;
            m_enableLocker = new EventWaitHandle(true, EventResetMode.ManualReset);
        }
        private void Run()
        {
            Stopwatch m_chrono = new Stopwatch();
            do
            {
                m_chrono.Reset();
                m_chrono.Start();
                if (Tick != null)
                    Tick(this, EventArgs.Empty);
                m_chrono.Stop();
                int delay = m_interval - (int)m_chrono.ElapsedMilliseconds;
                if (delay > 0)
                    Thread.Sleep(delay);
            } while (this.Enable);
 
        }
 
        #region IDisposable Members
 
        public void Dispose()
        {
            try
            {
                Stop();
            }
            catch { }
        }
 
        #endregion
 
        public override string ToString()
        {
            return String.Format("({0}) : {1}", this.GetType(), m_threadName);
        }
    }
}