当前位置: 澳门新濠3559 > 编程 > 正文

实例可以很好的测量一个时间间隔的运行时间,

时间:2019-11-08 23:18来源:编程
结合Stopwatch 使用打印测量某个时间间隔的运行时间的方法 StartNew:初始化新的 Stopwatch实例,将运行时间属性设置为零,然后开始测量运行时间。 引用命名空间: using System.Diagnostics;

结合Stopwatch 使用打印测量某个时间间隔的运行时间的方法

StartNew:初始化新的 Stopwatch 实例,将运行时间属性设置为零,然后开始测量运行时间。

引用命名空间: using System.Diagnostics;

Start:开始或继续测量某个时间间隔的运行时间。

Reset;//停止时间间隔测量,并将运行时间重置为零

 

 

GetRawElapsedTicks:获取总运行时间,包括从 Stopwatch 上次启动开始起的时间。

打印日志方法,目录也可以自己指定:

IsRunning:获取一个值,该值指示 Stopwatch 计时器是否正在运行。

Start;//开始或继续测量某个时间间隔的运行时间

实例可以很好的测量一个时间间隔的运行时间,初始化 Stopwatch 类的新实例。GetType:获取当前实例的 Type。 (继承自 Object。)

Restart;//停止时间间隔测量,并将运行时间重置为零,然后开始测量运行时间

Equals(Object):确定指定的对象是否等于当前对象。(继承自 Object。)

打印一个接口、方法的运行时间在程序中是很容易遇到的一件事情;现在,我就分享一个我在工作中使用的临时打印日志的方法和结合 Stopwatch 打印测量某个时间间隔的运行时间的方法。

GetElapsedDateTimeTicks:如果系统正在使用高分辨率计数器,请获取高分辨率刻度作为 DateTime.Ticks。

Stopwatch 实例可以很好的测量一个时间间隔的运行时间;以下例子是比较常用到的:

3、方法

     有不对或遗漏的地方,欢迎指出;

Stopwatch:初始化 Stopwatch 类的新实例。

 1         public static void WriteError(string message)
 2         {
 3             string path = AppDomain.CurrentDomain.BaseDirectory;//获取基目录
 4             path = System.IO.Path.GetDirectoryName(path) + " \ErrorLogs";//设置输出日志输出目录
 5             try
 6             {
 7                 if (!System.IO.Directory.Exists(path))
 8                 {
 9                     System.IO.Directory.CreateDirectory(path);
10                 }
11                 string fileName = System.IO.Path.Combine(path, DateTime.Now.ToString("yyyy-MM-dd") + ".log");
12                 System.IO.StreamWriter sw = new System.IO.StreamWriter(fileName, true);//文件流创建写数据流
13                 sw.WriteLine(DateTime.Now.ToString("HH:mm:ss:fff") + " -------------------");
14                 sw.WriteLine(message);
15                 sw.WriteLine();
16                 sw.Close();//关闭写数据流
17             }
18             catch
19             {
20             }
21         }

6、示例代码二

1          var s = new Stopwatch();
2          //需要测试运行时间的的代码
3          WriteError(s.ElapsedMilliseconds.ToString() + "  GetNewUpdateFileList");//打印运行时间

4 s.Reset();

Finalize:在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。 (继承自 Object。)

注:方法为小七在工作中用到的方法,如果转载,请注明出处;

1、构造函数:

ElapsedMilliseconds;//获取当前实例测量得出的总运行时间(以毫秒为单位)

using System;
using System.Diagnostics;
using System.Threading;
class Program
{
    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);
    }
}

     欢迎评论;

2、属性

Elapsed;//获取当前实例测量得出的总运行时间(以时分秒为单位)

IsHighResolution:指示计时器是否基于高分辨率性能计数器。 此字段为只读。

Stopwatch//Stopwatch 实例

Reset:停止时间间隔测量,并将运行时间重置为零。

不定期、看心情从本人博客搬来文章藏博客园。欢迎来访博客查阅最新文章:www.zengqiang.org

Stop:停止测量某个时间间隔的运行时间。

Stopwatch 类: 提供一组方法和属性,可用于准确地测量运行时间。

MemberwiseClone:创建当前 Object 的浅表副本。 (继承自 Object。)

using System;
using System.Diagnostics;

namespace StopWatchSample
{
    class OperationsTimer
    {
        public static void Main()
        {
            DisplayTimerProperties();

            Console.WriteLine();
            Console.WriteLine("Press the Enter key to begin:");
            Console.ReadLine();
            Console.WriteLine();

            TimeOperations();
        }

        public static void DisplayTimerProperties()
        {
            // Display the timer frequency and resolution.
            if (Stopwatch.IsHighResolution)
            {
                Console.WriteLine("Operations timed using the system's high-resolution performance counter.");
            }
            else 
            {
                Console.WriteLine("Operations timed using the DateTime class.");
            }

            long frequency = Stopwatch.Frequency;
            Console.WriteLine("  Timer frequency in ticks per second = {0}",
                frequency);
            long nanosecPerTick = (1000L*1000L*1000L) / frequency;
            Console.WriteLine("  Timer is accurate within {0} nanoseconds", 
                nanosecPerTick);
        }

