C# PerformanceCounter.Increment方法代码示例

        static void Main(string[] args)
        {
            if (CreatePerformanecCounters())
            {
                Console.WriteLine("Created performance counters");
                Console.WriteLine("Please restart the application");
                Console.ReadKey();

                return;
            }

            var totalOperationsCounter = new PerformanceCounter(
                "MyCategory",
                "# operations executed",
                "",
                false);
            var operationsPerSecondCounter = new PerformanceCounter(
                "MyCategory",
                "# operations sec",
                "",
                false);

            totalOperationsCounter.Increment();
            operationsPerSecondCounter.Increment();
        }

 protected void IncreaseCounter(object sender, EventArgs e)
 {
     using (var counter = new PerformanceCounter("Test Category", "Test Increment", readOnly: false))
     {
         counter.Increment();
     }
 }

 private void UpdateCounterConditional(PerformanceCounter c, CounterInvokeDirection expectedDirection)
 {
     if (c != null && (expectedDirection & _direction) == expectedDirection)
     {
         lock (c)
         {
             //reset name
             string ins = c.InstanceName;
             c.Increment();
             //also update overall insance!
             c.InstanceName = OverallInstance;
             c.Increment();
             c.InstanceName = ins;
         }
     }
 }

        private void btnCount_Click(object sender, RoutedEventArgs e)
        {
            if(!PerformanceCounterCategory.Exists("PerfApp"))
            {
                PerformanceCounterCategory.Create("PerfApp", "Conters for app", PerformanceCounterCategoryType.SingleInstance, "Clicks", "Times the user has clicked the button");
            }

            PerformanceCounter pc = new PerformanceCounter("PerfApp", "Clicks", false);
            pc.Increment();
            txbCounter.Content = pc.NextValue().ToString();
        }

		public void WriteCounters ()
		{
			using (var hitCounter = new PerformanceCounter ("Category", "Hits")) {
				using (var rateCounter = new PerformanceCounter ("Category", "Rate")) {
					for (var x = 0; x < 5; x++) {
						hitCounter.Increment ();
						rateCounter.IncrementBy (x + 10);
					}
				}
			}
		}

 public static void Increment()
 {
     if (_exists)
     {
         using (var counter = new PerformanceCounter(_category, _counter, false)
                                  {
                                      MachineName = "."
                                  })
         {
             counter.Increment();
         }
     }
 }

        static void IncrementCounter()
        {
            // get an instance of our perf counter
            PerformanceCounter counter = new PerformanceCounter();
            counter.CategoryName = "MyCategory";
            counter.CounterName = "AddCounter";
            counter.ReadOnly = false;

            // increment and close the perf counter
            counter.Increment();

            counter.Close();
        }

        public override void Run()
        {
            while (true)
            {
                using (var counter = new PerformanceCounter("category", "counter1", false))
                {
                    counter.Increment();
                }

                EventLog.WriteEntry("source", "running");

                Thread.Sleep(1000);
            }
        }

		public SaveMetrics()
		{
			if (!PerformanceCounterCategory.Exists(PerformanceCategoryName))
			{
				var counters = new CounterCreationDataCollection
				{
					new CounterCreationData(
						//
						"Save - Count", "Number of world saves.", PerformanceCounterType.NumberOfItems32),
					new CounterCreationData(
						//
						"Save - Items/sec", "Number of items saved per second.", PerformanceCounterType.RateOfCountsPerSecond32),
					new CounterCreationData(
						//
						"Save - Mobiles/sec", "Number of mobiles saved per second.", PerformanceCounterType.RateOfCountsPerSecond32),
					new CounterCreationData(
						//
						"Save - Customs/sec", "Number of cores saved per second.", PerformanceCounterType.RateOfCountsPerSecond32),
					new CounterCreationData(
						//
						"Save - Serialized bytes/sec",
						"Amount of world-save bytes serialized per second.",
						PerformanceCounterType.RateOfCountsPerSecond32),
					new CounterCreationData(
						//
						"Save - Written bytes/sec",
						"Amount of world-save bytes written to disk per second.",
						PerformanceCounterType.RateOfCountsPerSecond32)
				};

#if !MONO
				PerformanceCounterCategory.Create(
					PerformanceCategoryName, PerformanceCategoryDesc, PerformanceCounterCategoryType.SingleInstance, counters);
#endif
			}

			numberOfWorldSaves = new PerformanceCounter(PerformanceCategoryName, "Save - Count", false);

			itemsPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Items/sec", false);
			mobilesPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Mobiles/sec", false);
			dataPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Customs/sec", false);

			serializedBytesPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Serialized bytes/sec", false);
			writtenBytesPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Written bytes/sec", false);

			// increment number of world saves
			numberOfWorldSaves.Increment();
		}

        static void Main(string[] args)
        {
            CounterCreationDataCollection counters = new CounterCreationDataCollection();
            counters.Add(new CounterCreationData("Sales", "Number of total sales", PerformanceCounterType.NumberOfItems64));
            counters.Add(new CounterCreationData("Active Users", "Number of active users", PerformanceCounterType.NumberOfItems64));
            counters.Add(new CounterCreationData("Sales value", "Total value of all sales", PerformanceCounterType.NumberOfItems64));
            PerformanceCounterCategory.Create("MyApp Counters", "Counters describing the performance of MyApp",
                PerformanceCounterCategoryType.SingleInstance, counters);

            PerformanceCounter pc = new PerformanceCounter("MyApp Counters", "Sales", false);

            pc.RawValue = 7;
            pc.Decrement();
            pc.Increment();
            pc.IncrementBy(3);
        }

        //
        // http://msdn.microsoft.com/en-us/library/5e3s61wf(v=vs.90).aspx
        //
        private static void Sample_CreatingPerformanceCounter()
        {
            var performanceMonitor = new PerformanceMonitor();
            performanceMonitor.AddCounter("CustomInstance");
            using (var counter = new PerformanceCounter(PerformanceMonitor.pcCategory, "CustomInstance", readOnly: false))
            {
                string command;
                do
                {
                    counter.Increment();
                    Console.Write("enter command: ");
                    command = Console.ReadLine();
                } while (command != "");
            }

            Console.WriteLine("press any key...");
            Console.ReadKey();
        }

        private static void IncrementUnhandledExceptions()
        {
            try
            {
                string performanceCounterCategory = Assembly.GetEntryAssembly().GetName().Name;
                string performanceCounterName = "UnhandledExceptions";

                PerformanceCounter counter = new PerformanceCounter();
                counter.CategoryName = performanceCounterCategory;
                counter.CounterName = performanceCounterName;
                counter.ReadOnly = false;
                counter.Increment();
                counter.Close();
            }
            catch (Exception)
            {
                return;
            }
        }

        public static void Main(string[] args)
        {
            if (CreatePerformanceCounters())
            {
                Console.WriteLine("Created performance counters");
                Console.WriteLine("Please restart application");
                Console.ReadKey();
                return;
            }

            var totalOperationsCounter = new PerformanceCounter("MyCategory", "# operations executed", "", false);
            var operationsPerSecondCounter = new PerformanceCounter("MyCategory", "# operations / sec", "", false);

            totalOperationsCounter.Increment();
            operationsPerSecondCounter.Increment();

            Console.WriteLine("Total number of operations: {0}", totalOperationsCounter.RawValue);
            Console.WriteLine("Operations / sec: {0}", operationsPerSecondCounter.RawValue);

            Console.ReadLine();
        }

        public void StopCounter()
        {
            this.stopWatch.Stop();

            using (
                var averageExecutionTimeCounter = new PerformanceCounter(Category, 
                                                                         AverageExecutionTimeCounterName, 
                                                                         this.instanceName, 
                                                                         false))
            {
                using (
                    var averageExecutionTimeBaseCounter = new PerformanceCounter(Category, 
                                                                                 AverageExecutionTimeBaseCounterName, 
                                                                                 this.instanceName, 
                                                                                 false))
                {
                    averageExecutionTimeCounter.IncrementBy(this.stopWatch.ElapsedTicks);
                    averageExecutionTimeBaseCounter.Increment();
                }
            }
        }

 //public static void CountBeginAverageTimerCounter
 //                        (
 //                            this PerformanceCounter performanceCounter
 //                            , PerformanceCounter basePerformanceCounter
 //                            , Stopwatch stopwatch
 //                        )
 //{
 //        //stopwatch.Reset();
 //        //stopwatch.Start();
 //        stopwatch.Restart();
 //}
 public static void CountEndAverageTimerCounter
                 (
                     this PerformanceCounter performanceCounter
                     , PerformanceCounter basePerformanceCounter
                     , Stopwatch stopwatch
                     , Func<PerformanceCounterProcessingFlagsType, PerformanceCounter, long> onBasePerformanceCounterChangeValueProcessFunc = null
                 )
 {
     if
         (
             stopwatch != null
         )
     {
         if (stopwatch.IsRunning)
         {
             stopwatch.Stop();
         }
         performanceCounter
                 .IncrementBy(stopwatch.ElapsedTicks);
         //stopwatch = null;
         var increment = 1L;
         if (onBasePerformanceCounterChangeValueProcessFunc != null)
         {
             increment = onBasePerformanceCounterChangeValueProcessFunc
                                 (
                                     PerformanceCounterProcessingFlagsType.TimeBasedOnEnd
                                     , basePerformanceCounter
                                 );
         }
         if (increment == 1)
         {
             basePerformanceCounter.Increment();
         }
         else
         {
             basePerformanceCounter.IncrementBy(increment);
         }
         
     }
 }