Discussion :

[jmclej]

Bonjour,
J'ai une méthode log qui attend d'être appelée de la manière suivante par la méthode toto (nom) :

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
public static void toto(ref decimal? limit, ref string code)
{
log("limit", typeof(decimal?), "code", typeof(string));
...
}
public static int log(params object[] parameters)
{
    if ( (parameters[i].GetType() != typeof(string)) ||
        !(parameters[i + 1] is Type))
    {
        return 0;
    }
    else
    {
        if (parameters[i + 1].GetType() == typeof(decimal?))
        {
            ....
        }
        else if (parameters[i + 1].GetType() == typeof(string))
        {
            ....
        }
        ....
    }
    return ... ;
}

Le problème est que mes tests ne fonctionnent pas car le type d'un typeof n'est pas un System.Type mais un System.RuntimeType
Quand je regarde la valeur du premier parameters[i + 1].ToString(), j'obtiens "System.Nullable`1[System.Decimal]", il doit donc bien y avoir moyen d'obtenir le "sous-type" de parameters[i + 1] d'une meilleur manière qu'aller regarder si le tostring() contient System.Decimal ou System.String, etc... Mais je ne sais pas comment. Est-ce que vous pouvez m'aider s'il vous plaît ?

[Bluedeep]

Bonjour

D'abord System.RuntimeType n'est pas une classe publique, et de plus dérive de System.Type.

Sinon, je ne comprends pas trop ton problème.

En effet, ce type de test fonctionne parfaitement :

Code :

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

1
2
3
4
			string s = "x";
			Type t1 = typeof(string );
			Type t2 = s.GetType();
			bool ok = t1 == t2;

ok est toujours à "true".

Sinon, tu as aussi une solution très simple :

Code :

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

parameters[i].GetType().FullName != typeof(string).FullName

Par ailleurs, tester directement des trucs du type Nullable<decimal> (i.e. decimal?) me semble une idée assez douteuse.

Mieux vaut tester le type sousjacent quand tu reçois un Nullable<X>, car je ne pense pas que tu traite fondamentalement différement un Nullable<decimal> d'un decimal.

Peut on connaitre l'objectif fonctionnel ici ? pourquoi ne passes tu pas plutot par des méthodes génériques ?

[jmclej]

Ce n'est pas parameters[i] qui me pose problème, mais parameters[i+1], et ici, parameters[i+1].GetType().FullName = "System.RuntimeType". Et je voudrais savoir quel est le type sous-jacent, à savoir System.Decimal nullable.
Le bout de test que tu mets en exemple n'est pas ce qui me pose problème, on peut voir par contre que :

Code :

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

1
2
3
4
5
string str = string.Empty;
Type strType = str.GetType();
Type strTypeType = strType.GetType();
strType.ToString();     // returns "System.string"
strTypeType.ToString(); // returns "System.RuntimeType"

Moi j'ai besoin de savoir comment détecter le type "sous" strTypeType, à savoir "System.string"

[Bluedeep]

Ton problème vient du fait que tu appelle GetType sur une varable de type Type; donc tu récupére le type de la variable qui contient le Type, au lieu du contenu de la variable (qui lui est le type).

Cela revient à écrire :

typeof(decimal).GetType();

cf. exemple :

Code :

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

1
2
3
4
5
6
		static void Main()
		{		
			Console.WriteLine(typeof(decimal?).GetType().FullName);
			Console.WriteLine(typeof(decimal?).FullName);
			Console.ReadKey();
		}

Le test pour ce ca slà peut se faire ainsi :

Code :

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

1
2
3
4
5
6
7
			if (o.GetType().FullName == "System.RuntimeType")
			{
				string typeFullName = (o as Type).FullName;
				Console.WriteLine(typeFullName);
			}
			else
				Console.WriteLine(o.GetType().FullName);

[jmclej]