        private static void TimeOperations()
        {
            long nanosecPerTick = (1000L*1000L*1000L) / Stopwatch.Frequency;
            const long numIterations = 10000;

            // Define the operation title names.
            String [] operationNames = {"Operation: Int32.Parse("0")",
                                           "Operation: Int32.TryParse("0")",
                                           "Operation: Int32.Parse("a")",
                                           "Operation: Int32.TryParse("a")"};


            // Time four different implementations for parsing 
            // an integer from a string. 

            for (int operation = 0; operation <= 3; operation++)
            {
                // Define variables for operation statistics.
                long numTicks = 0;
                long numRollovers = 0;
                long maxTicks = 0;
                long minTicks = Int64.MaxValue;
                int indexFastest = -1;
                int indexSlowest = -1;
                long milliSec = 0;

                Stopwatch time10kOperations = Stopwatch.StartNew();

                // Run the current operation 10001 times.
                // The first execution time will be tossed
                // out, since it can skew the average time.

                for (int i=0; i<=numIterations; i++) 
                {
                    long ticksThisTime = 0;
                    int inputNum;
                    Stopwatch timePerParse;

                    switch (operation)
                    {
                        case 0:
                            // Parse a valid integer using
                            // a try-catch statement.

                            // Start a new stopwatch timer.
                            timePerParse = Stopwatch.StartNew();

                            try 
                            {
                                inputNum = Int32.Parse("0");
                            }
                            catch (FormatException)
                            {
                                inputNum = 0;
                            }

                            // Stop the timer, and save the
                            // elapsed ticks for the operation.

                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 1:
                            // Parse a valid integer using
                            // the TryParse statement.

                            // Start a new stopwatch timer.
                            timePerParse = Stopwatch.StartNew();

                            if (!Int32.TryParse("0", out inputNum))
                            { 
                                inputNum = 0;
                            }

                            // Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 2:
                            // Parse an invalid value using
                            // a try-catch statement.

                            // Start a new stopwatch timer.
                            timePerParse = Stopwatch.StartNew();

                            try 
                            {
                                inputNum = Int32.Parse("a");
                            }
                            catch (FormatException)
                            {
                                inputNum = 0;
                            }

                            // Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 3:
                            // Parse an invalid value using
                            // the TryParse statement.

                            // Start a new stopwatch timer.
                            timePerParse = Stopwatch.StartNew();

                            if (!Int32.TryParse("a", out inputNum))
                            { 
                                inputNum = 0;
                            }

                            // Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;

                        default:
                            break;
                    }

                    // Skip over the time for the first operation,
                    // just in case it caused a one-time
                    // performance hit.
                    if (i == 0)
                    {
                        time10kOperations.Reset();
                        time10kOperations.Start();
                    }
                    else 
                    {

                        // Update operation statistics
                        // for iterations 1-10001.
                        if (maxTicks < ticksThisTime)
                        {
                            indexSlowest = i;
                            maxTicks = ticksThisTime;
                        }
                        if (minTicks > ticksThisTime)
                        {
                            indexFastest = i;
                            minTicks = ticksThisTime;
                        }
                        numTicks += ticksThisTime;
                        if (numTicks < ticksThisTime)
                        {
                            // Keep track of rollovers.
                            numRollovers ++;
                        }
                    }
                }  

                // Display the statistics for 10000 iterations.

                time10kOperations.Stop();
                milliSec = time10kOperations.ElapsedMilliseconds;

                Console.WriteLine();
                Console.WriteLine("{0} Summary:", operationNames[operation]);
                Console.WriteLine("  Slowest time:  #{0}/{1} = {2} ticks",
                    indexSlowest, numIterations, maxTicks);
                Console.WriteLine("  Fastest time:  #{0}/{1} = {2} ticks",
                    indexFastest, numIterations, minTicks);
                Console.WriteLine("  Average time:  {0} ticks = {1} nanoseconds", 
                    numTicks / numIterations, 
                    (numTicks * nanosecPerTick) / numIterations );
                Console.WriteLine("  Total time looping through {0} operations: {1} milliseconds", 
                    numIterations, milliSec);
            }
        }
     }
}

5、示例代码一

ElapsedTicks:获取当前实例测量得出的总运行时间(用计时器刻度表示)。

GetTimestamp:获取计时器机制中的当前刻度数。

Elapsed:获取当前实例测量得出的总运行时间。

ToString:返回表示当前对象的字符串。 (继承自 Object。)

ElapsedMilliseconds:获取当前实例测量得出的总运行时间(以毫秒为单位)。

Frequency:获取以每秒刻度数表示的计时器频率。 此字段为只读。

4、字段

GetHashCode:作为默认哈希函数。 (继承自 Object。)

编辑:编程 本文来源:实例可以很好的测量一个时间间隔的运行时间,

关键词: