Comment puis-je mesurer la durée de fonctionnement d'une fonction?

N'utilisez pas de minuterie - utilisez la classe Stopwatch .

var sw = new Stopwatch();
Result result = new Result();

sw.Start();
result = new GeneticAlgorithms().TabuSearch(parametersTabu, functia);

sw.Stop();

// sw.Elapsed tells you how much time passed

vous devez utiliser la classe de chronomètre pour les fonctions de chronométrage.

essayez ce qui suit:

private int counter = 0;

// setup stopwatch and begin timing
var timer = System.Diagnostics.Stopwatch.StartNew();

Result result = new Result();
result = new GeneticAlgorithms().TabuSearch(parametersTabu, functia);

// stop timer and get elapsed time
timer.Stop();
var elapsed = timer.Elapsed;

// display result time
MessageBox.Show(elapsed.ToString("mm':'ss':'fff"));

la meilleure façon de voir combien de temps un peu de code prend à courir est d'utiliser System.Diagnostics.Stopwatch .

voici un exemple:

using System.Diagnostics;

#if DEBUG
     Stopwatch timer = new Stopwatch();
     timer.Start();
#endif

     //Long running code

#if DEBUG
     timer.Stop();
     Debug.WriteLine("Time Taken: " + timer.Elapsed.TotalMilliseconds.ToString("#,##0.00 'milliseconds'"));
#endif

j'utilise le #if DEBUG pour m'assurer que le code du chronomètre n'entre pas dans la version de production, mais vous pourriez vous en passer.

Visual Studio 2015 , 2017 Professionnel et L'entreprise a Outil de diagnostic. Si vous avez un point de rupture à la fin de votre fonction, il affichera l'heure et la durée sous L'onglet Events comme indiqué dans l'image:

vous pouvez voir l'article outils de Diagnostic débogueur fenêtre dans Visual Studio 2015 pour plus de détails.

PS; jusqu'à présent seulement Xamarin formes, cross platform project ne supporte pas cette fonctionnalité. Je souhaite que Microsoft apporte cette grande fonctionnalité pour xamarin forms projets.

utiliser Chronomètre du système.Diagnostics:

static void Main(string[] args)
{
    Stopwatch stopWatch = new Stopwatch();
    stopWatch.Start();
    Thread.Sleep(10000);
    stopWatch.Stop();

    // Get the elapsed time as a TimeSpan value.
    TimeSpan ts = stopWatch.Elapsed;

    // Format and display the TimeSpan value.
    string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds,
        ts.Milliseconds / 10);
    Console.WriteLine("RunTime " + elapsedTime);
}

pour chronométrer une fonction, vous devez utiliser le la classe de Chronomètre

aussi, la raison pour laquelle votre minuterie ne compte pas est que vous n'avez pas mis d'intervalle pour cela.

peut-être, vous pourriez écrire une méthode comme ça:

public static void Time(Action action)
{
    Stopwatch st = new Stopwatch();
    st.Start();
    action();
    st.Stop();
    Trace.WriteLine("Duration:" + st.Elapsed.ToString("mm\:ss\.ff"));
}

et l'utiliser comme ça:

Time(()=>
{
 CallOfTheMethodIWantToMeasure();
});

j'ai examiné et accepté toutes les suggestions. Mais nous voulions partager une implémentation générique pour l'enregistreur de temps d'exécution où nous ne voulons pas implémenter la logique du chronomètre plusieurs fois mais voulons tout de même mesurer le temps d'exécution pour plusieurs méthodes.

la raison principale pour ne pas mettre en œuvre logger de manière générique est - l'exécution de la méthode est entre deux chronomètres.Start () et chronomètre.Stop () Nous pouvons également exiger le résultat de la méthode après l'exécution pour un traitement ultérieur.

donc pour aborder cette question j'ai créé après la mise en œuvre de l'échantillon où le temps D'exécution est enregistré séparément sans le mélanger avec le flux de la méthode réelle.

public static class Helper
{
    public static T Time<T>(Func<T> method, ILogger log)
    {
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        var result = method();
        stopwatch.Stop();
        log.Info(string.Format("Time Taken For Execution is:{0}", stopwatch.Elapsed.TotalMilliseconds));
        return result;
    }
}

public class Arithmatic
{
    private ILogger _log;
    public Arithmatic(ILogger log)//Inject Dependency
    {
        _log = log;
    }

    public void Calculate(int a, int b)
    {
        try
        {
            Console.WriteLine(Helper.Time(() => AddNumber(a, b), _log));//Return the result and do execution time logging
            Console.WriteLine(Helper.Time(() => SubtractNumber(a, b), _log));//Return the result and do execution time logging
        }
        catch (Exception ex)
        {
            _log.Error(ex.Message, ex);
        }
    }

    private string AddNumber(int a, int b)
    {
        return "Sum is:" + (a + b);
    }

    private string SubtractNumber(int a, int b)
    {
        return "Subtraction is:" + (a - b);
    }
}

public class Log : ILogger
{
    public void Info(string message)
    {
        Console.WriteLine(message);
    }

    public void Error(string message, Exception ex)
    {
        Console.WriteLine("Error Message:" + message, "Stacktrace:" + ex.StackTrace);
    }
}

public interface ILogger
{
    void Info(string message);
    void Error(string message, Exception ex);
}

L'Appel De La Partie:

 static void Main()
 {
    ILogger log = new Log();
    Arithmatic obj = new Arithmatic(log);
    obj.Calculate(10, 3);
    Console.ReadLine();
 }

enregistrer l'heure à laquelle l'étape en cours commence à traiter

DateTime dtStart = DateTime.Now;

//Calculate the total number of milliseconds request took (Timespan = to represent the time interval)-> current - started time stamp ...
//TotalMilliseconds -->Gets the value of the current TimeSpan structure expressed in whole and fractional milliseconds.
// to measure how long a function is running 
var result=((TimeSpan)(DateTime.Now - dtStart)).TotalMilliseconds.ToString("#,##0.00") + "ms";