C'est bien ce que je veux faire.
Par contre, je veux pouvoir le comparer par la suite à des typeof(decimal?), typeof(decimal), typeof(string), typeof(int?), typeof(int), etc...
Et quand je fais ce que tu préconises : (parameters[i + 1] as Type).FullName, j'obtiens un type string contenant "System.Nullable`1[[System.Decimal, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]"

[jmclej]

Oh, je viens de voir que typeof(decimal?).FullName = "System.Nullable`1[[System.Decimal, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]", soit la même chaîne. Donc je peux effectivement comparer ces 2 strings j'imagine.
Merci

[Bluedeep]

Si encore une fois, tu donnais l'objectif fonctionnel de ce qui parait quand même être un bricolage, on pourrait te guider vers une solution plus adaptée.

[jmclej]

En fait, je fais un site web et je souhaite logguer chaque appel à une procédure stockée de manière à pouvoir les ré-executer rapidement s'il y en a une qui ne donne pas les résultats attendus.
Au final j'ai donc fait cela:

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
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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
public static class Log
    {
        private static readonly object _lock = new object();
 
        public static void Mylog(ILog log, Divers.LogLevel level, string msg)
        {
            Log.Mylog(log, level, msg, null);
        }
 
        public static void Mylog(ILog log, Divers.LogLevel level, string msg, Exception e)
        {
            lock (_lock)
            {
                GlobalContext.Properties["login"] = HttpContext.Current.Session["login"];
                GlobalContext.Properties["IPAddress"] = HttpContext.Current.Request.UserHostAddress;
 
                switch (level)
                {
                    case Divers.LogLevel.Fatal:
                        if (e != null)
                            log.Fatal(msg, e);
                        else
                            log.Fatal(msg);
                        break;
                    case Divers.LogLevel.Error:
                        if (e != null)
                            log.Error(msg, e);
                        else
                            log.Error(msg);
                        break;
                    case Divers.LogLevel.Warn:
                        if (e != null)
                            log.Warn(msg, e);
                        else
                            log.Warn(msg);
                        break;
                    case Divers.LogLevel.Info:
                        if (e != null)
                            log.Info(msg, e);
                        else
                            log.Info(msg);
                        break;
                    case Divers.LogLevel.Debug:
                        if (e != null)
                            log.Debug(msg, e);
                        else
                            log.Debug(msg);
                        break;
                    default:
                        if (e != null)
                            log.Fatal(msg, e);
                        else
                            log.Fatal(msg);
                        break;
                }
            }
        }
    }
 
 
 
private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
 
public enum ReqType
        {
            Sql,
            StoredProcedureWithoutOutputParam,
            StoredProcedureWithOutputParam
        };
 
