/// <summary>
/// Returns true if the counter is registered for this category on a particular machine.
/// </summary>
public static bool CounterExists(string counterName, string categoryName, string machineName)
{
if (counterName == null)
{
throw new ArgumentNullException(nameof(counterName));
}
if (categoryName == null)
{
throw new ArgumentNullException(nameof(categoryName));
}
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(categoryName), categoryName), nameof(categoryName));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(machineName), machineName), nameof(machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
return(PerformanceCounterLib.CounterExists(machineName, categoryName, counterName));
}
private static void DeleteCategory(string categoryName, string machineName)
{
CheckValidCategory(categoryName);
if (machineName != "." && String.Compare(machineName, PerformanceCounterLib.ComputerName, true, CultureInfo.InvariantCulture) != 0)
{
throw new NotSupportedException(SR.GetString(SR.RemoteCounterAdmin));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName);
permission.Demand();
SharedUtils.CheckNtEnvironment();
Mutex mutex = SharedUtils.EnterMutex(perfMutexName);
try {
if (!PerformanceCounterLib.IsCustomCategory(machineName, categoryName))
{
throw new InvalidOperationException(SR.GetString(SR.CantDeleteCategory));
}
PerformanceCounterLib.UnregisterCategory(machineName, categoryName);
}
finally {
mutex.ReleaseMutex();
mutex.Close();
}
}
// Will cause an update, raw value
/// <devdoc>
/// Obtains a counter sample and returns the raw value for it.
/// </devdoc>
public CounterSample NextSample()
{
string currentCategoryName = categoryName;
string currentMachineName = machineName;
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, currentMachineName, currentCategoryName);
permission.Demand();
Initialize();
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(currentMachineName, currentCategoryName);
CounterDefinitionSample counterSample = categorySample.GetCounterDefinitionSample(this.counterName);
this.counterType = counterSample.CounterType;
if (!categorySample.IsMultiInstance)
{
if (instanceName != null && instanceName.Length != 0)
{
throw new InvalidOperationException(SR.GetString(SR.InstanceNameProhibited, this.instanceName));
}
return(counterSample.GetSingleValue());
}
else
{
if (instanceName == null || instanceName.Length == 0)
{
throw new InvalidOperationException(SR.GetString(SR.InstanceNameRequired));
}
return(counterSample.GetInstanceValue(this.instanceName));
}
}
/// <devdoc>
/// Returns true if the category is registered in the machine.
/// </devdoc>
public static bool Exists(string categoryName, string machineName)
{
if (categoryName == null)
{
throw new ArgumentNullException("categoryName");
}
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "categoryName", categoryName));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
if (PerformanceCounterLib.IsCustomCategory(machineName, categoryName))
{
return(true);
}
return(PerformanceCounterLib.CategoryExists(machineName, categoryName));
}
/// <devdoc>
/// Frees all the resources allocated for all performance
/// counters, frees File Mapping used by extensible counters,
/// unloads dll's used to read counters.
/// </devdoc>
public static void CloseSharedResources()
{
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, ".", "*");
permission.Demand();
PerformanceCounterLib.CloseAllLibraries();
}
protected virtual bool UserHasAccessRights(string catagory)
{
PerformanceCounterPermission permissions = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Write, ".", catagory);
permissions.Demand();
if (!PerformanceCounterCategory.Exists(catagory, "."))
return false;
return true;
}
/// <include file='doc\PerformanceCounter.uex' path='docs/doc[@for="PerformanceCounter.Initialize"]/*' />
/// <devdoc>
/// Intializes required resources
/// </devdoc>
private void Initialize()
{
if (!initialized && !DesignMode)
{
lock (this) {
if (!initialized)
{
if (this.categoryName == String.Empty)
{
throw new InvalidOperationException(SR.GetString(SR.CategoryNameMissing));
}
if (this.counterName == String.Empty)
{
throw new InvalidOperationException(SR.GetString(SR.CounterNameMissing));
}
if (this.ReadOnly)
{
PerformanceCounterPermission permission = new PerformanceCounterPermission(
PerformanceCounterPermissionAccess.Browse, this.machineName, this.categoryName);
permission.Demand();
if (!PerformanceCounterLib.CounterExists(machineName, categoryName, counterName))
{
throw new InvalidOperationException(SR.GetString(SR.CounterExists, categoryName, counterName));
}
this.initialized = true;
}
else
{
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Instrument, this.machineName, this.categoryName);
permission.Demand();
if (this.machineName != "." && String.Compare(this.machineName, PerformanceCounterLib.ComputerName, true, CultureInfo.InvariantCulture) != 0)
{
throw new InvalidOperationException(SR.GetString(SR.RemoteWriting));
}
SharedUtils.CheckNtEnvironment();
if (!PerformanceCounterLib.IsCustomCategory(machineName, categoryName))
{
throw new InvalidOperationException(SR.GetString(SR.NotCustomCounter));
}
this.sharedCounter = new SharedPerformanceCounter(categoryName.ToLower(CultureInfo.InvariantCulture), counterName.ToLower(CultureInfo.InvariantCulture), instanceName.ToLower(CultureInfo.InvariantCulture));
this.initialized = true;
}
}
}
}
}
/// <devdoc>
/// Creates a PerformanceCounterCategory object for given category.
/// Uses the given machine name.
/// </devdoc>
public PerformanceCounterCategory(string categoryName, string machineName) {
if (categoryName == null)
throw new ArgumentNullException("categoryName");
if (categoryName.Length == 0)
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "categoryName", categoryName));
if (!SyntaxCheck.CheckMachineName(machineName))
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
this.categoryName = categoryName;
this.machineName = machineName;
}
public static PerformanceCounterCategory Create(string categoryName, string categoryHelp, PerformanceCounterCategoryType categoryType, CounterCreationDataCollection counterData)
{
if (categoryType < PerformanceCounterCategoryType.Unknown || categoryType > PerformanceCounterCategoryType.MultiInstance)
{
throw new ArgumentOutOfRangeException("categoryType");
}
if (counterData == null)
{
throw new ArgumentNullException("counterData");
}
CheckValidCategory(categoryName);
if (categoryHelp != null)
{
// null categoryHelp is a valid option - it gets set to "Help Not Available" later on.
CheckValidHelp(categoryHelp);
}
string machineName = ".";
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName);
permission.Demand();
SharedUtils.CheckNtEnvironment();
Mutex mutex = null;
RuntimeHelpers.PrepareConstrainedRegions();
try {
SharedUtils.EnterMutex(perfMutexName, ref mutex);
if (PerformanceCounterLib.IsCustomCategory(machineName, categoryName) || PerformanceCounterLib.CategoryExists(machineName, categoryName))
{
throw new InvalidOperationException(SR.GetString(SR.PerformanceCategoryExists, categoryName));
}
CheckValidCounterLayout(counterData);
PerformanceCounterLib.RegisterCategory(categoryName, categoryType, categoryHelp, counterData);
return(new PerformanceCounterCategory(categoryName, machineName));
}
finally {
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
/// <include file='doc\PerformanceCounterCategory.uex' path='docs/doc[@for="PerformanceCounterCategory.GetCounterInstances"]/*' />
/// <devdoc>
/// Returns the instance names for a given category
/// </devdoc>
/// <internalonly/>
internal static string[] GetCounterInstances(string categoryName, string machineName)
{
if (categoryName == null)
{
throw new ArgumentNullException("categoryName");
}
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "categoryName", categoryName));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Browse, machineName, categoryName);
permission.Demand();
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(machineName, categoryName);
try {
if (categorySample.InstanceNameTable.Count == 0)
{
throw new InvalidOperationException(SR.GetString(SR.NoInstanceInformation, categoryName));
}
string[] instanceNames = new string[categorySample.InstanceNameTable.Count];
categorySample.InstanceNameTable.Keys.CopyTo(instanceNames, 0);
if (instanceNames.Length == 1 && instanceNames[0].CompareTo(PerformanceCounterLib.SingleInstanceName) == 0)
{
return(new string[0]);
}
return(instanceNames);
}
finally {
categorySample.Dispose();
}
}
/// <devdoc>
/// Returns an array of performance counter categories for a particular machine.
/// </devdoc>
public static PerformanceCounterCategory[] GetCategories(string machineName)
{
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, "*");
permission.Demand();
string[] categoryNames = PerformanceCounterLib.GetCategories(machineName);
PerformanceCounterCategory[] categories = new PerformanceCounterCategory[categoryNames.Length];
for (int index = 0; index < categories.Length; index++)
{
categories[index] = new PerformanceCounterCategory(categoryNames[index], machineName);
}
return(categories);
}
/// <devdoc>
/// Returns the instance names for a given category
/// </devdoc>
/// <internalonly/>
internal static string[] GetCounterInstances(string categoryName, string machineName)
{
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(machineName, categoryName);
if (categorySample.InstanceNameTable.Count == 0)
{
return(new string[0]);
}
string[] instanceNames = new string[categorySample.InstanceNameTable.Count];
categorySample.InstanceNameTable.Keys.CopyTo(instanceNames, 0);
if (instanceNames.Length == 1 && instanceNames[0].CompareTo(PerformanceCounterLib.SingleInstanceName) == 0)
{
return(new string[0]);
}
return(instanceNames);
}
public static void Delete(string categoryName)
{
CheckValidCategory(categoryName);
string machineName = ".";
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName);
permission.Demand();
SharedUtils.CheckNtEnvironment();
categoryName = categoryName.ToLower(CultureInfo.InvariantCulture);
Mutex mutex = null;
RuntimeHelpers.PrepareConstrainedRegions();
try {
SharedUtils.EnterMutex(perfMutexName, ref mutex);
if (!PerformanceCounterLib.IsCustomCategory(machineName, categoryName))
{
throw new InvalidOperationException(SR.GetString(SR.CantDeleteCategory));
}
SharedPerformanceCounter.RemoveAllInstances(categoryName);
PerformanceCounterLib.UnregisterCategory(categoryName);
PerformanceCounterLib.CloseAllLibraries();
}
finally {
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
/// <devdoc>
/// Creates a PerformanceCounterCategory object for given category.
/// Uses the given machine name.
/// </devdoc>
public PerformanceCounterCategory(string categoryName, string machineName)
{
if (categoryName == null)
{
throw new ArgumentNullException("categoryName");
}
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "categoryName", categoryName));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
this.categoryName = categoryName;
this.machineName = machineName;
}
/// <summary>
/// Creates a PerformanceCounterCategory object for given category.
/// Uses the given machine name.
/// </summary>
public PerformanceCounterCategory(string categoryName, string machineName)
{
if (categoryName == null)
{
throw new ArgumentNullException(nameof(categoryName));
}
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(categoryName), categoryName), nameof(categoryName));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(machineName), machineName), nameof(machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
_categoryName = categoryName;
_machineName = machineName;
}
internal static PerformanceCounterCategory Create(string categoryName, string categoryHelp, CounterCreationDataCollection counterData, string machineName, string localizedIniFilePath)
{
CheckValidCategory(categoryName);
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
}
if (machineName != "." && String.Compare(machineName, PerformanceCounterLib.ComputerName, true, CultureInfo.InvariantCulture) != 0)
{
throw new NotSupportedException(SR.GetString(SR.RemoteCounterAdmin));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName);
permission.Demand();
SharedUtils.CheckNtEnvironment();
Mutex mutex = SharedUtils.EnterMutex(perfMutexName);
try {
if (PerformanceCounterLib.IsCustomCategory(machineName, categoryName) || PerformanceCounterLib.CategoryExists(machineName, categoryName))
{
throw new InvalidOperationException(SR.GetString(SR.PerformanceCategoryExists));
}
// Ensure that there are no duplicate counter names being created
Hashtable h = new Hashtable();
for (int i = 0; i < counterData.Count; i++)
{
// Ensure that all counter help strings aren't null or empty
if (counterData[i].CounterName == null || counterData[i].CounterName.Length == 0)
{
throw new ArgumentException(SR.GetString(SR.InvalidCounterName));
}
int currentSampleType = (int)counterData[i].CounterType;
if ((currentSampleType == NativeMethods.PERF_AVERAGE_BULK) ||
(currentSampleType == NativeMethods.PERF_COUNTER_QUEUELEN_TYPE) ||
(currentSampleType == NativeMethods.PERF_COUNTER_LARGE_QUEUELEN_TYPE) ||
(currentSampleType == NativeMethods.PERF_100NSEC_MULTI_TIMER) ||
(currentSampleType == NativeMethods.PERF_100NSEC_MULTI_TIMER_INV) ||
(currentSampleType == NativeMethods.PERF_COUNTER_MULTI_TIMER) ||
(currentSampleType == NativeMethods.PERF_COUNTER_MULTI_TIMER_INV) ||
(currentSampleType == NativeMethods.PERF_RAW_FRACTION) ||
(currentSampleType == NativeMethods.PERF_SAMPLE_FRACTION) ||
(currentSampleType == NativeMethods.PERF_SAMPLE_COUNTER) ||
(currentSampleType == NativeMethods.PERF_AVERAGE_TIMER))
{
if (counterData.Count <= (i + 1))
{
throw new InvalidOperationException(SR.GetString(SR.CounterLayout));
}
else
{
currentSampleType = (int)counterData[i + 1].CounterType;
if (currentSampleType != NativeMethods.PERF_AVERAGE_BASE &&
currentSampleType != NativeMethods.PERF_COUNTER_MULTI_BASE &&
currentSampleType != NativeMethods.PERF_RAW_BASE &&
currentSampleType != NativeMethods.PERF_SAMPLE_BASE)
{
throw new InvalidOperationException(SR.GetString(SR.CounterLayout));
}
}
}
else if (currentSampleType == NativeMethods.PERF_AVERAGE_BASE ||
currentSampleType == NativeMethods.PERF_COUNTER_MULTI_BASE ||
currentSampleType == NativeMethods.PERF_RAW_BASE ||
currentSampleType == NativeMethods.PERF_SAMPLE_BASE)
{
if (i == 0)
{
throw new InvalidOperationException(SR.GetString(SR.CounterLayout));
}
else
{
currentSampleType = (int)counterData[i - 1].CounterType;
if (
(currentSampleType != NativeMethods.PERF_AVERAGE_BULK) &&
(currentSampleType != NativeMethods.PERF_COUNTER_QUEUELEN_TYPE) &&
(currentSampleType != NativeMethods.PERF_COUNTER_LARGE_QUEUELEN_TYPE) &&
(currentSampleType != NativeMethods.PERF_100NSEC_MULTI_TIMER) &&
(currentSampleType != NativeMethods.PERF_100NSEC_MULTI_TIMER_INV) &&
(currentSampleType != NativeMethods.PERF_COUNTER_MULTI_TIMER) &&
(currentSampleType != NativeMethods.PERF_COUNTER_MULTI_TIMER_INV) &&
(currentSampleType != NativeMethods.PERF_RAW_FRACTION) &&
(currentSampleType != NativeMethods.PERF_SAMPLE_FRACTION) &&
(currentSampleType != NativeMethods.PERF_SAMPLE_COUNTER) &&
(currentSampleType != NativeMethods.PERF_AVERAGE_TIMER))
{
throw new InvalidOperationException(SR.GetString(SR.CounterLayout));
}
}
}
if (h.ContainsKey(counterData[i].CounterName))
{
throw new ArgumentException(SR.GetString(SR.DuplicateCounterName, counterData[i].CounterName));
}
else
{
h.Add(counterData[i].CounterName, String.Empty);
// Ensure that all counter help strings aren't null or empty
if (counterData[i].CounterHelp == null || counterData[i].CounterHelp.Length == 0)
{
counterData[i].CounterHelp = counterData[i].CounterName + " help";
}
}
}
if (localizedIniFilePath == null)
{
PerformanceCounterLib.RegisterCategory(machineName, categoryName, categoryHelp, counterData);
}
else
{
PerformanceCounterLib.RegisterCategory(machineName, categoryName, categoryHelp, counterData, localizedIniFilePath);
}
return(new PerformanceCounterCategory(categoryName, machineName));
}
finally {
mutex.ReleaseMutex();
mutex.Close();
}
}
/// <devdoc>
/// Returns an array of performance counter categories for a particular machine.
/// </devdoc>
public static PerformanceCounterCategory[] GetCategories(string machineName) {
if (!SyntaxCheck.CheckMachineName(machineName))
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, "*");
permission.Demand();
string[] categoryNames = PerformanceCounterLib.GetCategories(machineName);
PerformanceCounterCategory[] categories = new PerformanceCounterCategory[categoryNames.Length];
for (int index = 0; index < categories.Length; index++)
categories[index] = new PerformanceCounterCategory(categoryNames[index], machineName);
return categories;
}
/// <devdoc>
/// Returns the instance names for a given category
/// </devdoc>
/// <internalonly/>
internal static string[] GetCounterInstances(string categoryName, string machineName) {
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(machineName, categoryName);
if (categorySample.InstanceNameTable.Count == 0)
return new string[0];
string[] instanceNames = new string[categorySample.InstanceNameTable.Count];
categorySample.InstanceNameTable.Keys.CopyTo(instanceNames, 0);
if (instanceNames.Length == 1 && instanceNames[0].CompareTo(PerformanceCounterLib.SingleInstanceName) == 0)
return new string[0];
return instanceNames;
}
/// <devdoc>
/// Returns true if the category is registered in the machine.
/// </devdoc>
public static bool Exists(string categoryName, string machineName) {
if (categoryName == null)
throw new ArgumentNullException("categoryName");
if (categoryName.Length == 0)
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "categoryName", categoryName));
if (!SyntaxCheck.CheckMachineName(machineName))
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
if (PerformanceCounterLib.IsCustomCategory(machineName , categoryName))
return true;
return PerformanceCounterLib.CategoryExists(machineName , categoryName);
}
public static void Delete(string categoryName) {
CheckValidCategory(categoryName);
string machineName = ".";
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName);
permission.Demand();
SharedUtils.CheckNtEnvironment();
categoryName = categoryName.ToLower(CultureInfo.InvariantCulture);
Mutex mutex = null;
RuntimeHelpers.PrepareConstrainedRegions();
try {
SharedUtils.EnterMutex(perfMutexName, ref mutex);
if (!PerformanceCounterLib.IsCustomCategory(machineName, categoryName))
throw new InvalidOperationException(SR.GetString(SR.CantDeleteCategory));
SharedPerformanceCounter.RemoveAllInstances(categoryName);
PerformanceCounterLib.UnregisterCategory(categoryName);
PerformanceCounterLib.CloseAllLibraries();
}
finally {
if (mutex != null) {
mutex.ReleaseMutex();
mutex.Close();
}
}
}
public static PerformanceCounterCategory Create(string categoryName, string categoryHelp, PerformanceCounterCategoryType categoryType, CounterCreationDataCollection counterData) {
if (categoryType < PerformanceCounterCategoryType.Unknown || categoryType > PerformanceCounterCategoryType.MultiInstance)
throw new ArgumentOutOfRangeException("categoryType");
if (counterData == null)
throw new ArgumentNullException("counterData");
CheckValidCategory(categoryName);
if (categoryHelp != null) {
// null categoryHelp is a valid option - it gets set to "Help Not Available" later on.
CheckValidHelp(categoryHelp);
}
string machineName = ".";
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName);
permission.Demand();
SharedUtils.CheckNtEnvironment();
Mutex mutex = null;
RuntimeHelpers.PrepareConstrainedRegions();
try {
SharedUtils.EnterMutex(perfMutexName, ref mutex);
if (PerformanceCounterLib.IsCustomCategory(machineName, categoryName) || PerformanceCounterLib.CategoryExists(machineName , categoryName))
throw new InvalidOperationException(SR.GetString(SR.PerformanceCategoryExists, categoryName));
CheckValidCounterLayout(counterData);
PerformanceCounterLib.RegisterCategory(categoryName, categoryType, categoryHelp, counterData);
return new PerformanceCounterCategory(categoryName, machineName);
}
finally {
if (mutex != null) {
mutex.ReleaseMutex();
mutex.Close();
}
}
}
/// <devdoc>
/// Frees all the resources allocated for all performance
/// counters, frees File Mapping used by extensible counters,
/// unloads dll's used to read counters.
/// </devdoc>
public static void CloseSharedResources() {
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, ".", "*");
permission.Demand();
PerformanceCounterLib.CloseAllLibraries();
}
/// <devdoc>
/// Intializes required resources
/// </devdoc>
//[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
private void InitializeImpl() {
bool tookLock = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
Monitor.Enter(InstanceLockObject, ref tookLock);
if (!initialized) {
string currentCategoryName = categoryName;
string currentMachineName = machineName;
if (currentCategoryName == String.Empty)
throw new InvalidOperationException(SR.GetString(SR.CategoryNameMissing));
if (this.counterName == String.Empty)
throw new InvalidOperationException(SR.GetString(SR.CounterNameMissing));
if (this.ReadOnly) {
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, currentMachineName, currentCategoryName);
permission.Demand();
if (!PerformanceCounterLib.CounterExists(currentMachineName, currentCategoryName, counterName))
throw new InvalidOperationException(SR.GetString(SR.CounterExists, currentCategoryName, counterName));
PerformanceCounterCategoryType categoryType = PerformanceCounterLib.GetCategoryType(currentMachineName, currentCategoryName);
if (categoryType == PerformanceCounterCategoryType.MultiInstance) {
if (String.IsNullOrEmpty(instanceName))
throw new InvalidOperationException(SR.GetString(SR.MultiInstanceOnly, currentCategoryName));
} else if (categoryType == PerformanceCounterCategoryType.SingleInstance) {
if (!String.IsNullOrEmpty(instanceName))
throw new InvalidOperationException(SR.GetString(SR.SingleInstanceOnly, currentCategoryName));
}
if (instanceLifetime != PerformanceCounterInstanceLifetime.Global)
throw new InvalidOperationException(SR.GetString(SR.InstanceLifetimeProcessonReadOnly));
this.initialized = true;
} else {
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Write, currentMachineName, currentCategoryName);
permission.Demand();
if (currentMachineName != "." && String.Compare(currentMachineName, PerformanceCounterLib.ComputerName, StringComparison.OrdinalIgnoreCase) != 0)
throw new InvalidOperationException(SR.GetString(SR.RemoteWriting));
SharedUtils.CheckNtEnvironment();
if (!PerformanceCounterLib.IsCustomCategory(currentMachineName, currentCategoryName))
throw new InvalidOperationException(SR.GetString(SR.NotCustomCounter));
// check category type
PerformanceCounterCategoryType categoryType = PerformanceCounterLib.GetCategoryType(currentMachineName, currentCategoryName);
if (categoryType == PerformanceCounterCategoryType.MultiInstance) {
if (String.IsNullOrEmpty(instanceName))
throw new InvalidOperationException(SR.GetString(SR.MultiInstanceOnly, currentCategoryName));
} else if (categoryType == PerformanceCounterCategoryType.SingleInstance) {
if (!String.IsNullOrEmpty(instanceName))
throw new InvalidOperationException(SR.GetString(SR.SingleInstanceOnly, currentCategoryName));
}
if (String.IsNullOrEmpty(instanceName) && InstanceLifetime == PerformanceCounterInstanceLifetime.Process)
throw new InvalidOperationException(SR.GetString(SR.InstanceLifetimeProcessforSingleInstance));
this.sharedCounter = new SharedPerformanceCounter(currentCategoryName.ToLower(CultureInfo.InvariantCulture), counterName.ToLower(CultureInfo.InvariantCulture), instanceName.ToLower(CultureInfo.InvariantCulture), instanceLifetime);
this.initialized = true;
}
}
} finally {
if (tookLock)
Monitor.Exit(InstanceLockObject);
}
}
// Will cause an update, raw value
/// <devdoc>
/// Obtains a counter sample and returns the raw value for it.
/// </devdoc>
public CounterSample NextSample() {
string currentCategoryName = categoryName;
string currentMachineName = machineName;
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, currentMachineName, currentCategoryName);
permission.Demand();
Initialize();
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(currentMachineName, currentCategoryName);
CounterDefinitionSample counterSample = categorySample.GetCounterDefinitionSample(this.counterName);
this.counterType = counterSample.CounterType;
if (!categorySample.IsMultiInstance) {
if (instanceName != null && instanceName.Length != 0)
throw new InvalidOperationException(SR.GetString(SR.InstanceNameProhibited, this.instanceName));
return counterSample.GetSingleValue();
}
else {
if (instanceName == null || instanceName.Length == 0)
throw new InvalidOperationException(SR.GetString(SR.InstanceNameRequired));
return counterSample.GetInstanceValue(this.instanceName);
}
}
/// <devdoc>
/// Intializes required resources
/// </devdoc>
//[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
private void InitializeImpl()
{
bool tookLock = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
Monitor.Enter(InstanceLockObject, ref tookLock);
if (!initialized)
{
string currentCategoryName = categoryName;
string currentMachineName = machineName;
if (currentCategoryName == String.Empty)
{
throw new InvalidOperationException(SR.GetString(SR.CategoryNameMissing));
}
if (this.counterName == String.Empty)
{
throw new InvalidOperationException(SR.GetString(SR.CounterNameMissing));
}
if (this.ReadOnly)
{
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, currentMachineName, currentCategoryName);
permission.Demand();
if (!PerformanceCounterLib.CounterExists(currentMachineName, currentCategoryName, counterName))
{
throw new InvalidOperationException(SR.GetString(SR.CounterExists, currentCategoryName, counterName));
}
PerformanceCounterCategoryType categoryType = PerformanceCounterLib.GetCategoryType(currentMachineName, currentCategoryName);
if (categoryType == PerformanceCounterCategoryType.MultiInstance)
{
if (String.IsNullOrEmpty(instanceName))
{
throw new InvalidOperationException(SR.GetString(SR.MultiInstanceOnly, currentCategoryName));
}
}
else if (categoryType == PerformanceCounterCategoryType.SingleInstance)
{
if (!String.IsNullOrEmpty(instanceName))
{
throw new InvalidOperationException(SR.GetString(SR.SingleInstanceOnly, currentCategoryName));
}
}
if (instanceLifetime != PerformanceCounterInstanceLifetime.Global)
{
throw new InvalidOperationException(SR.GetString(SR.InstanceLifetimeProcessonReadOnly));
}
this.initialized = true;
}
else
{
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Write, currentMachineName, currentCategoryName);
permission.Demand();
if (currentMachineName != "." && String.Compare(currentMachineName, PerformanceCounterLib.ComputerName, StringComparison.OrdinalIgnoreCase) != 0)
{
throw new InvalidOperationException(SR.GetString(SR.RemoteWriting));
}
SharedUtils.CheckNtEnvironment();
if (!PerformanceCounterLib.IsCustomCategory(currentMachineName, currentCategoryName))
{
throw new InvalidOperationException(SR.GetString(SR.NotCustomCounter));
}
// check category type
PerformanceCounterCategoryType categoryType = PerformanceCounterLib.GetCategoryType(currentMachineName, currentCategoryName);
if (categoryType == PerformanceCounterCategoryType.MultiInstance)
{
if (String.IsNullOrEmpty(instanceName))
{
throw new InvalidOperationException(SR.GetString(SR.MultiInstanceOnly, currentCategoryName));
}
}
else if (categoryType == PerformanceCounterCategoryType.SingleInstance)
{
if (!String.IsNullOrEmpty(instanceName))
{
throw new InvalidOperationException(SR.GetString(SR.SingleInstanceOnly, currentCategoryName));
}
}
if (String.IsNullOrEmpty(instanceName) && InstanceLifetime == PerformanceCounterInstanceLifetime.Process)
{
throw new InvalidOperationException(SR.GetString(SR.InstanceLifetimeProcessforSingleInstance));
}
this.sharedCounter = new SharedPerformanceCounter(currentCategoryName.ToLower(CultureInfo.InvariantCulture), counterName.ToLower(CultureInfo.InvariantCulture), instanceName.ToLower(CultureInfo.InvariantCulture), instanceLifetime);
this.initialized = true;
}
}
} finally {
if (tookLock)
{
Monitor.Exit(InstanceLockObject);
}
}
}