/// <summary>
/// Конструктор CounterPropertyInfo
/// </summary>
/// <param name="containerType">Тип контейнера</param>
/// <param name="counterProp">Свойство</param>
/// <param name="counterAttrib">Атрибут</param>
/// <param name="counterType">Тип счётчика</param>
/// <param name="counterSetter">Делегат установки значения счётчика</param>
/// <param name="couterGetter">Делегат для получения счётчика</param>
public CounterPropertyInfo(Type containerType, PropertyInfo counterProp, CounterAttribute counterAttrib, CounterTypes counterType, GenericSetter counterSetter, GenericGetter couterGetter)
{
if (containerType == null)
{
throw new ArgumentNullException("containerType");
}
if (counterProp == null)
{
throw new ArgumentNullException("counterProp");
}
if (counterAttrib == null)
{
throw new ArgumentNullException("counterAttrib");
}
if (counterSetter == null)
{
throw new ArgumentNullException("counterSetter");
}
if (couterGetter == null)
{
throw new ArgumentNullException("couterGetter");
}
CounterContainerType = containerType;
Property = counterProp;
Attribute = counterAttrib;
CounterType = counterType;
_setter = counterSetter;
_getter = couterGetter;
}
public Counter(CounterTypes CT, PerformanceCounter PC)
{
ShortAverage = 0;
LongAverage = 0;
CounterType = CT;
PerfCounter = PC;
}
/// <summary>
/// Создать дескриптор счётчика
/// </summary>
/// <param name="type">Тип счётчика</param>
/// <param name="counterName">Имя счётчика</param>
/// <param name="counterDescription">Описание счётчика</param>
/// <param name="info">Информацию по функционированию</param>
/// <returns>Созданный дескриптор</returns>
public static WinCounterDescriptor CreateCounterDescriptor(CounterTypes type, string counterName, string counterDescription, WinCountersWorkingInfo info)
{
switch (type)
{
case CounterTypes.NumberOfItems:
return(WinNumberOfItemsCounter.CreateDescriptor(counterName, counterDescription, info));
case CounterTypes.Delta:
return(WinDeltaCounter.CreateDescriptor(counterName, counterDescription, info));
case CounterTypes.AverageTime:
return(WinAverageTimeCounter.CreateDescriptor(counterName, counterDescription, info));
case CounterTypes.AverageCount:
return(WinAverageCountCounter.CreateDescriptor(counterName, counterDescription, info));
case CounterTypes.OperationsPerSecond:
return(WinOperationsPerSecondCounter.CreateDescriptor(counterName, counterDescription, info));
case CounterTypes.ElapsedTime:
return(WinElapsedTimeCounter.CreateDescriptor(counterName, counterDescription, info));
case CounterTypes.MomentTime:
return(WinMomentTimeCounter.CreateDescriptor(counterName, counterDescription, info));
default:
throw new InvalidOperationException("Unknown CounterTypes value: " + type.ToString());
}
}
/// <summary>
/// Получение счетчика определенного типа. Всегда создаёт новый.
/// </summary>
/// <param name="counterName">Имя счетчика</param>
/// <param name="expectedCounterType">Тип счётчика</param>
/// <returns>Счётчик</returns>
public override Counter GetCounter(string counterName, CounterTypes expectedCounterType)
{
if (counterName == null)
{
throw new ArgumentNullException("counterName");
}
switch (expectedCounterType)
{
case CounterTypes.NumberOfItems:
return(new NullNumberOfItemsCounter(counterName, counterName));
case CounterTypes.Delta:
return(new NullDeltaCounter(counterName, counterName));
case CounterTypes.AverageTime:
return(new NullAverageTimeCounter(counterName, counterName));
case CounterTypes.AverageCount:
return(new NullAverageCountCounter(counterName, counterName));
case CounterTypes.OperationsPerSecond:
return(new NullOperationPerSecondCounter(counterName, counterName));
case CounterTypes.ElapsedTime:
return(new NullElapsedTimeCounter(counterName, counterName));
case CounterTypes.MomentTime:
return(new NullMomentTimeCounter(counterName, counterName));
default:
throw new InvalidOperationException("Unknown CounterTypes value: " + expectedCounterType.ToString());
}
}
/// <summary>
/// Создать счётчик определённого типа
/// </summary>
/// <param name="type">Тип счётчика</param>
/// <param name="counterName">Имя счётчика</param>
/// <param name="counterDescription">Описание счётчика</param>
/// <returns>Счётчик</returns>
public override Counter CreateCounter(CounterTypes type, string counterName, string counterDescription)
{
if (counterName == null)
{
throw new ArgumentNullException("counterName");
}
if (counterDescription == null)
{
throw new ArgumentNullException("counterDescription");
}
if (_counters.ContainsKey(counterName))
{
throw new DuplicateCounterNameException("Counter with the same name is already existed. Name: " + counterName);
}
Counter res = null;
switch (type)
{
case CounterTypes.NumberOfItems:
res = new InternalNumberOfItemsCounter(counterName, counterDescription);
break;
case CounterTypes.Delta:
res = new InternalDeltaCounter(counterName, counterDescription);
break;
case CounterTypes.AverageTime:
res = new InternalAverageTimeCounter(counterName, counterDescription);
break;
case CounterTypes.AverageCount:
res = new InternalAverageCountCounter(counterName, counterDescription);
break;
case CounterTypes.OperationsPerSecond:
res = new InternalOperationsPerSecondCounter(counterName, counterDescription);
break;
case CounterTypes.ElapsedTime:
res = new InternalElapsedTimeCounter(counterName, counterDescription);
break;
case CounterTypes.MomentTime:
res = new InternalMomentTimeCounter(counterName, counterDescription);
break;
default:
throw new InvalidOperationException("Unknown CounterTypes value: " + type.ToString());
}
if (!_counters.TryAdd(counterName, res))
{
throw new DuplicateCounterNameException("Counter with the same name is already existed. Name: " + counterName);
}
_isCountersChanged = true;
return(res);
}
/// <summary>
/// Создать счётчик определённого типа
/// </summary>
/// <param name="type">Тип счётчика</param>
/// <param name="counterName">Имя счётчика</param>
/// <param name="counterDescription">Описание счётчика</param>
/// <returns>Счётчик</returns>
public override Counter CreateCounter(CounterTypes type, string counterName, string counterDescription)
{
if (counterName == null)
{
throw new ArgumentNullException("counterName");
}
if (counterDescription == null)
{
throw new ArgumentNullException("counterDescription");
}
if (State != WinCategoryState.Created)
{
throw new InvalidOperationException("Can't create counter inside initialized category. Category: " + this.ToString());
}
if (_counters.ContainsKey(counterName))
{
throw new PerformanceCounterCreationException("Counter with the same name is already existed. Name: " + counterName,
new DuplicateCounterNameException("Counter with the same name is already existed. Name: " + counterName));
}
Counter res = CounterHelper.CreateCounter(type, counterName, counterDescription, Info);
if (!_counters.TryAdd(counterName, res))
{
throw new PerformanceCounterCreationException("Counter with the same name is already existed. Name: " + counterName,
new DuplicateCounterNameException("Counter with the same name is already existed. Name: " + counterName));
}
return(res);
}
/// <summary>
/// Создать счётчик определённого типа
/// </summary>
/// <param name="type">Тип счётчика</param>
/// <param name="counterName">Имя счётчика</param>
/// <param name="counterDescription">Описание счётчика</param>
/// <returns>Счётчик</returns>
public override Counter CreateCounter(CounterTypes type, string counterName, string counterDescription)
{
if (counterName == null)
{
throw new ArgumentNullException("counterName");
}
if (counterDescription == null)
{
throw new ArgumentNullException("counterDescription");
}
if (_counters.ContainsKey(counterName))
{
throw new DuplicateCounterNameException("Counter with the same name is already existed. Name: " + counterName);
}
Counter res = null;
switch (type)
{
case CounterTypes.NumberOfItems:
res = new CompositeNumberOfItemsCounter(counterName, counterDescription, _wrappedCategories.Select(wc => wc.CreateNumberOfItemsCounter(counterName, counterDescription)));
break;
case CounterTypes.Delta:
res = new CompositeDeltaCounter(counterName, counterDescription, _wrappedCategories.Select(wc => wc.CreateDeltaCounter(counterName, counterDescription)));
break;
case CounterTypes.AverageTime:
res = new CompositeAverageTimeCounter(counterName, counterDescription, _wrappedCategories.Select(wc => wc.CreateAverageTimeCounter(counterName, counterDescription)));
break;
case CounterTypes.AverageCount:
res = new CompositeAverageCountCounter(counterName, counterDescription, _wrappedCategories.Select(wc => wc.CreateAverageCountCounter(counterName, counterDescription)));
break;
case CounterTypes.OperationsPerSecond:
res = new CompositeOperationsPerSecondCounter(counterName, counterDescription, _wrappedCategories.Select(wc => wc.CreateOperationsPerSecondCounter(counterName, counterDescription)));
break;
case CounterTypes.ElapsedTime:
res = new CompositeElapsedTimeCounter(counterName, counterDescription, _wrappedCategories.Select(wc => wc.CreateElapsedTimeCounter(counterName, counterDescription)));
break;
case CounterTypes.MomentTime:
res = new CompositeMomentTimeCounter(counterName, counterDescription, _wrappedCategories.Select(wc => wc.CreateMomentTimeCounter(counterName, counterDescription)));
break;
default:
throw new InvalidOperationException("Unknown CounterTypes value: " + type.ToString());
}
if (!_counters.TryAdd(counterName, res))
{
throw new DuplicateCounterNameException("Counter with the same name is already existed. Name: " + counterName);
}
return(res);
}
/// <summary>
/// Получить описатель свойства счётчика
/// </summary>
/// <param name="type">Тип обёртки</param>
/// <param name="property">Свойство</param>
/// <returns>Описатель или null, если не помечен атрибутом</returns>
public static CounterPropertyInfo GetCounterPropertyInfo(Type type, PropertyInfo property)
{
if (type == null)
{
throw new ArgumentNullException("type", "Тип класса категориги не божет быть null");
}
if (property == null)
{
throw new ArgumentNullException("property", "Свойство не может быть null");
}
var attrArr = property.GetCustomAttributes(typeof(CounterAttribute), false);
if (attrArr == null || attrArr.Length == 0)
{
return(null);
}
var attr = attrArr[0] as CounterAttribute;
if (attr == null)
{
return(null);
}
CounterTypes counterType = CounterTypes.NumberOfItems;
try
{
counterType = CounterTypeConverter.Convert(property.PropertyType);
}
catch (UnknownCounterTypeException ex)
{
throw new InvalidCounterDefinitionException(string.Format("Unknown counter type. WrapperType: {0}, Property: {1}", type.Name, property.Name), ex);
}
var setter = CreateSetMethod(property);
if (setter == null)
{
throw new InvalidCounterDefinitionException(
string.Format("Counter property in wrapper should have Set method. WrapperType: {0}, Property: {1}", type.Name, property.Name));
}
var getter = CreateGetMethod(property);
if (getter == null)
{
throw new InvalidCounterDefinitionException(
string.Format("Counter property in wrapper should have Get method. WrapperType: {0}, Property: {1}", type.Name, property.Name));
}
return(new CounterPropertyInfo(type, property, attr, counterType, setter, getter));
}
/// <summary>
/// Конструктор CounterValueData
/// </summary>
/// <param name="name">Имя счётчика</param>
/// <param name="type">Тип счётчика</param>
/// <param name="rawValue">Значение счётчика</param>
public CounterValueData(string name, CounterTypes type, double rawValue)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
Name = name;
Type = type;
RawValue = rawValue;
}
public ICounter GetCounter(IBlockCipherEngine engine, CounterTypes counterType, BitString initialIv)
{
switch (counterType)
{
case CounterTypes.Additive:
return(new AdditiveCounter(engine, initialIv));
case CounterTypes.Subtractive:
return(new SubtractiveCounter(engine, initialIv));
default:
throw new ArgumentException(nameof(counterType));
}
}
/// <summary>
/// Конструктор InternalCounterDescriptor
/// </summary>
/// <param name="name">Имя счётчика</param>
/// <param name="description">Описание счётчика</param>
/// <param name="type">Тип счётчика</param>
protected InternalCounterDescriptor(string name, string description, CounterTypes type)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (description == null)
{
throw new ArgumentNullException("description");
}
Name = name;
Description = description;
Type = type;
}
/// <summary>
/// Конструктор CounterDescriptorAggregatedInfo
/// </summary>
/// <param name="name">Имя счётчика</param>
/// <param name="description">Описание счётчика</param>
/// <param name="type">Тип счётчика</param>
public CounterDescriptorAggregatedInfo(string name, string description, CounterTypes type)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (description == null)
{
throw new ArgumentNullException("description");
}
Name = name;
Description = description;
Type = type;
}
/// <summary>
/// Получение счетчика определенного типа
/// </summary>
/// <param name="counterName">Имя счетчика</param>
/// <param name="expectedCounterType">Тип счётчика</param>
/// <returns>Счётчик</returns>
public override Counter GetCounter(string counterName, CounterTypes expectedCounterType)
{
Counter res = null;
if (!_counters.TryGetValue(counterName, out res))
{
throw new CounterNotExistException(string.Format("Counter ({0}) is not found in category {1}", counterName, this.Name));
}
if (res.Type != expectedCounterType)
{
throw new InvalidCounterTypeException(
string.Format("Counter types are not equal. Expected: {0}, Returned: {1}", expectedCounterType, res.Type));
}
return(res);
}
/// <summary>
/// Совместимы ли представления счётчиков в Windows
/// </summary>
/// <param name="a">Тип первого счётчика</param>
/// <param name="b">Тип второго счётчика</param>
/// <returns>Совместимы ли</returns>
public static bool IsWinCompatible(CounterTypes a, CounterTypes b)
{
if (a == b)
{
return(true);
}
switch (a)
{
case CounterTypes.NumberOfItems:
return(b == CounterTypes.NumberOfItems || b == CounterTypes.MomentTime);
case CounterTypes.MomentTime:
return(b == CounterTypes.MomentTime || b == CounterTypes.NumberOfItems);
}
return(false);
}
public void ReadResetCounters(CounterTypes eType)
{
//Datos
byte[] Datos = new byte[] { };
//Command
byte Command = 0;
if (eType == CounterTypes.GLOBAL_COUNTER)
{
Command = (byte)EnumCommandFrame_02_SF.M_R_RESETCOUNTERS;
}
else
{
Command = (byte)EnumCommandFrame_02_SF.M_R_RESETCOUNTERSP;
}
SendMessage(Datos, Command);
}
/// <summary>
/// Конструктор WinCounterDescriptor
/// </summary>
/// <param name="name">Имя счётчика</param>
/// <param name="description">Описание счётчика</param>
/// <param name="type">Тип счётчика</param>
/// <param name="info">Информация о функционировании</param>
protected WinCounterDescriptor(string name, string description, CounterTypes type, WinCountersWorkingInfo info)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (description == null)
{
throw new ArgumentNullException("description");
}
if (info == null)
{
throw new ArgumentNullException("info");
}
Name = name;
Description = description;
Type = type;
Info = info;
}
/// <summary>
/// Создать счётчик определённого типа, если он уже есть в Windows
/// </summary>
/// <param name="type">Тип счётчика</param>
/// <param name="counterName">Имя счётчика</param>
/// <param name="counterDescription">Описание счётчика</param>
/// <returns>Счётчик</returns>
public override Counter CreateCounter(CounterTypes type, string counterName, string counterDescription)
{
if (counterName == null)
{
throw new ArgumentNullException("counterName");
}
if (counterDescription == null)
{
throw new ArgumentNullException("counterDescription");
}
if (State == WinCategoryState.Disposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
Counter res = null;
if (!_counters.TryGetValue(counterName, out res))
{
throw new PerformanceCounterCreationException("Can't create not existed counter in mode 'UseOnlyExisted'. Counter: " + counterName + ", Category: " + this.ToString());
}
if (res.Type != type && CounterHelper.IsWinCompatible(res.Type, type))
{
var newCntr = CounterHelper.CreateCounter(type, counterName, res.Description, Info);
if (_counters.TryUpdate(counterName, newCntr, res))
{
(newCntr as IWinCounterInitialization).CounterInit(this.FullName, null);
res = newCntr;
}
}
if (res.Type != type)
{
throw new PerformanceCounterCreationException("Can't create not existed counter in mode 'UseOnlyExisted'. Counter: " + counterName,
new InvalidCounterTypeException(string.Format("Counter types are not equal. Expected: {0}, Returned: {1}", type, res.Type)));
}
return(res);
}
/// <summary>
/// Получение счетчика определенного типа
/// </summary>
/// <param name="counterName">Имя счетчика</param>
/// <param name="expectedCounterType">Тип счётчика</param>
/// <returns>Счётчик</returns>
public override Counter GetCounter(string counterName, CounterTypes expectedCounterType)
{
if (_state == WinCategoryState.Disposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
Counter res = null;
if (!_counters.TryGetValue(counterName, out res))
{
throw new CounterNotExistException(string.Format("Counter ({0}) is not found in instance {1} of category {2}", counterName, this.InstanceName, this.Parent.Name));
}
if (res.Type != expectedCounterType)
{
throw new InvalidCounterTypeException(
string.Format("Counter types are not equal. Expected: {0}, Returned: {1}", expectedCounterType, res.Type));
}
return(res);
}
/// <summary>
/// Конструктор FractionCounterValueData
/// </summary>
/// <param name="name">Имя счётчика</param>
/// <param name="type">Тип счётчика</param>
/// <param name="value">Значение счётчика</param>
public FractionCounterValueData(string name, CounterTypes type, double value)
: base(name, type, value)
{
}
/// <summary>
/// Преобразовать тип счётчика из внутреннего в Windows
/// </summary>
/// <param name="srcType">Исходный тип счётчика</param>
/// <param name="prefer64BitCounter">Предпочитать ли 64-ёх битные счётчики</param>
/// <returns>Преобразованный тип счётчика</returns>
public static PerformanceCounterType ConvertCounterType(CounterTypes srcType, bool prefer64BitCounter)
{
switch (srcType)
{
case CounterTypes.NumberOfItems:
if (prefer64BitCounter)
{
return(PerformanceCounterType.NumberOfItems64);
}
else
{
return(PerformanceCounterType.NumberOfItems32);
}
case CounterTypes.OperationsPerSecond:
if (prefer64BitCounter)
{
return(PerformanceCounterType.RateOfCountsPerSecond64);
}
else
{
return(PerformanceCounterType.RateOfCountsPerSecond32);
}
//case CounterTypes.CountPerTimeInterval:
// break;
case CounterTypes.AverageCount:
return(PerformanceCounterType.AverageCount64);
case CounterTypes.AverageTime:
return(PerformanceCounterType.AverageTimer32);
case CounterTypes.MomentTime:
if (prefer64BitCounter)
{
return(PerformanceCounterType.NumberOfItems64);
}
else
{
return(PerformanceCounterType.NumberOfItems32);
}
//case CounterTypes.RawFraction:
// break;
//case CounterTypes.CounterMultiTimer:
// break;
//case CounterTypes.SampleCounter:
// break;
//case CounterTypes.SampleFraction:
// break;
case CounterTypes.Delta:
if (prefer64BitCounter)
{
return(PerformanceCounterType.CounterDelta64);
}
else
{
return(PerformanceCounterType.CounterDelta32);
}
case CounterTypes.ElapsedTime:
return(PerformanceCounterType.ElapsedTime);
default:
throw new InvalidOperationException("Unknown CounterTypes value: " + srcType.ToString());
}
}
/// <summary>
/// Создать счётчик определённого типа
/// </summary>
/// <param name="type">Тип счётчика</param>
/// <param name="counterName">Имя счетчика</param>
/// <param name="counterDescription">Описание счетчика</param>
public override void CreateCounter(CounterTypes type, string counterName, string counterDescription)
{
if (counterName == null)
{
throw new ArgumentNullException("counterName");
}
if (counterDescription == null)
{
throw new ArgumentNullException("counterDescription");
}
if (_instances.Count != 0)
{
throw new PerformanceCounterCreationException(
string.Format("Can't create counter in multiInstanceCategory ({0}) when it has created instances", this.Name));
}
if (_counters.ContainsKey(counterName))
{
throw new DuplicateCounterNameException("Counter with the same name is already existed. Name: " + counterName);
}
CompositeCounterDescriptor res = null;
switch (type)
{
case CounterTypes.NumberOfItems:
res = CompositeNumberOfItemsCounter.CreateDescriptor(counterName, counterDescription);
break;
case CounterTypes.Delta:
res = CompositeDeltaCounter.CreateDescriptor(counterName, counterDescription);
break;
case CounterTypes.AverageTime:
res = CompositeAverageTimeCounter.CreateDescriptor(counterName, counterDescription);
break;
case CounterTypes.AverageCount:
res = CompositeAverageCountCounter.CreateDescriptor(counterName, counterDescription);
break;
case CounterTypes.OperationsPerSecond:
res = CompositeOperationsPerSecondCounter.CreateDescriptor(counterName, counterDescription);
break;
case CounterTypes.ElapsedTime:
res = CompositeElapsedTimeCounter.CreateDescriptor(counterName, counterDescription);
break;
case CounterTypes.MomentTime:
res = CompositeMomentTimeCounter.CreateDescriptor(counterName, counterDescription);
break;
default:
throw new InvalidOperationException("Unknown CounterTypes value: " + type.ToString());
}
if (!_counters.TryAdd(counterName, res))
{
throw new DuplicateCounterNameException("Counter with the same name is already existed. Name: " + counterName);
}
foreach (var wrappedCat in _wrappedCategories)
{
wrappedCat.CreateCounter(type, counterName, counterDescription);
}
}
/// <summary>
/// Получение счетчика определенного типа. Всегда создаёт новый.
/// </summary>
/// <param name="counterName">Имя счетчика</param>
/// <param name="expectedCounterType">Тип счётчика</param>
/// <returns>Счётчик</returns>
public override Counter GetCounter(string counterName, CounterTypes expectedCounterType)
{
return(CreateCounter(expectedCounterType, counterName, counterName));
}
/// <summary> /// Create counter /// </summary> /// <param name="type">Counter type</param> /// <param name="counterName">Existing counter name</param> /// <param name="counterDescription">Counter description</param> /// <returns>Counter</returns> public abstract Counter CreateCounter(CounterTypes type, string counterName, string counterDescription);
/// <summary> /// Returns existing counter by name and type /// </summary> /// <param name="counterName">Existing counter name</param> /// <param name="expectedCounterType">Counter type</param> /// <returns>Counter</returns> public abstract Counter GetCounter(string counterName, CounterTypes expectedCounterType);
/// <summary>
/// Конструктор ItemCounterValueData
/// </summary>
/// <param name="name">Имя счётчика</param>
/// <param name="type">Тип счётчика</param>
/// <param name="value">Значение счётчика</param>
public ItemCounterValueData(string name, CounterTypes type, long value)
: base(name, type, value)
{
}
/// <summary>
/// Конструктор TimeCounterValueData
/// </summary>
/// <param name="name">Имя счётчика</param>
/// <param name="type">Тип счётчика</param>
/// <param name="value">Значение счётчика</param>
public TimeCounterValueData(string name, CounterTypes type, TimeSpan value)
: base(name, type, value.TotalMilliseconds)
{
}
/// <summary>
/// Создать счётчик определённого типа
/// </summary>
/// <param name="type">Тип счётчика</param>
/// <param name="counterName">Имя счетчика</param>
/// <param name="counterDescription">Описание счетчика</param>
public override void CreateCounter(CounterTypes type, string counterName, string counterDescription)
{
}
/// <summary>
/// Попробовать сконвертировать тип счётчика Windows во внутренний тип счётчика
/// </summary>
/// <param name="srcWinType">Тип счётчика Windows</param>
/// <param name="resLocType">Сконвертированный тип счётчика</param>
/// <returns>Найдено ли соответствие</returns>
public static bool TryConvertCounterType(PerformanceCounterType srcWinType, out CounterTypes resLocType)
{
switch (srcWinType)
{
//case PerformanceCounterType.AverageBase:
// break;
case PerformanceCounterType.AverageCount64:
resLocType = CounterTypes.AverageCount;
return(true);
case PerformanceCounterType.AverageTimer32:
resLocType = CounterTypes.AverageTime;
return(true);
//case PerformanceCounterType.CountPerTimeInterval32:
// break;
//case PerformanceCounterType.CountPerTimeInterval64:
// break;
case PerformanceCounterType.CounterDelta32:
case PerformanceCounterType.CounterDelta64:
resLocType = CounterTypes.Delta;
return(true);
//case PerformanceCounterType.CounterMultiBase:
// break;
//case PerformanceCounterType.CounterMultiTimer:
// break;
//case PerformanceCounterType.CounterMultiTimer100Ns:
// break;
//case PerformanceCounterType.CounterMultiTimer100NsInverse:
// break;
//case PerformanceCounterType.CounterMultiTimerInverse:
// break;
//case PerformanceCounterType.CounterTimer:
// break;
//case PerformanceCounterType.CounterTimerInverse:
// break;
case PerformanceCounterType.ElapsedTime:
resLocType = CounterTypes.ElapsedTime;
return(true);
case PerformanceCounterType.NumberOfItems32:
resLocType = CounterTypes.NumberOfItems;
return(true);
case PerformanceCounterType.NumberOfItems64:
resLocType = CounterTypes.NumberOfItems;
return(true);
//case PerformanceCounterType.NumberOfItemsHEX32:
// break;
//case PerformanceCounterType.NumberOfItemsHEX64:
// break;
case PerformanceCounterType.RateOfCountsPerSecond32:
resLocType = CounterTypes.OperationsPerSecond;
return(true);
case PerformanceCounterType.RateOfCountsPerSecond64:
resLocType = CounterTypes.OperationsPerSecond;
return(true);
//case PerformanceCounterType.RawBase:
// break;
//case PerformanceCounterType.RawFraction:
// break;
//case PerformanceCounterType.SampleBase:
// break;
//case PerformanceCounterType.SampleCounter:
// break;
//case PerformanceCounterType.SampleFraction:
// break;
//case PerformanceCounterType.Timer100Ns:
// break;
//case PerformanceCounterType.Timer100NsInverse:
// break;
}
resLocType = default(CounterTypes);
return(false);
}
