C# Stopwatch.Start方法代码示例

    // Update is called once per frame
    void Update()
    {
        if(Input.GetKeyDown(KeyCode.Space))
        {
            System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
            watch.Reset();
            // Single call test
            watch.Start ();

            SingleCall ();

            watch.Stop ();
            long elapsedSingle = watch.ElapsedTicks;
            Debug.Log ("Single call: " + elapsedSingle + " ticks");
            watch.Reset();
            // Multicall test
            watch.Start ();

            for(int t = 0; t < Iterations; ++t)
            {
                MultiCall();
            }

            watch.Stop ();
            long elapsedMulti = watch.ElapsedTicks;
            Debug.Log ("Multi call: " + elapsedMulti + " ticks");

            Debug.Log ("Ratio (Multi/Single): " + elapsedMulti / (double)elapsedSingle);

        }
    }

 private void RunTests(Harness harness)
 {
     Clients.All.showmessage("Starting " + harness.Name + " tests...");
     var sw = new Stopwatch();
     sw.Start();
     for (var i = 0; i < OPERATIONS; i++)
     {
         var data = i.ToString();
         harness.Create(data);
     }
     sw.Stop();
     Clients.All.showmessage("Put " + OPERATIONS + " values in " + sw.ElapsedMilliseconds + "ms.");
     sw.Reset();
     sw.Start();
     for (var i = 0; i < OPERATIONS; i++)
     {
         var data = i.ToString();
         harness.Read(data);
     }
     sw.Stop();
     Clients.All.showmessage("Read " + OPERATIONS + " values in " + sw.ElapsedMilliseconds + "ms.");
     sw.Reset();
     sw.Start();
     for (var i = 0; i < OPERATIONS; i++)
     {
         var data = i.ToString();
         harness.Delete(data);
     }
     sw.Stop();
     Clients.All.showmessage("Deleted " + OPERATIONS + " values in " + sw.ElapsedMilliseconds + "ms.");
     Clients.All.showmessage("Completed " + harness.Name + " tests...");
 }

		/// <summary>
		/// Uruchamia grę z maksymalną wydajnością.
		/// </summary>
		public void Run()
		{
			if (!this.IsRunning)
			{
				this.IsRunning = true;
				Stopwatch elapsedTime = new Stopwatch();
				this.OnInit();
				elapsedTime.Start();
				while (this.Info.MainWindow.Exists && !this.IsExiting)
				{
					elapsedTime.Stop();
					double delta = elapsedTime.Elapsed.TotalSeconds;
					elapsedTime.Reset();
					elapsedTime.Start();

					if (delta > 1.0)
						delta = 1.0; //Przycinamy do max. 1 sekundy

					this.Info.MainWindow.ProcessEvents();
					this.OnUpdate(delta);
					this.OnRender();
					this.Info.MainWindow.Show();
				}

				if (this.IsExiting)
				{
					this.Info.MainWindow.Close();
				}
				this.OnDeinit();
			}
		}

        public void Searcher_When_SearcherWarmedUp_SearchIsFaster()
        {
            // Arrange
            var stopwatch = new Stopwatch();
            var indexsource = new FeedsDbContextIndexSource(new FeedsDbEntities(), 100);
            var searcher = new Searcher<Document>(indexsource);

            // Act
            stopwatch.Start();
            var results = searcher.Search("net").ToList();
            stopwatch.Stop();

            var elapsed = stopwatch.ElapsedMilliseconds;
            stopwatch.Reset();

            Debug.WriteLine(elapsed);

            stopwatch.Start();
            results = searcher.Search("net").ToList();
            stopwatch.Stop();

            var elapsed2 = stopwatch.ElapsedMilliseconds;

            Debug.WriteLine(elapsed2);

            // Assert
            Assert.IsTrue(elapsed2 < elapsed);
        }

	void Start() {

		System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();

		sw.Reset();
		sw.Start();

		for (int i = 0; i < 100000; i++) {
			GameObject a = Instantiate(Resources.Load<GameObject>("A"));
			a.AddComponent<TestA>();
		}

		sw.Stop();


		print("1:"+sw.ElapsedMilliseconds);

		sw.Reset();
		sw.Start();

		for (int i = 0; i < 100000; i++) {
			GameObject a = Instantiate(Resources.Load<GameObject>("B"));
		}

		sw.Stop();
		print("2:" + sw.ElapsedMilliseconds);


	}

        public static async Task HowToUseAsyncProperly()
        {
            HttpClient client = new HttpClient();   // add System.Net.Http reference to your project
            
            Stopwatch clock = new Stopwatch();
            clock.Start();

            string microsoft = await client.GetStringAsync("http://www.microsoft.com");
            string msdn = await client.GetStringAsync("http://msdn.microsoft.com");
            string google = await client.GetStringAsync("http://www.google.com");

            clock.Stop();
            System.Console.WriteLine("Took {0:hh\\:mm\\:ss} seconds", clock.Elapsed);

            clock.Reset();
            clock.Start();

            Task microsoftTask =  client.GetStringAsync("http://www.microsoft.com");
            Task msdnTask =  client.GetStringAsync("http://msdn.microsoft.com");
            Task googleTask =  client.GetStringAsync("http://www.google.com");
            await Task.WhenAll(microsoftTask, msdnTask, googleTask);

            clock.Stop();
            System.Console.WriteLine("Took {0:hh\\:mm\\:ss} seconds", clock.Elapsed);
        }

        public override TestResult DoTest(ITestCase testCase, int testCasesNumber, bool singleton)
        {
            var result = new TestResult { Singleton = singleton, TestCasesNumber = testCasesNumber };
            var sw = new Stopwatch();

            var c = new ServiceContainer();
            if (singleton)
            {
                sw.Start();
                c = (ServiceContainer)testCase.SingletonRegister(c);
                sw.Stop();
            }
            else
            {
                sw.Start();
                c = (ServiceContainer)testCase.TransientRegister(c);
                sw.Stop();
            }
            result.RegisterTime = sw.ElapsedMilliseconds;

            sw.Reset();
            result.ResolveTime = DoResolve(sw, testCase, c, testCasesNumber, singleton);

            c.Dispose();

            return result;
        }

        public DemoForm()
        {
            InitializeComponent();

            GraphConfiguration configuration = new GraphConfiguration();
            configuration.AxisXConfiguration.MajorGrid.LineColor = Color.FromArgb(200, 111, 135);
            configuration.Palette.Add(new PaletteItem(){Color = Color.Firebrick, HatchStyle = ChartHatchStyle.BackwardDiagonal});
            configuration.Palette.Add(new PaletteItem() { Color = Color.Black, HatchStyle = ChartHatchStyle.SolidDiamond });
            configuration.GraphSource = new XmlFileGraphSource(){DateTag = "aaa"};
            configuration.SaveToXml("qwe.xml");

            Stopwatch sw = new Stopwatch();
            sw.Start();
            GraphControl gc = graphControl;// new GraphControl();

            gc.SetConfiguration("graphConfig.xml", Size, null);
            sw.Stop();
            #if STOPWATCH
            MessageBox.Show("Time spent for data extraction: " + sw.ElapsedMilliseconds);
            #endif
            sw.Reset();
            sw.Start();
            gc.SaveImage("temp.jpg", ChartImageFormat.Jpeg);
            sw.Stop();
            #if STOPWATCH
            MessageBox.Show("Time spent for data render by Chart control: " + sw.ElapsedMilliseconds);
            #endif
        }

        public void should_be_faster_than_the_fcl_json_deserializer()
        {
            var json = "[" + Enumerable.Range(0, 5).Select(x => "{" +
                    "\"Value0\": [ " + Enumerable.Range(0, 5).Select(y => "{ \"Value0\": \"ssdfsfsfd\", \"Value1\": \"sfdsfsdf\", \"Value2\": \"adasd\", \"Value3\": \"wqerqwe\", \"Value4\": \"qwerqwer\" }").Aggregate((a, i) => a + "," + i) + " ], " +
                    "\"Value1\": [ " + Enumerable.Range(0, 5).Select(y => "{ \"Value0\": \"ssdfsfsfd\", \"Value1\": \"sfdsfsdf\", \"Value2\": \"adasd\", \"Value3\": \"wqerqwe\", \"Value4\": \"qwerqwer\" }").Aggregate((a, i) => a + "," + i) + " ], " +
                    "\"Value2\": [ " + Enumerable.Range(0, 5).Select(y => "{ \"Value0\": \"ssdfsfsfd\", \"Value1\": \"sfdsfsdf\", \"Value2\": \"adasd\", \"Value3\": \"wqerqwe\", \"Value4\": \"qwerqwer\" }").Aggregate((a, i) => a + "," + i) + " ], " +
                    "\"Value3\": [ " + Enumerable.Range(0, 5).Select(y => "{ \"Value0\": \"ssdfsfsfd\", \"Value1\": \"sfdsfsdf\", \"Value2\": \"adasd\", \"Value3\": \"wqerqwe\", \"Value4\": \"qwerqwer\" }").Aggregate((a, i) => a + "," + i) + " ], " +
                    "\"Value4\": [ " + Enumerable.Range(0, 5).Select(y => "{ \"Value0\": \"ssdfsfsfd\", \"Value1\": \"sfdsfsdf\", \"Value2\": \"adasd\", \"Value3\": \"wqerqwe\", \"Value4\": \"qwerqwer\" }").Aggregate((a, i) => a + "," + i) + " ] " +
                "}").Aggregate((a, i) => a + ", " + i) + "]";

            var stopwatch = new Stopwatch();

            stopwatch.Start();
            for (var i = 0; i < 100; i++) Bender.Deserializer.Create().DeserializeJson<List<SpeedTestCollection>>(json);
            stopwatch.Stop();
            var benderSpeed = stopwatch.ElapsedTicks;

            var jsonSerializer = new JavaScriptSerializer();
            stopwatch.Start();
            for (var i = 0; i < 100; i++) jsonSerializer.Deserialize<List<SpeedTestCollection>>(json);
            stopwatch.Stop();
            var javascriptSerializerSpeed = stopwatch.ElapsedTicks;

            Debug.WriteLine("Bender speed (ticks): {0:#,##0}", benderSpeed);
            Debug.WriteLine("JavaScriptSerializer speed (ticks): {0:#,##0}", javascriptSerializerSpeed);
            (benderSpeed < javascriptSerializerSpeed).ShouldBeTrue();
        }

        public void Performance(ICompressor compressor)
        {
            Trace.WriteLine("---------" + compressor.GetType() + "---------");
            byte[] indata = Encoding.UTF8.GetBytes(testData);

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            byte[] result = null;
            foreach (var i in Enumerable.Range(0,100))
            {
                result = compressor.Compress(indata);
            }
            stopwatch.Stop();
            long ticks = stopwatch.ElapsedTicks;
            Trace.WriteLine("Compress: " +  ticks);

            stopwatch.Reset();
            stopwatch.Start();

            byte[] resurrected;
            foreach (var i in Enumerable.Range(0, 100))
            {
                resurrected = compressor.Decompress(result);
            }
            stopwatch.Stop();
            ticks = stopwatch.ElapsedTicks;
            Trace.WriteLine("Decompress: " + ticks);
            Trace.WriteLine("Compression: " + result.Length / (1.0 * indata.Length));
        }

        public void should_be_faster_than_the_fcl_xml_serializer()
        {
            var collection = new List<SpeedTestCollection>();
            collection.AddRange(Enumerable.Range(0, 5).Select(x => new SpeedTestCollection
                {
                    Value0 = Enumerable.Range(0, 5).Select(y => new SpeedTestItem {
                            Value0 = "ssdfsfsfd", Value1 = "sfdsfsdf", Value2 = "adasd", Value3 = "wqerqwe", Value4 = "qwerqwer"}).ToList(),
                    Value1 = Enumerable.Range(0, 5).Select(y => new SpeedTestItem {
                            Value0 = "ssdfsfsfd", Value1 = "sfdsfsdf", Value2 = "adasd", Value3 = "wqerqwe", Value4 = "qwerqwer"}).ToList(),
                    Value2 = Enumerable.Range(0, 5).Select(y => new SpeedTestItem {
                            Value0 = "ssdfsfsfd", Value1 = "sfdsfsdf", Value2 = "adasd", Value3 = "wqerqwe", Value4 = "qwerqwer"}).ToList(),
                    Value3 = Enumerable.Range(0, 5).Select(y => new SpeedTestItem {
                            Value0 = "ssdfsfsfd", Value1 = "sfdsfsdf", Value2 = "adasd", Value3 = "wqerqwe", Value4 = "qwerqwer"}).ToList(),
                    Value4 = Enumerable.Range(0, 5).Select(y => new SpeedTestItem {
                            Value0 = "ssdfsfsfd", Value1 = "sfdsfsdf", Value2 = "adasd", Value3 = "wqerqwe", Value4 = "qwerqwer"}).ToList()
                }));

            var stopwatch = new Stopwatch();

            stopwatch.Start();
            for (var i = 0; i < 100; i++) Bender.Serializer.Create().SerializeXml(collection);
            stopwatch.Stop();
            var benderSpeed = stopwatch.ElapsedTicks;

            var xmlSerializer = new XmlSerializer(typeof(List<SpeedTestCollection>));
            stopwatch.Start();
            for (var i = 0; i < 100; i++) xmlSerializer.Serialize(new MemoryStream(), collection);
            stopwatch.Stop();
            var xmlSerializerSpeed = stopwatch.ElapsedTicks;

            Debug.WriteLine("Bender speed (ticks): {0:#,##0}", benderSpeed);
            Debug.WriteLine("XmlSerializer speed (ticks): {0:#,##0}", xmlSerializerSpeed);
            (benderSpeed < xmlSerializerSpeed).ShouldBeTrue();
        }

        public void Can_bench_specification_extension_method_performance()
        {
            var stopwatch = new Stopwatch();
            const int trials = 1000;

            ISpecification<int> isGreaterThanThree = new PredicateSpecification<int>(v => v > 3);
            ISpecification<int> isLessThanFive = new PredicateSpecification<int>(v => v < 5);
            var isFour = isGreaterThanThree.And(isLessThanFive);

            stopwatch.Start();
            
            for (var i = 0; i < trials; i++)
            {
                isFour.IsSatisfiedBy(2 + 2);
            }
            stopwatch.Stop();
            Trace.WriteLine(stopwatch.Elapsed);

            stopwatch.Start();
            for (var i = 0; i < trials; i++)
            {
                (2 + 2).Satisfies(isFour);
            }
            stopwatch.Stop();
            Trace.WriteLine(stopwatch.Elapsed);
        }

 public double Update()
 {
     var w = new Stopwatch();
     w.Start();
     Initialize();
     //long timeInit = w.ElapsedTicks;
     w.Reset();
     w.Start();
     ImageBuffer = Solve(Xvalues, Yvalues, MaxIterations);
     //long timeSolve = w.ElapsedTicks;
     return w.ElapsedMilliseconds*0.001;
 }

        private static void Generate()
        {
            var fileName = "premake5";

            if (UnityEngine.Application.platform == RuntimePlatform.WindowsEditor) {
                fileName = Path.Combine(RootPath, fileName + ".exe");
            }

            using (var process = new Process {
                StartInfo = new ProcessStartInfo {
                    FileName = fileName,
                    WorkingDirectory = RootPath,
                    Arguments = "--protogen",
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    CreateNoWindow = true
                }
            }) {
                var timer = new Stopwatch();

                DataReceivedEventHandler hander = (sender, e) => {
                    timer.Reset();
                    timer.Start();

                    if (!e.Data.Contains(": error CS001: ")) return;

                    UnityEngine.Debug.LogError(e.Data.Substring(AssetsPath.Length + 1));
                };

                process.OutputDataReceived += hander;
                process.ErrorDataReceived += hander;

                timer.Start();
                process.Start();
                process.BeginOutputReadLine();
                process.BeginErrorReadLine();

                while (!process.WaitForExit(100)) {
                    if (timer.Elapsed.TotalSeconds > 2.5) {
                        UnityEngine.Debug.LogError("Process timed out while generating ProtoBuf classes");
                        return;
                    }
                }

                if (process.ExitCode == 0) {
                    UnityEngine.Debug.Log("Successfully generated ProtoBuf classes");
                } else {
                    UnityEngine.Debug.LogError("An error occurred while generating ProtoBuf classes");
                }
            }
        }

    void LateUpdate()
    {
        //Debug.Log ("Time.time - updateRateRec = " + (Time.time - updateRateRec).ToString());
        if (Time.time - updateRateRec > updateRate)
        {
            Debug.Log("Time.time - updateRateRec = " + (Time.time - updateRateRec).ToString() + "updateRate = " + updateRate.ToString() + "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
            updateRateRec = Time.time;

            RenderMe();

            //currentMaterial.SetTexture("_Cube", cubemap);
            //GetComponent<Renderer>().material = currentMaterial;
        }

        if (Input.GetKeyUp("space"))
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
            stopwatch.Start();//-------------
            RenderMe();
            stopwatch.Stop();
            sb.AppendLine("RenderMe() cost : " + stopwatch.ElapsedMilliseconds);
            stopwatch.Reset();

            stopwatch.Start();//-------------
            //SaveCubemap();
            Texture2D sphereTex = SaveCubeMap2SphericalMap.CreateSphericalMapFromCubeMap(cubemap);
            stopwatch.Stop();
            sb.AppendLine("CreateSphericalMapFromCubeMap() cost : " + stopwatch.ElapsedMilliseconds);
            stopwatch.Reset();

            stopwatch.Start();//-------------
            var bytes = sphereTex.EncodeToJPG();
            File.WriteAllBytes(Application.dataPath + "/cube2sphere.jpg", bytes);
            stopwatch.Stop();
            sb.AppendLine("EncodeToJPG() cost : " + stopwatch.ElapsedMilliseconds);

            System.IO.File.WriteAllText(Application.dataPath + "/CostTime.txt", sb.ToString());
            Debug.Log("save cube map done!!");
            DestroyImmediate(sphereTex);
        }

        bool writeDebugFile = false;
        if (Input.GetKeyUp("d"))
            writeDebugFile = true;
        SaveCubeMap2SphericalMap.RenderDebugSphericalSampleRayInfo(16, 16, writeDebugFile);

        //Debug.Log("Mathf.Sin(Mathf.PI * 0.5f)=" + Mathf.Sin(Mathf.PI * 0.25f).ToString("0.000")  );
        //Debug.Log("Mathf.Cos(Mathf.PI * 0.5f)=" + Mathf.Cos(Mathf.PI * 0.25f).ToString("0.000")  );
    }