private static void FinalLogDBCalls(Divers.LogLevel level, string message)
        {
            message = "Database call : " + message;
            switch (level)
            {
                case Divers.LogLevel.Fatal:
                    Log.Mylog(log, Divers.LogLevel.Fatal, message);
                    break;
                case Divers.LogLevel.Error:
                    Log.Mylog(log, Divers.LogLevel.Error, message);
                    break;
                case Divers.LogLevel.Warn:
                    Log.Mylog(log, Divers.LogLevel.Warn, message);
                    break;
                case Divers.LogLevel.Info:
                    Log.Mylog(log, Divers.LogLevel.Info, message);
                    break;
                case Divers.LogLevel.Debug:
                    Log.Mylog(log, Divers.LogLevel.Debug, message);
                    break;
                default:
                    Log.Mylog(log, Divers.LogLevel.Fatal, message);
                    break;
            }
        }
 
        //We could do it with a collection of personnalized object Params that would define the value, the type, outputORnot
        //that would simplify the code of this procedure, but it would make each call more "complex"
        public static void LogDBCalls(Divers.LogLevel level, ReqType reqType, int? nb_output_params, string req, params object[] parameters)
        {
            if (String.IsNullOrEmpty(req))
            {
                FinalLogDBCalls(Divers.LogLevel.Error, "WRONG PARAMETERS IN LogDBCalls - 1");
            }
 
            StringBuilder declare = new StringBuilder();
            StringBuilder select = new StringBuilder();
            StringBuilder message = new StringBuilder();
            switch (reqType)
            {
                case ReqType.StoredProcedureWithOutputParam:
                    message.Append("exec " + req);
                    if ( (parameters.Length < 2) ||  //We need to have at least one pair fieldName/fieldType
                          (nb_output_params == null) ||  //We need to know the number of output params we have
                          (parameters.Length < (nb_output_params * 2)))  //We need to have pairs fieldName/fieldType
                    {
                        message.Append("WRONG PARAMETERS IN LogDBCalls - 2");
                        FinalLogDBCalls(Divers.LogLevel.Error, message.ToString());
                        break;
                    }
                    int index_of_first_output_param = parameters.Length - ((nb_output_params ?? 0) * 2);
                    for (var i = 0; i < parameters.Length; i++)
                    {
                        if (i >= index_of_first_output_param)
                        {
                            if ((index_of_first_output_param & 1) == 1)  //index_of_first_output_param is Odd
                            {
                                if (i % 2 == 0)  //parameters[i] defines the type, not the name of the output param
                                    continue;
                            }
                            else
                            {
                                if (i % 2 == 1)  //parameters[i] defines the type, not the name of the output param
                                    continue;
                            }
 
                            if ( (parameters[i].GetType() != typeof(string)) ||
                                 !(parameters[i + 1] is Type))
                            {
                                message.Append("WRONG PARAMETERS IN LogDBCalls - 3");
                                FinalLogDBCalls(Divers.LogLevel.Error, message.ToString());
                                break;
                            }
                            else
                            {
                                declare.Append("declare ");
 
                                //We are obliged to compare with FullName because parameters[i + 1].GetType() is of type System.RuntimeType
                                if ((parameters[i + 1] as Type).FullName == typeof(string).FullName)
                                {
                                    declare.AppendLine(String.Format("@{0} varchar(max)", parameters[i]));
                                    select.Append(String.Format("@{0} as {0}, ", parameters[i]));
                                }
                                else if ((parameters[i + 1] as Type).FullName == typeof(char).FullName)
                                {
                                    declare.AppendLine(String.Format("@{0} char(1)", parameters[i]));
                                    select.Append(String.Format("@{0} as {0}, ", parameters[i]));
                                }
                                else if (((parameters[i + 1] as Type).FullName == typeof(int).FullName) ||
                                          ((parameters[i + 1] as Type).FullName == typeof(int?).FullName))
                                {
                                    declare.AppendLine(String.Format("@{0} int", parameters[i]));
                                    select.Append(String.Format("@{0} as {0}, ", parameters[i]));
                                }
                                else if (((parameters[i + 1] as Type).FullName == typeof(decimal).FullName) ||
                                          ((parameters[i + 1] as Type).FullName == typeof(decimal?).FullName))
                                {
                                    declare.AppendLine(String.Format("@{0} numeric(18, 8)", parameters[i]));
                                    select.Append(String.Format("@{0} as {0}, ", parameters[i]));
                                }
                                else if (((parameters[i + 1] as Type).FullName == typeof(bool).FullName) ||
                                          ((parameters[i + 1] as Type).FullName == typeof(bool?).FullName))
                                {
                                    declare.AppendLine(String.Format("@{0} bit", parameters[i]));
                                    select.Append(String.Format("@{0} as {0}, ", parameters[i]));
                                }
                                else if (((parameters[i + 1] as Type).FullName == typeof(DateTime).FullName) ||
                                          ((parameters[i + 1] as Type).FullName == typeof(DateTime?).FullName))
                                {
                                    declare.AppendLine(String.Format("@{0} datetime", parameters[i]));
                                    select.Append(String.Format("@{0} as {0}, ", parameters[i]));
                                }
                                else
                                {
                                    declare.AppendLine(String.Format(" ('{0}' are not handled in LogDBCalls),", parameters[i + 1].GetType()));
                                }
                                message.Append(String.Format(" @{0} output,", parameters[i]));
                            }
                        }
                        else
                        {
                            if (parameters[i] == null)
                            {
                                message.Append(" null,");
                            }
                            else
                            {
                                if ((parameters[i].GetType() == typeof(string)) ||
                                     (parameters[i].GetType() == typeof(char)))
                                {
                                    message.Append(parameters[i] == null ? " null," : String.Format(" '{0}',", parameters[i]));
                                }
                                else
                                {
                                    if ((parameters[i].GetType() == typeof(int)) ||
                                         (parameters[i].GetType() == typeof(decimal)) ||
                                         (parameters[i].GetType() == typeof(bool)))
                                    {
                                        message.Append(String.Format(" {0},", parameters[i]));
                                    }
                                    else
                                    {
                                        if ((parameters[i].GetType() == typeof(int?)) ||
                                             (parameters[i].GetType() == typeof(decimal?)) ||
                                             (parameters[i].GetType() == typeof(bool?)))
                                        {
                                            message.Append(parameters[i] == null ? " null," : String.Format(" {0},", parameters[i]));
                                        }
                                        else
                                        {
                                            if (parameters[i].GetType() == typeof(DateTime))
                                            {
                                                message.Append(String.Format(" '{0:yyyyMMdd}',", (DateTime)parameters[i]));
                                            }
                                            else
                                            {
                                                if (parameters[i].GetType() == typeof(DateTime?))
                                                {
                                                    message.Append(parameters[i] == null ? " null," : String.Format(" '{0:yyyyMMdd}',", (DateTime)parameters[i]));
                                                }
                                                else
                                                {
                                                    message.Append(String.Format(" ('{0}' are not handled in LogDBCalls),", parameters[i].GetType()));
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (parameters.Length > 0)
                    {
                        if (nb_output_params > 0)
                        {
                            message = declare.Append(message.Remove(message.Length - 1, 1)).AppendLine().Append("select " + select.Remove(select.Length - 2, 2));
                        }
                        else
                        {
                            message = message.Remove(message.Length - 1, 1);
                        }
                    }
                    FinalLogDBCalls(level, message.ToString());
                    break;
                case ReqType.StoredProcedureWithoutOutputParam:
                    message.Append("exec " + req);
                    if (nb_output_params != null)
                    {
                        message.Append("WRONG PARAMETERS IN LogDBCalls - 4");
                        FinalLogDBCalls(Divers.LogLevel.Error, message.ToString());
                        break;
                    }
                    for (var i = 0; i < parameters.Length; i++)
                    {
                        if (parameters[i] == null)
                        {
                            message.Append(" null,");
                        }
                        else
                        {
                            if ( (parameters[i].GetType() == typeof(string)) ||
                                 (parameters[i].GetType() == typeof(char)) )
                            {
                                message.Append(parameters[i] == null ? " null," : String.Format(" '{0}',", parameters[i]));
                            }
                            else
                            {
                                if ( (parameters[i].GetType() == typeof(int)) ||
                                     (parameters[i].GetType() == typeof(decimal)) ||
                                     (parameters[i].GetType() == typeof(bool)) )
                                {
                                    message.Append(String.Format(" {0},", parameters[i]));
                                }
                                else
                                {
                                    if ( (parameters[i].GetType() == typeof(int?)) ||
                                         (parameters[i].GetType() == typeof(decimal?)) ||
                                         (parameters[i].GetType() == typeof(bool?)) )
                                    {
                                        message.Append(parameters[i] == null ? " null," : String.Format(" {0},", parameters[i]));
                                    }
                                    else
                                    {
                                        if (parameters[i].GetType() == typeof(DateTime))
                                        {
                                            message.Append(String.Format(" '{0:yyyyMMdd}',", (DateTime)parameters[i]));
                                        }
                                        else
                                        {
                                            if (parameters[i].GetType() == typeof(DateTime?))
                                            {
                                                message.Append(parameters[i] == null ? " null," : String.Format(" '{0:yyyyMMdd}',", (DateTime)parameters[i]));
                                            }
                                            else
                                            {
                                                message.Append(String.Format(" ('{0}' are not handled in LogDBCalls),", parameters[i].GetType()));
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    FinalLogDBCalls(level, parameters.Length > 0 ? message.Remove(message.Length - 1, 1).ToString() : message.ToString());
                    break;
                case ReqType.Sql:
                    message.Append(req);
                    FinalLogDBCalls(level, message.ToString());
                    break;
                default:
                    break;
            }
        }

Mon appel se fait de la manière suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public static int InsRequestPayment(int? thirdParty, decimal? amount, int? currency, string motif, string comment, DateTime? requestDate, int CustomerOID, ref decimal? limit, ref string ccy_name)
        {
            LogDBCalls(Divers.LogLevel.Info, ReqType.StoredProcedureWithOutputParam, 2, "ins_RequestPayment", thirdParty, amount, currency, motif, comment, requestDate, CustomerOID, "limit", typeof(decimal?), "ccy_name", typeof(string));
            return DB.ins_RequestPayment(thirdParty, amount, currency, motif, comment, requestDate, CustomerOID, ref limit, ref ccy_name);
        }
 
        public static IEnumerable GetCustomer(int? CustomerId)
        {
            LogDBCalls(Divers.LogLevel.Info, ReqType.StoredProcedureWithoutOutputParam, null, "sel_Customers", CustomerId);
            return DB.sel_Customers(CustomerId);
        }

[Bluedeep]

En fait, je fais un site web et je souhaite logguer chaque appel à une procédure stockée de manière à pouvoir les ré-executer rapidement s'il y en a une qui ne donne pas les résultats attendus.

Avec quel type de SGBD ?

Sur Sql Server, par exemple, tu peux auditer les appels de proc stoc (avec Sql Profiler ou Sql Server Audit). Avec Oracle je crois que c'est possible aussi.

Bref, je ne vois pas trop l'intérêt de faire cela coté applicatif.

[jmclej]

J'utilise SQL SERVER 2008.
D'expérience, faire cela côté applicatif permet de ne pas avoir à dépendre des dba pour avoir des infos complètes. D'une manière générale, avoir le plus d'infos possible directement accessible (sans passer par un admin système ou dba ou peu importe) augmente grandement la rapidité de résolution des problèmes.
Je n'ai pas la main sur les outils de SQL Server Management studio et je ne pense pas que les logs sont conservées très longtemps, et souvent les dba ne mette pas des traces fines jusqu'au moment où on a un problème.
De plus, je compte faire une petite interface qui permettra de lire un fichier de log et de suivre un utilisateur en particulier, ce qui sera très pratique pour valider s'il a effectué ou non telle ou telle opération et à quel moment. J'ai comme cela son historique complet et pas seulement après qu'il ait eu un problème, ce qui peut être trop tard pour être utile.

[Bluedeep]

J'utilise SQL SERVER 2008.
D'expérience, faire cela côté applicatif permet de ne pas avoir à dépendre des dba pour avoir des infos complètes.

Avec le Profiler non plus. Et avec l'Audit iol suffit de demander un accès en lectures aux éléments audité qu t'intéresse.

Je n'ai pas la main sur les outils de SQL Server Management studio

[jmclej]

Je bosse dans une grosse boîte, et donc tout est très compartimenté malheureusement (heureusement parfois...).
Je préfère donc, pour une fois que j'ai l'occasion de coder from scratch, de prévoir d'avoir accès au maximum d'info possible pour résoudre d'éventuels problèmes le plus rapidement possible. J'ai pu expérimenter à quel point cela est pénible lorsque ce n'était pas le cas..