C# Stopwatch.Restart方法代码示例

        static void Main(string[] args)
        {
            dynamic x = new Speaker();
            x.Clonk();

            return;

            var expression = "import pythonDemo\npythonDemo.factorial(2000)";
            var engine = Python.CreateEngine();

            Stopwatch sw = new Stopwatch();

            int max = 10;

            sw.Start();
            for (int i = 0; i < max; ++i) engine.Execute(expression);
            sw.Stop();
            Console.WriteLine("Python={0}", sw.Elapsed);
            sw.Restart();
            for (int i = 0; i < max; ++i) factDyn(2000);
            sw.Stop();
            Console.WriteLine("Dynamic={0}", sw.Elapsed);
            sw.Restart();
            for (int i = 0; i < max; ++i) fact(2000);
            sw.Stop();
            Console.WriteLine("Typed={0}", sw.Elapsed);

            Console.Beep(1000, 2000);

            //Console.WriteLine(result);
            Console.ReadKey();
        }

        static void Main(string[] args)
        {
            var context = new SoftUniEntities();

            var totalCount = context.Employees.Count();

            var sw = new Stopwatch();
            sw.Start();

            PrintNamesWithNativeQuery();
            Console.WriteLine("\nNative: {0}\n\n", sw.Elapsed);

            sw.Restart();

            PrintNamesWithLinqQuery_LINQtoEntities();

            Console.WriteLine("\n\nLINQtoEntities: {0}\n\n", sw.Elapsed);

            sw.Restart();

            PrintNamesWithLinqQuery_WithExtensionMethods();

            Console.WriteLine("\n\nLINQWithExtensionMethods: {0}", sw.Elapsed);

            sw.Stop();
        }

        public static void BackSequentialCompare(int countOfElementInArray)
        {
            int[] intArray = new int[countOfElementInArray];
            double[] doubleArray = new double[countOfElementInArray];
            string[] stringArray = new string[countOfElementInArray];

            for (int i = countOfElementInArray - 1; i >= 0; i--)
            {
                intArray[i] = i;
                doubleArray[i] = i;
                stringArray[i] = i.ToString();
            }

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Restart();
            QuickSort<int>.Sort(intArray, Comparer<int>.Default);
            stopwatch.Stop();

            Console.WriteLine("Quick sort result for back sequential int is:{0}", stopwatch.ElapsedMilliseconds);

            stopwatch.Restart();
            QuickSort<double>.Sort(doubleArray, Comparer<double>.Default);
            stopwatch.Stop();

            Console.WriteLine("Quick sort result for back sequential double is:{0}", stopwatch.ElapsedMilliseconds);

            stopwatch.Restart();
            QuickSort<string>.Sort(stringArray, Comparer<string>.Default);
            stopwatch.Stop();

            Console.WriteLine("Quick sort result for back sequential string is:{0}", stopwatch.ElapsedMilliseconds);
        }

        private static void TestGetPalindromes(string text)
        {
            var sw = new Stopwatch();
            SimpleImplementation.count = 0;
            sw.Restart();
            var expected = SimpleImplementation.GetPalindromes(text).ToArray();
            sw.Stop();
            var simpleCount = SimpleImplementation.count;
            var simpleTime = sw.Elapsed;

            Implementation1.count = 0;
            sw.Restart();
            var actual = Implementation1.GetPalindromes(text).ToArray();
            sw.Stop();
            var newCount = Implementation1.count;
            var newTime = sw.Elapsed;

            Console.WriteLine("べた実装 {0}, {2}. 新実装 {1}, {3}", simpleCount, newCount, simpleTime, newTime);

            if (!expected.OrderBy(x => x).SequenceEqual(actual.OrderBy(x => x)))
            {
                Console.WriteLine("error GetPalindromes");

                Console.WriteLine(string.Join(", ", expected));
                Console.WriteLine(string.Join(", ", actual));
            }
        }

        static void ExpressionHashTiming() {
            var timer = new Stopwatch();

            Console.WriteLine("Generating dynamically specialized code...");
            timer.Start();
            var specializedExpression = ExpressionHashUtil.Example.Specialize();
            var specializedMethod = specializedExpression.Compile();
            Console.WriteLine("Done after {0:0}ms", timer.Elapsed.TotalMilliseconds);

            // -- uncomment to output the IL to disk, where it can be inspected more easily
            //ExpressionHashUtil.WriteMethodToAssembly(specializedExpression, "Example");
            
            Console.WriteLine("Timing interpretation vs dynamically generated code of example hash...");
            var repeatCount = 10;
            var streamSize = 1 << 24;
            foreach (var _ in Enumerable.Range(0, repeatCount)) {
                timer.Restart();
                var r1 = ExpressionHashUtil.Example.Interpret(new CountingStream(streamSize));
                var t1 = timer.Elapsed;
                Console.Write("Interpreted: {0:0}ms", t1.TotalMilliseconds);
                
                timer.Restart();
                var r2 = specializedMethod(new CountingStream(streamSize));
                var t2 = timer.Elapsed;
                Console.Write(", Specialized: {0:0}ms", t2.TotalMilliseconds);
                Console.WriteLine(r1 == r2 ? "" : ", !!!Didn't match!!!");
            }
        }

        /// <summary>
        /// Checks if there were any changes in document types defined in Umbraco/uSiteBuilder/Both.
        /// Does not check relations between document types (allowed childs and allowable parents)
        /// </summary>
        /// <param name="hasDefaultValues"></param>
        /// <returns></returns>
        public static List<ContentComparison> PreviewDocumentTypeChanges(out bool hasDefaultValues)
        {
            #if DEBUG
            Stopwatch timer = new Stopwatch();
            timer.Start();
            #endif
            // compare the library based definitions to the Umbraco DB
            var definedDocTypes = PreviewDocTypes(typeof(DocumentTypeBase), "");

            #if DEBUG
            timer.Stop();
            StopwatchLogger.AddToLog(string.Format("Total elapsed time for method 'DocumentTypeComparer.PreviewDocumentTypeChanges' - only PreviewDocTypes: {0}ms.", timer.ElapsedMilliseconds));
            timer.Restart();
            #endif

            #if DEBUG
            timer.Start();
            #endif
            hasDefaultValues = _hasDefaultValues;
            // add any umbraco defined doc types that don't exist in the class definitions
            definedDocTypes.AddRange(ContentTypeService.GetAllContentTypes()
                                         .Where(doctype => definedDocTypes.All(dd => dd.Alias != doctype.Alias))
                                         .Select(docType => new ContentComparison { Alias = docType.Alias, DocumentTypeStatus = Status.Deleted, DocumentTypeId = docType.Id }));

            #if DEBUG
            timer.Stop();
            StopwatchLogger.AddToLog(string.Format("Total elapsed time for method 'DocumentTypeComparer.PreviewDocumentTypeChanges' - add any umbraco defined doc types that don't exist in the class definitions: {0}ms.", timer.ElapsedMilliseconds));
            timer.Restart();
            #endif

            return definedDocTypes;
        }

        static void Main(string[] args)
        {
            var context = new AdsEntities();

            context.Database.ExecuteSqlCommand("CHECKPOINT; DBCC DROPCLEANBUFFERS;");

            var nonOptimizedRunningTimes = new List<TimeSpan>();
            var optimizedRunningTimes = new List<TimeSpan>();
            var sw = new Stopwatch();
            
            sw.Start();

            for (int i = 0; i < 10; i++)
            {
                NonOptimizedQuery(context);
                nonOptimizedRunningTimes.Add(sw.Elapsed);
                sw.Restart();
            }

            for (int i = 0; i < 10; i++)
            {
                OptimizedQuery(context);
                optimizedRunningTimes.Add(sw.Elapsed);
                sw.Restart();
            }

            Console.WriteLine("NonOptimized: {0}", nonOptimizedRunningTimes.Average(ts => ts.TotalMilliseconds));
            Console.WriteLine("Optimized: {0}", optimizedRunningTimes.Average(ts => ts.TotalMilliseconds));
        }

        public static void Main()
        {
            Stopwatch timer = new Stopwatch();

            // Task 1
            databaseConnection = new TelerikAcademyEntities();
            using (databaseConnection)
            {
                timer.Restart();
                PrintEmployeesClean();
                Console.WriteLine("\nThe query for all employees WITHOUT include took: {0}.\nCheck screens in the solution folder for queries count!", timer.Elapsed);

                timer.Restart();
                PrintEmployeesIncluded();
                Console.WriteLine("\nThe query for all employees WITH include took: {0}.\nCheck screens in the solution folder for queries count!", timer.Elapsed);
            }

            // Task 2
            databaseConnection = new TelerikAcademyEntities();
            using (databaseConnection)
            {
                timer.Restart();
                GetEmployeesFromSofiaUnoptimized();
                Console.WriteLine("\nTo list operations took: {0} with N queries.", timer.Elapsed);

                timer.Restart();
                GetEmployeesFromSofiaOptimizedOne();
                Console.WriteLine("\nOptimized #1 query took: {0} with 1 querie.", timer.Elapsed);

                timer.Restart();
                GetEmployeesFromSofiaOptimizedTwo();
                Console.WriteLine("\nOptimized #2 query took: {0} with 1 querie.", timer.Elapsed);
            }
        }

 public Task Load()
 {
     Stopwatch sw = new Stopwatch();
     sw.Start();
     StartLoading();
     Console.WriteLine("{1}. Start loading {0} ms.", sw.ElapsedMilliseconds, this.GetType().Name);
     sw.Restart();
     BeforeDataLoading();
     Console.WriteLine("{1}. Before data loading {0} ms.", sw.ElapsedMilliseconds, this.GetType().Name);
     sw.Restart();
     ClearData();
     Console.WriteLine("{1}. Clear data {0} ms.", sw.ElapsedMilliseconds, this.GetType().Name);
     sw.Restart();
     return Task.Factory.StartNew(() =>
         {
             dataSource = LoadDataFromServer();
             //Thread.Sleep(5000);
             Console.WriteLine("{1}. Load from server {0} ms.", sw.ElapsedMilliseconds, this.GetType().Name);
             sw.Restart();
         }).ContinueWith((task) =>
             {
                 Dispatcher.Invoke(new Action(() =>
                     {
                         AfterDataLoaded();
                         Console.WriteLine("{1}. After loading {0} ms.", sw.ElapsedMilliseconds, this.GetType().Name);
                         sw.Restart();
                         StopLoading();
                     }));
             }, TaskContinuationOptions.ExecuteSynchronously);
 }

        public void should_be_within_performace_tolerance()
        {
            var json = File.ReadAllText("model.json");
            var jsonBytes = new MemoryStream(File.ReadAllBytes("model.json"));
            var stopwatch = new Stopwatch();

            var controlBenchmark = Enumerable.Range(1, 1000).Select(x =>
            {
                jsonBytes.Seek(0, SeekOrigin.Begin);
                stopwatch.Restart();
                json.ParseJson();
                stopwatch.Stop();
                return stopwatch.ElapsedTicks;
            }).Skip(5).Average();

            var flexoBenchmark = Enumerable.Range(1, 1000).Select(x =>
            {
                jsonBytes.Seek(0, SeekOrigin.Begin);
                stopwatch.Restart();
                JElement.Load(jsonBytes);
                stopwatch.Stop();
                return stopwatch.ElapsedTicks;
            }).Skip(5).Average();

            Console.Write("Control: {0}, Flexo: {1}", controlBenchmark, flexoBenchmark);

            flexoBenchmark.ShouldBeLessThan(controlBenchmark * 2);
        }

        public void CompareStringReplaceMethods()
        {
            const int times = 1000;

            var watch = new Stopwatch();

            watch.Restart();
            for (var i = 0; i < times; i++)
            {
                var resultsA = StringReplaceMethodA(CONTENT_A);
            }
            watch.Stop();

            Console.WriteLine("Time taken for Method A : " + watch.ElapsedMilliseconds + "ms");

            watch.Restart();
            for (var i = 0; i < times; i++)
            {
                var resultsB = StringReplaceMethodB(CONTENT_A);
            }
            watch.Stop();

            Console.WriteLine("Time taken for Method B : " + watch.ElapsedMilliseconds + "ms");

            watch.Restart();
            for (var i = 0; i < times; i++)
            {
                var resultsB = StringReplaceMethodC(CONTENT_A);
            }
            watch.Stop();

            Console.WriteLine("Time taken for Method C : " + watch.ElapsedMilliseconds + "ms");

            Assert.IsNotNull("hello");
        }

		public static void Run()
		{
			Parse ();

			var pcw = new LegacyParseCacheView (new[]{ srcDir });
			var ctxt = new ResolutionContext (pcw, new ConditionalCompilationFlags(versions,0, true));

			var mod = pcw.LookupModuleName (null, "botan.pubkey.algo.dsa").First();
			var scope = ResolutionTests.N<DMethod> (mod, "DSAVerificationOperation.verify");
			var scopedStmt = ResolutionTests.S (scope, 9);

			ctxt.Push (scope, scopedStmt.Location);

			ITypeDeclaration td = new IdentifierDeclaration ("q"){ Location = scopedStmt.Location };
			AbstractType t;

			var sw = new Stopwatch ();
			Console.WriteLine ("Begin resolving...");
			sw.Restart ();
			t = TypeDeclarationResolver.ResolveSingle(td, ctxt);

			sw.Stop ();

			Console.WriteLine ("Finished resolution. {0} ms.", sw.ElapsedMilliseconds);

			sw.Restart ();
			t = TypeDeclarationResolver.ResolveSingle(td, ctxt);

			sw.Stop ();

			Console.WriteLine ("Finished resolution. {0} ms.", sw.ElapsedMilliseconds);
		}

 static void Main(string[] args)
 {
     Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
     var useCaseTypes =
         typeof(Program).Assembly.GetTypes().Where(t => typeof(UseCase).IsAssignableFrom(t) && t != typeof(UseCase)).ToArray();
     useCaseTypes = useCaseTypes.Concat(useCaseTypes).ToArray();
     foreach (var useCaseType in useCaseTypes.OrderByDescending(t=>t.Name))
     {
         var sw = new Stopwatch();
         GC.Collect(GC.MaxGeneration);
         GC.WaitForPendingFinalizers();
         GC.Collect(GC.MaxGeneration);
         Logger.InstanceCount = 0;
         ErrorHandler.InstanceCount = 0;
         sw.Start();
         var uc = (UseCase)useCaseType.GetConstructor(Type.EmptyTypes).Invoke(new object[0]);
         uc.Run();
         sw.Stop();
         var initTicks = sw.Elapsed.TotalMilliseconds;
         sw.Restart();
         for (int i = 0; i < 100000; i++) uc.AddToCheck(uc.Run());
         sw.Stop();
         var runTicks = sw.Elapsed.TotalMilliseconds;
         uc.Check();
         sw.Restart();
         uc = (UseCase) useCaseType.GetConstructor(Type.EmptyTypes).Invoke(new object[0]);
         uc.Run();
         sw.Stop();
         var init2Ticks = sw.Elapsed.TotalMilliseconds;
         Console.WriteLine("{0,-20} {1,8:N1}ms init:{2,7:N2}ms 2nd init:{3,7:N2}ms ch: {4} {5}", useCaseType.Name, runTicks, initTicks, init2Ticks, Logger.InstanceCount, ErrorHandler.InstanceCount);
     }
 }

        static void Main(string[] args) {
            const int terminoFibonacci = 40;
            int resultado;

            var crono = new Stopwatch();
            crono.Start();
            resultado = FibonacciNoMemorizado.Fibonacci(terminoFibonacci);
            crono.Stop();
            long ticksNoMemorizadoPrimeraLlamada = crono.ElapsedTicks;
            Console.WriteLine("Versión no memorizada, primera llamada: {0:N} ticks. Resultado: {1}.", ticksNoMemorizadoPrimeraLlamada, resultado);

            crono.Restart();
            resultado = FibonacciNoMemorizado.Fibonacci(terminoFibonacci);
            crono.Stop();
            long ticksNoMemorizadoSegundaLlamada = crono.ElapsedTicks;
            Console.WriteLine("Versión no memorizada, segunda llamada: {0:N} ticks. Resultado: {1}.", ticksNoMemorizadoSegundaLlamada, resultado);

            crono.Restart();
            resultado = FibonacciMemorizacion.Fibonacci(terminoFibonacci);
            crono.Stop();
            long ticksMemorizadoPrimeraLlamada = crono.ElapsedTicks;
            Console.WriteLine("Versión memorizada, primera llamada: {0:N} ticks. Resultado: {1}.", ticksMemorizadoPrimeraLlamada, resultado);

            crono.Restart();
            resultado = FibonacciMemorizacion.Fibonacci(terminoFibonacci);
            crono.Stop();
            long ticksMemorizadoSegundaLlamada = crono.ElapsedTicks;
            Console.WriteLine("Versión memorizada, segunda llamada: {0:N} ticks. Resultado: {1}.", ticksMemorizadoSegundaLlamada, resultado);
        }

        static void Main(string[] args)
        {
            var sourceList = new Item[10000];
            for (int i = 0; i < sourceList.Length; i++)
            {
                sourceList[i] = new Item { IntValue = i, StringValue = i.ToString() };
            }
            var mySerializer = new YamlSerializer();
            var myDeserializer = new YamlDeserializer();
            var defaultSerializer = new Serializer();
            var defaultDeserializer = new Deserializer();
            var watch = new Stopwatch();

            while (true)
            {
                var sw = new StringWriter();
                watch.Restart();
                mySerializer.Serialize(sw, sourceList);
                var stime = watch.ElapsedMilliseconds;
                watch.Restart();
                var list = myDeserializer.Deserialize<List<Item>>(new StringReader(sw.ToString()));
                var dtime = watch.ElapsedMilliseconds;
                Console.WriteLine("My - Serialize time: {0}ms, Deserialize time: {1}ms", stime, dtime);

                sw = new StringWriter();
                watch.Restart();
                defaultSerializer.Serialize(sw, sourceList);
                stime = watch.ElapsedMilliseconds;
                watch.Restart();
                list = defaultDeserializer.Deserialize<List<Item>>(new StringReader(sw.ToString()));
                dtime = watch.ElapsedMilliseconds;
                Console.WriteLine("Default - Serialize time: {0}ms, Deserialize time: {1}ms", stime, dtime);
            }
        }