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

 public static PerformanceCounterData CreatePerformanceCounterData(string category, string format, string name, string help, PerformanceCounterType type)
 {
     return new PerformanceCounterData()
     {
         Category = category,
         Name = string.Format(format, name),
         Help = help,
         Type = type,
     };
 }

 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public CounterSample(long rawValue, long baseValue, long counterFrequency, long systemFrequency, long timeStamp, long timeStamp100nSec, PerformanceCounterType counterType, long counterTimeStamp) {
     this.rawValue = rawValue;
     this.baseValue = baseValue;
     this.timeStamp = timeStamp;
     this.counterFrequency = counterFrequency;
     this.counterType = counterType;
     this.timeStamp100nSec = timeStamp100nSec;
     this.systemFrequency = systemFrequency;
     this.counterTimeStamp = counterTimeStamp;
 }         

 public CounterSample(long rawValue,
     long baseValue,
     long counterFrequency,
     long systemFrequency,
     long timeStamp,
     long timeStamp100nSec,
     PerformanceCounterType counterType)
     : this(rawValue, baseValue, counterFrequency,
         systemFrequency, timeStamp, timeStamp100nSec,
         counterType, 0) {
 }

	    protected PerformanceCounterAttribute(
			string categoryName, string counterName, PerformanceCounterType counterType, PerformanceCounterType? baseCounterType)
	    {
		    this.CategoryName = categoryName;
		    this.CounterName = counterName;
		    this.BaseCounterName = counterName + "Base";
		    this.CounterType = counterType;
		    this.BaseCounterType = baseCounterType;
			this.CategoryType=PerformanceCounterCategoryType.MultiInstance;
		    this.sharedDataRef = sharedData;
	    }

		/// <summary>
		/// Converts a PerformanceCounterType to a string.
		/// </summary>
		/// <param name="Type">The type.</param>
		public static string PerformanceCounterTypeToString(PerformanceCounterType Type)
		{
			switch (Type)
			{
				case PerformanceCounterType.MemoryBytes:
					return "bytes";
				case PerformanceCounterType.TimeMilliseconds:
					return "ms";
				default:
					throw new InvalidOperationException("PerformanceCounterType has invalid value " + Type.ToString());
			}
		}