Discussion :

[roubi]

Bonjour,

soit des méthodes:

Code :

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

1
2
3
4
5
 public void methode1()
{methode2();}
 public void methode2()
{ methode3();}
 public void methode3(){}

je voudrais mesurer le temps d’exécution de la méthode 1 + le temps qu'il a passé dans les methodes 2 et 3. (pour le même appel)
pour le moment j'utilise stopwatch() pour mesurer le temps d’exécution de la methode1.
il y aurait il une extension ou une méthode permettant de faire cela?

[Sehnsucht]

Bonjour,

L'idéal dans ton cas serait de pouvoir étendre le type StopWatch pour lui ajouter une méthode statique, sauf qu'en C# on peut pas faire une extension statique au pire. On pourrait sinon étendre Func et Action sauf que l'utilisation s'en retrouve plus verbeuse ; bref voici les divers choix que je suggère (sans trop savoir lequel est le plus adapté )

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
// Extensions sur StopWatch
static class StopWatchExtensions
{
    // Version 1 ; renvoi du résultat + renvoi du temps en paramètre out
    // Exemple d'utilisation
    // TimeSpan elapsed;
    // int result = new Stopwatch().Measure(() => 42, out elapsed);
    // Défaut: obliger d'instancier alors qu'une méthode statique serait préférable
    public static T Measure<T>(this Stopwatch sw, Func<T> body, out TimeSpan elapsed)
    {
        sw.Restart();
        T result = body();
        elapsed = sw.Elapsed;
        return result;
    }
 
    // Version 1 ; renvoi du temps en paramètre out (on pourrait le renvoyer par la méthode au lieu de void, mais j'essaie de rester constant avec l'autre prototype)
    // Exemple d'utilisation
    // TimeSpan elapsed;
    // new Stopwatch().Measure(() => Console.Write("Hello"), out elapsed);
    // Défaut: obliger d'instancier alors qu'une méthode statique serait préférable
    public static void Measure<T>(this Stopwatch sw, Action body, out TimeSpan elapsed)
    {
        sw.Restart();
        body();
        elapsed = sw.Elapsed;
    }
 
    // Version 2 ; Utilisation d'une continuation, pour exploiter le résultat et le temps
    // Exemple d'utilisation
    // new Stopwatch().Measure(() => 42, (result, elapsed) => Console.WriteLine("{0} in {1}", result, elapsed));
    // Défaut: obliger d'instancier alors qu'une méthode statique serait préférable
    public static void Measure<T>(this Stopwatch sw, Func<T> body, Action<T, TimeSpan> continuation)
    {
        sw.Restart();
        T result = body();
        continuation(result, sw.Elapsed);
    }
 
    // Version 2 ; Utilisation d'une continuation, pour exploiter le temps (également je garde la même constance d'utilisation)
    // Exemple d'utilisation
    // new Stopwatch().Measure(() => Console.Write("Hello"), elapsed => Console.WriteLine(" execution: {0}", elapsed));
    // Défaut: obliger d'instancier alors qu'une méthode statique serait préférable
    public static void Measure<T>(this Stopwatch sw, Action body, Action<TimeSpan> continuation)
    {
        sw.Restart();
        body();
        continuation(sw.Elapsed);
    }
}
 
static class DelegateExtensions // nom pas forcément le plus adapté)
{
    // Version 1 ; renvoi du résultat + renvoi du temps en paramètre out
    // Exemple d'utilisation
    // TimeSpan elapsed;
    // int result = new Func<int>(() => 42).Measure(out elapsed);
    // Défaut: obliger  de créer "verbeusement" l'expression lambda
    public static T Measure<T>(this Func<T> body, out TimeSpan elapsed)
    {
        var sw = Stopwatch.StartNew();
        T result = body();
        elapsed = sw.Elapsed;
        return result;
    }
 
    // Version 1 ; renvoi du temps en paramètre out (idem constance)
    // Exemple d'utilisation
    // TimeSpan elapsed;
    // new Action(() => Console.Write("Hello")).Measure(out elapsed);
    // Défaut: obliger  de créer "verbeusement" l'expression lambda
    public static void Measure(this Action body, out TimeSpan elapsed)
    {
        var sw = Stopwatch.StartNew();
        body();
        elapsed = sw.Elapsed;
    }
 
    // Version 2 ; Utilisation d'une continuation, pour exploiter le résultat et le temps
    // Exemple d'utilisation
    // new Func<int>(() => 42).Measure((result, elapsed) => Console.WriteLine("{0} in {1}", result, elapsed));
    // Défaut: obliger  de créer "verbeusement" l'expression lambda
    public static void Measure<T>(this Func<T> body, Action<T, TimeSpan> continuation)
    {
        var sw = Stopwatch.StartNew();
        continuation(body(), sw.Elapsed);
    }
 
    // Version 2 ; Utilisation d'une continuation, pour exploiter le temps (idem constance)
    // Exemple d'utilisation
    // new Action(() => Console.Write("Hello")).Measure(elapsed => Console.WriteLine(" execution: {0}", elapsed));
    // Défaut: obliger  de créer "verbeusement" l'expression lambda
    public static void Measure(this Action body, Action<TimeSpan> continuation)
    {
        var sw = Stopwatch.StartNew();
        body();
        continuation(sw.Elapsed);
    }
}

À voir maintenant, au passage, je suis preneur, de ceux qui ont trouvé une solution

P.S. À titre informatif voilà comment cela pourrait se faire en F# (enfin avec mon niveau ):

Code F# :

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
// Extension du type Stopwatch
type Stopwatch with
  // oui on peut ajouter une méthode statique
  static member Measure body =
    let sw = Stopwatch.StartNew ()
    let result = body ()
    (result, sw.Elapsed)
 
  static member Measure (body, continuation) =
    continuation (Stopwatch.Measure body)
 
// Utilisation
// ici Measure renvoie un tuple 'T, TimeSpan, je peux récupérer séparément les valeurs.
let (result, elapsed) = Stopwatch.Measure (fun () -> 42)
 
// ici Measure renvoie un tuple unit, TimeSpan ; (unit étant, pour faire court un équivalent de void, mais récupérable), j'utilise donc _ pour correspondre au pattern sans toutefois vouloir stocker cette partie là.
let (_, elapsed) = Stopwatch.Measure (fun () -> printf "Hello")
 
// versions avec continuation:
Stopwatch.Measure ((fun () -> 42), fun (result, elapsed) -> printfn "%d in %A" result elapsed)
 
Stopwatch.Measure ((fun () -> printf "Hello"), fun (_, elapsed) -> printfn " execution: %A" elapsed)

Cordialement !