C# Stopwatch.Stop方法代码示例

        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;
        }

        private static void CountLinkedList(int max)
        {
            WriteLine("Linked lists");

            var stopWatch = new Stopwatch();

            stopWatch.Start();
            var ll = new LinkedList<int>();
            for (var i = 0; i < max; i++)
            {
                ll.AddLast(i);
            }
            stopWatch.Stop();
            WriteLine("Time to initialise: " + stopWatch.ElapsedMilliseconds);

            stopWatch.Restart();
            WriteLine(ll.Count);
            stopWatch.Stop();
            WriteLine("Time to count with prop: " + stopWatch.ElapsedMilliseconds);

            stopWatch.Restart();
            WriteLine(ll.Count());
            stopWatch.Stop();
            WriteLine("Time to count with extension method: " + stopWatch.ElapsedMilliseconds);

            WriteLine();
        }

        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 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 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();
        }

 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>
        /// DataTable
        /// </summary>
        /// <param name="repository"></param>
        /// <param name="spName"></param>
        /// <param name="sqlParameter"></param>
        /// <param name="dt"></param>
        public static void ExecuteStoredProcedure(this ISqlRepository repository, string spName, SqlParameter[] sqlParameter, DataTable dt)
        {
            using (var conn = repository.Create())
            {
                SqlCommand command = new SqlCommand(spName, conn);
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.Clear();
                command.Parameters.AddRange(sqlParameter);
                try
                {
                    Stopwatch sw = new Stopwatch();
                    sw.Start();

                    conn.Open();

                    sw.Stop();
                    var connOpen = sw.Elapsed.TotalSeconds;
                    sw.Restart();

                    SqlDataAdapter sqlDA = new SqlDataAdapter(command);
                    sqlDA.Fill(dt);

                    sw.Stop();
                    //var execute = sw.Elapsed.TotalSeconds;
                    //Log.SqlServerPerformaceAnalysis(command, connOpen, execute);
                }
                finally
                {
                    conn.Close();
                }
            }
        }

        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);
        }

    // 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);

        }
    }

        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 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 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
        }

    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")  );
    }

		public ActionResult SearchCustomers(HomeViewModel data)
		{
			var client = cloudStorageAccount.CreateCloudTableClient();
			var table = client.GetTableReference(DemoSettings.Storage.CustomerTableName);
			data.MatchedCustomers.Clear();
			var watch = new Stopwatch();

			if (data.UseTable)
			{
				watch.Start();

				foreach (var customer in table.CreateQuery<Customer>().Where(c => data.SearchString == c.Name))
				{
					customer.Value = (int)(customer.Value * 100) / 100.0;
					data.TableCustomers.Add(customer);
				}
				watch.Stop();
				data.TableResponseTime = watch.ElapsedMilliseconds;
			}

			var connection = ConnectionMultiplexer.Connect(new ConfigurationOptions
			{
				EndPoints = { { DemoSettings.CustomerRedisCache.Url, DemoSettings.CustomerRedisCache.Port } },
				Password = DemoSettings.CustomerRedisCache.Password
			});

			var db = connection.GetDatabase();
			watch.Restart();

			var record = db.StringGet("cust:" + data.SearchString.Replace(' ', ':'));
			if (!record.IsNullOrEmpty)
			{
				string[] parts = Encoding.ASCII.GetString(record).Split(':');
				if (parts.Length == 2)
				{
					foreach (var customer in table.CreateQuery<Customer>().Where(c => c.PartitionKey == parts[0] && c.RowKey == parts[1]))
					{
						customer.Value = (int)(customer.Value * 100) / 100.0;
						data.MatchedCustomers.Add(customer);
					}
				}
			}
			watch.Stop();

			data.CachedResponseTime = watch.ElapsedMilliseconds;
			connection.Close(false);

			return View("Index", data);
		}