C# PerformanceCounterType类代码示例

        public static PerformanceCounter CreateCounter(string name, string description, PerformanceCounterType type)
        {
            if (_countersAllowed == false)
            {
                return null;
            }

            string categoryName = Application.ProductName + "." + name;
            if (PerformanceCounterCategory.Exists(categoryName) == false)
            {
                CounterCreationDataCollection counters = new CounterCreationDataCollection();

                CounterCreationData counterData = new CounterCreationData();
                counterData.CounterName = name;
                counterData.CounterHelp = description;
                counterData.CounterType = type;

                counters.Add(counterData);

                PerformanceCounterCategory category = PerformanceCounterCategory.Create(categoryName, "Category for the counters of " + Application.ProductName,
                    PerformanceCounterCategoryType.SingleInstance, counters);
            }

            PerformanceCounter counter = new PerformanceCounter(categoryName, name, string.Empty, false);
            return counter;
        }

 internal PerformanceCounterSample(string path,
                        string instanceName,
                        double cookedValue,
                        UInt64 rawValue,
                        UInt64 secondValue,
                        uint multiCount,
                        PerformanceCounterType counterType,
                        UInt32 defaultScale,
                        UInt64 timeBase,
                        DateTime timeStamp,
                        UInt64 timeStamp100nSec,
                        UInt32 status)
 {
     _path = path;
     _instanceName = instanceName;
     _cookedValue = cookedValue;
     _rawValue = rawValue;
     _secondValue = secondValue;
     _multiCount = multiCount;
     _counterType = counterType;
     _defaultScale = defaultScale;
     _timeBase = timeBase;
     _timeStamp = timeStamp;
     _timeStamp100nSec = timeStamp100nSec;
     _status = status;
 }

 internal PerformanceCounterDefinition(string categoryName, string counterName, string counterHelp, PerformanceCounterType counterType)
 {
     _categoryName = categoryName;
     _counterName = counterName;
     _counterHelp = counterHelp;
     _counterType = counterType;
 }

 public IICPerformanceCounter CreateCounter(string counterName, PerformanceCounterType counterType)
 {
     IICPerformanceCounter counter = new IICPerformanceCounter();
     counter._rawAttr = new IICPerformanceCounterAttribute(counterName, counterType);
     _counters.Add(counter);
     return counter;
 }

	public CounterCreationData(String counterName, String counterHelp,
							   PerformanceCounterType counterType)
			{
				this.counterName = counterName;
				this.counterHelp = counterHelp;
				this.counterType = counterType;
			}

 public CounterCreationDataInfo(string counterName, string instanceName, PerformanceCounterType counterType, string counterHelp)
 {
     this.counterName = counterName;
     this.instanceName = instanceName;
     this.counterHelp = counterHelp;
     this.counterType = counterType;
 }

        public async Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress<Tuple<PerformanceCounterType, PerfCounterModel>> progress)
        {
            await Task.Run(async () =>
            {
                var random = new Random();
                int prevPoint = 0;

                while (true)
                {
                    await Task.Yield();

                    int point = prevPoint > 0 ? prevPoint : startPoint;

                    // Update the point price by a random factor of the range percent
                    int number = (point + (int)(random.NextDouble() * random.Next(0, 30))) - random.Next(0, 50);

                    if (number < minPoint)
                    {
                        number = random.Next(0, 10);
                    }
                    else if (number > maxPoint)
                    {
                        number = 100;
                    }

                    progress.Report(new Tuple<PerformanceCounterType, PerfCounterModel>(performanceCounterType, new PerfCounterModel { Timestamp = DateTime.Now, Value = number }));

                    await Task.Delay(250);

                    prevPoint = number;
                }
            }).ConfigureAwait(false);
        }

 public PerfCounterCreationData(PerformanceCounterName name, PerformanceCounterType type, string displayName, string helpText)
 {
     counterName = name;
     counterType = type;
     counterDisplayName = displayName;
     counterHelpText = helpText;
 }

 public CounterDescriptor(string name, string help, PerformanceCounterType type)
     : this()
 {
     Name = name;
     Help = help;
     Type = type;
 }

 internal PerformanceCounterData(string name, string description, PerformanceCounterType counterType, PerformanceCounterActionMapping[] mappings)
 {
     this.Name = name;
     this.Description = description;
     this.CounterType = counterType;
     this.Mappings = mappings;
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="name">Name of the counter</param>
 /// <param name="info">Information about the counter</param>
 /// <param name="counterType">Type of counter</param>
 /// <param name="baseAutoIncreased">if true, each time the performance counter increased/decreased its base will be increased/decrease on 1 point. Otherwise all that base management will need to be handed on client code</param>
 /// <seealso cref="PerformanceCounterType"/>
 public CounterAttribute(string name, string info, PerformanceCounterType counterType, bool baseAutoIncreased)
     : base()
 {
     this.name = name;
     this.info = info;
     this.counterType = counterType;
     this.baseAutoIncreased = baseAutoIncreased;
 }

		public CounterCreationData (string counterName, 
			string counterHelp, 
			PerformanceCounterType counterType)
		{
			CounterName = counterName;
			CounterHelp = counterHelp;
			CounterType = counterType;
		}

        protected PerformanceCounterDefinition AddDefinition(string counterName, string counterHelp, PerformanceCounterType counterType)
        {
            var definition = new PerformanceCounterDefinition(_categoryName, counterName, counterHelp, counterType);

            _counterDefinitions.Add(definition.GetCreationData());

            return definition;
        }

 public FluentCategoryConfigurator AddCounter(
     string name, 
     string help = "", 
     PerformanceCounterType type = PerformanceCounterType.NumberOfItems32)
 {
     _counters.Add(new CounterCreationData(name, help, type));
     return this;
 }

 // Methods
 public STPPerformanceCounter(
     string counterName, 
     string counterHelp, 
     PerformanceCounterType pcType)
 {
     this._counterName = counterName;
     this._counterHelp = counterHelp;
     this._pcType = pcType;
 }