Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Services / Monitoring / system / Diagnosticts / PerformanceCounter.cs / 1 / PerformanceCounter.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Diagnostics {
using System.Runtime.Serialization.Formatters;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Diagnostics;
using System;
using System.Collections;
using System.Globalization;
using System.Security;
using System.Security.Permissions;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Threading;
///
/// Performance Counter component.
/// This class provides support for NT Performance counters.
/// It handles both the existing counters (accesible by Perf Registry Interface)
/// and user defined (extensible) counters.
/// This class is a part of a larger framework, that includes the perf dll object and
/// perf service.
///
[
InstallerType("System.Diagnostics.PerformanceCounterInstaller," + AssemblyRef.SystemConfigurationInstall),
SRDescription(SR.PerformanceCounterDesc),
HostProtection(Synchronization = true, SharedState = true)
]
public sealed class PerformanceCounter : Component, ISupportInitialize {
private string machineName;
private string categoryName;
private string counterName;
private string instanceName;
private PerformanceCounterInstanceLifetime instanceLifetime = PerformanceCounterInstanceLifetime.Global;
private bool isReadOnly;
private bool initialized = false;
private string helpMsg = null;
private int counterType = -1;
// Cached old sample
private CounterSample oldSample = CounterSample.Empty;
// Cached IP Shared Performanco counter
private SharedPerformanceCounter sharedCounter;
[Obsolete("This field has been deprecated and is not used. Use machine.config or an application configuration file to set the size of the PerformanceCounter file mapping.")]
public static int DefaultFileMappingSize = 524288;
///
/// The defaut constructor. Creates the perf counter object
///
public PerformanceCounter() {
machineName = ".";
categoryName = String.Empty;
counterName = String.Empty;
instanceName = String.Empty;
this.isReadOnly = true;
GC.SuppressFinalize(this);
}
///
/// Creates the Performance Counter Object
///
public PerformanceCounter(string categoryName, string counterName, string instanceName, string machineName) {
this.MachineName = machineName;
this.CategoryName = categoryName;
this.CounterName = counterName;
this.InstanceName = instanceName;
this.isReadOnly = true;
Initialize();
GC.SuppressFinalize(this);
}
internal PerformanceCounter(string categoryName, string counterName, string instanceName, string machineName, bool skipInit) {
this.MachineName = machineName;
this.CategoryName = categoryName;
this.CounterName = counterName;
this.InstanceName = instanceName;
this.isReadOnly = true;
this.initialized = true;
GC.SuppressFinalize(this);
}
///
/// Creates the Performance Counter Object on local machine.
///
public PerformanceCounter(string categoryName, string counterName, string instanceName) :
this(categoryName, counterName, instanceName, true) {
}
///
/// Creates the Performance Counter Object on local machine.
///
public PerformanceCounter(string categoryName, string counterName, string instanceName, bool readOnly) {
this.MachineName = ".";
this.CategoryName = categoryName;
this.CounterName = counterName;
this.InstanceName = instanceName;
this.isReadOnly = readOnly;
Initialize();
GC.SuppressFinalize(this);
}
///
/// Creates the Performance Counter Object, assumes that it's a single instance
///
public PerformanceCounter(string categoryName, string counterName) :
this(categoryName, counterName, true) {
}
///
/// Creates the Performance Counter Object, assumes that it's a single instance
///
public PerformanceCounter(string categoryName, string counterName, bool readOnly) :
this(categoryName, counterName, "", readOnly) {
}
///
/// Returns the performance category name for this performance counter
///
[
ReadOnly(true),
DefaultValue(""),
TypeConverter("System.Diagnostics.Design.CategoryValueConverter, " + AssemblyRef.SystemDesign),
SRDescription(SR.PCCategoryName),
RecommendedAsConfigurable(true)
]
public string CategoryName {
get {
return categoryName;
}
set {
if (value == null)
throw new ArgumentNullException("value");
if (categoryName == null || String.Compare(categoryName, value, StringComparison.OrdinalIgnoreCase) != 0) {
categoryName = value;
Close();
}
}
}
///
/// Returns the description message for this performance counter
///
[
ReadOnly(true),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
MonitoringDescription(SR.PC_CounterHelp)
]
public string CounterHelp {
get {
string currentCategoryName = categoryName;
string currentMachineName = machineName;
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, currentMachineName, currentCategoryName);
permission.Demand();
Initialize();
if (helpMsg == null)
helpMsg = PerformanceCounterLib.GetCounterHelp(currentMachineName, currentCategoryName, this.counterName);
return helpMsg;
}
}
///
/// Sets/returns the performance counter name for this performance counter
///
[
ReadOnly(true),
DefaultValue(""),
TypeConverter("System.Diagnostics.Design.CounterNameConverter, " + AssemblyRef.SystemDesign),
SRDescription(SR.PCCounterName),
RecommendedAsConfigurable(true)
]
public string CounterName {
get {
return counterName;
}
set {
if (value == null)
throw new ArgumentNullException("value");
if (counterName == null || String.Compare(counterName, value, StringComparison.OrdinalIgnoreCase) != 0) {
counterName = value;
Close();
}
}
}
///
/// Sets/Returns the counter type for this performance counter
///
[
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
MonitoringDescription(SR.PC_CounterType)
]
public PerformanceCounterType CounterType {
get {
if (counterType == -1) {
string currentCategoryName = categoryName;
string currentMachineName = machineName;
// This is the same thing that NextSample does, except that it doesn't try to get the actual counter
// value. If we wanted the counter value, we would need to have an instance name.
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;
}
return(PerformanceCounterType) counterType;
}
}
[
DefaultValue(PerformanceCounterInstanceLifetime.Global),
SRDescription(SR.PCInstanceLifetime),
]
public PerformanceCounterInstanceLifetime InstanceLifetime {
get { return instanceLifetime; }
set {
if (value > PerformanceCounterInstanceLifetime.Process || value < PerformanceCounterInstanceLifetime.Global)
throw new ArgumentOutOfRangeException("value");
if (initialized)
throw new InvalidOperationException(SR.GetString(SR.CantSetLifetimeAfterInitialized));
instanceLifetime = value;
}
}
///
/// Sets/returns an instance name for this performance counter
///
[
ReadOnly(true),
DefaultValue(""),
TypeConverter("System.Diagnostics.Design.InstanceNameConverter, " + AssemblyRef.SystemDesign),
SRDescription(SR.PCInstanceName),
RecommendedAsConfigurable(true)
]
public string InstanceName {
get {
return instanceName;
}
set {
if (value == null && instanceName == null)
return;
if ((value == null && instanceName != null) ||
(value != null && instanceName == null) ||
String.Compare(instanceName, value, StringComparison.OrdinalIgnoreCase) != 0) {
instanceName = value;
Close();
}
}
}
///
/// Returns true if counter is read only (system counter, foreign extensible counter or remote counter)
///
[
Browsable(false),
DefaultValue(true),
MonitoringDescription(SR.PC_ReadOnly)
]
public bool ReadOnly {
get {
return isReadOnly;
}
set {
if (value != this.isReadOnly) {
this.isReadOnly = value;
Close();
}
}
}
///
/// Set/returns the machine name for this performance counter
///
[
Browsable(false),
DefaultValue("."),
SRDescription(SR.PCMachineName),
RecommendedAsConfigurable(true)
]
public string MachineName {
get {
return machineName;
}
set {
if (!SyntaxCheck.CheckMachineName(value))
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", value));
if (machineName != value) {
machineName = value;
Close();
}
}
}
///
/// Directly accesses the raw value of this counter. If counter type is of a 32-bit size, it will truncate
/// the value given to 32 bits. This can be significantly more performant for scenarios where
/// the raw value is sufficient. Note that this only works for custom counters created using
/// this component, non-custom counters will throw an exception if this property is accessed.
///
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
MonitoringDescription(SR.PC_RawValue)
]
public long RawValue {
get {
if (ReadOnly) {
//No need to initialize or Demand, since NextSample already does.
return NextSample().RawValue;
}
else {
Initialize();
return this.sharedCounter.Value;
}
}
set {
if (ReadOnly)
ThrowReadOnly();
Initialize();
this.sharedCounter.Value = value;
}
}
///
///
public void BeginInit() {
this.Close();
}
///
/// Frees all the resources allocated by this counter
///
public void Close() {
this.helpMsg = null;
this.oldSample = CounterSample.Empty;
this.sharedCounter = null;
this.initialized = false;
this.counterType = -1;
}
///
/// Frees all the resources allocated for all performance
/// counters, frees File Mapping used by extensible counters,
/// unloads dll's used to read counters.
///
public static void CloseSharedResources() {
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, ".", "*");
permission.Demand();
PerformanceCounterLib.CloseAllLibraries();
}
///
///
protected override void Dispose(bool disposing) {
// safe to call while finalizing or disposing
//
if (disposing) {
//Dispose managed and unmanaged resources
Close();
}
base.Dispose(disposing);
}
///
/// Decrements counter by one using an efficient atomic operation.
///
public long Decrement() {
if (ReadOnly)
ThrowReadOnly();
Initialize();
return this.sharedCounter.Decrement();
}
///
///
public void EndInit() {
Initialize();
}
///
/// Increments the value of this counter. If counter type is of a 32-bit size, it'll truncate
/// the value given to 32 bits. This method uses a mutex to guarantee correctness of
/// the operation in case of multiple writers. This method should be used with caution because of the negative
/// impact on performance due to creation of the mutex.
///
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public long IncrementBy(long value) {
if (isReadOnly)
ThrowReadOnly();
Initialize();
return this.sharedCounter.IncrementBy(value);
}
///
/// Increments counter by one using an efficient atomic operation.
///
public long Increment() {
if (isReadOnly)
ThrowReadOnly();
Initialize();
return this.sharedCounter.Increment();
}
private void ThrowReadOnly() {
throw new InvalidOperationException(SR.GetString(SR.ReadOnlyCounter));
}
///
/// Intializes required resources
///
//[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
private void Initialize() {
if (!initialized && ! DesignMode) {
bool tookLock = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
RuntimeHelpers.PrepareConstrainedRegions();
try {
}
finally {
Monitor.Enter(this);
tookLock = true;
}
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(this);
}
}
}
// Will cause an update, raw value
///
/// Obtains a counter sample and returns the raw value for it.
///
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);
}
}
///
/// Obtains a counter sample and returns the calculated value for it.
/// NOTE: For counters whose calculated value depend upon 2 counter reads,
/// the very first read will return 0.0.
///
public float NextValue() {
//No need to initialize or Demand, since NextSample already does.
CounterSample newSample = NextSample();
float retVal = 0.0f;
retVal = CounterSample.Calculate(oldSample, newSample);
oldSample = newSample;
return retVal;
}
///
/// Removes this counter instance from the shared memory
///
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public void RemoveInstance() {
if (isReadOnly)
throw new InvalidOperationException(SR.GetString(SR.ReadOnlyRemoveInstance));
Initialize();
sharedCounter.RemoveInstance(this.instanceName.ToLower(CultureInfo.InvariantCulture), instanceLifetime);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Diagnostics {
using System.Runtime.Serialization.Formatters;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Diagnostics;
using System;
using System.Collections;
using System.Globalization;
using System.Security;
using System.Security.Permissions;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Threading;
///
/// Performance Counter component.
/// This class provides support for NT Performance counters.
/// It handles both the existing counters (accesible by Perf Registry Interface)
/// and user defined (extensible) counters.
/// This class is a part of a larger framework, that includes the perf dll object and
/// perf service.
///
[
InstallerType("System.Diagnostics.PerformanceCounterInstaller," + AssemblyRef.SystemConfigurationInstall),
SRDescription(SR.PerformanceCounterDesc),
HostProtection(Synchronization = true, SharedState = true)
]
public sealed class PerformanceCounter : Component, ISupportInitialize {
private string machineName;
private string categoryName;
private string counterName;
private string instanceName;
private PerformanceCounterInstanceLifetime instanceLifetime = PerformanceCounterInstanceLifetime.Global;
private bool isReadOnly;
private bool initialized = false;
private string helpMsg = null;
private int counterType = -1;
// Cached old sample
private CounterSample oldSample = CounterSample.Empty;
// Cached IP Shared Performanco counter
private SharedPerformanceCounter sharedCounter;
[Obsolete("This field has been deprecated and is not used. Use machine.config or an application configuration file to set the size of the PerformanceCounter file mapping.")]
public static int DefaultFileMappingSize = 524288;
///
/// The defaut constructor. Creates the perf counter object
///
public PerformanceCounter() {
machineName = ".";
categoryName = String.Empty;
counterName = String.Empty;
instanceName = String.Empty;
this.isReadOnly = true;
GC.SuppressFinalize(this);
}
///
/// Creates the Performance Counter Object
///
public PerformanceCounter(string categoryName, string counterName, string instanceName, string machineName) {
this.MachineName = machineName;
this.CategoryName = categoryName;
this.CounterName = counterName;
this.InstanceName = instanceName;
this.isReadOnly = true;
Initialize();
GC.SuppressFinalize(this);
}
internal PerformanceCounter(string categoryName, string counterName, string instanceName, string machineName, bool skipInit) {
this.MachineName = machineName;
this.CategoryName = categoryName;
this.CounterName = counterName;
this.InstanceName = instanceName;
this.isReadOnly = true;
this.initialized = true;
GC.SuppressFinalize(this);
}
///
/// Creates the Performance Counter Object on local machine.
///
public PerformanceCounter(string categoryName, string counterName, string instanceName) :
this(categoryName, counterName, instanceName, true) {
}
///
/// Creates the Performance Counter Object on local machine.
///
public PerformanceCounter(string categoryName, string counterName, string instanceName, bool readOnly) {
this.MachineName = ".";
this.CategoryName = categoryName;
this.CounterName = counterName;
this.InstanceName = instanceName;
this.isReadOnly = readOnly;
Initialize();
GC.SuppressFinalize(this);
}
///
/// Creates the Performance Counter Object, assumes that it's a single instance
///
public PerformanceCounter(string categoryName, string counterName) :
this(categoryName, counterName, true) {
}
///
/// Creates the Performance Counter Object, assumes that it's a single instance
///
public PerformanceCounter(string categoryName, string counterName, bool readOnly) :
this(categoryName, counterName, "", readOnly) {
}
///
/// Returns the performance category name for this performance counter
///
[
ReadOnly(true),
DefaultValue(""),
TypeConverter("System.Diagnostics.Design.CategoryValueConverter, " + AssemblyRef.SystemDesign),
SRDescription(SR.PCCategoryName),
RecommendedAsConfigurable(true)
]
public string CategoryName {
get {
return categoryName;
}
set {
if (value == null)
throw new ArgumentNullException("value");
if (categoryName == null || String.Compare(categoryName, value, StringComparison.OrdinalIgnoreCase) != 0) {
categoryName = value;
Close();
}
}
}
///
/// Returns the description message for this performance counter
///
[
ReadOnly(true),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
MonitoringDescription(SR.PC_CounterHelp)
]
public string CounterHelp {
get {
string currentCategoryName = categoryName;
string currentMachineName = machineName;
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, currentMachineName, currentCategoryName);
permission.Demand();
Initialize();
if (helpMsg == null)
helpMsg = PerformanceCounterLib.GetCounterHelp(currentMachineName, currentCategoryName, this.counterName);
return helpMsg;
}
}
///
/// Sets/returns the performance counter name for this performance counter
///
[
ReadOnly(true),
DefaultValue(""),
TypeConverter("System.Diagnostics.Design.CounterNameConverter, " + AssemblyRef.SystemDesign),
SRDescription(SR.PCCounterName),
RecommendedAsConfigurable(true)
]
public string CounterName {
get {
return counterName;
}
set {
if (value == null)
throw new ArgumentNullException("value");
if (counterName == null || String.Compare(counterName, value, StringComparison.OrdinalIgnoreCase) != 0) {
counterName = value;
Close();
}
}
}
///
/// Sets/Returns the counter type for this performance counter
///
[
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
MonitoringDescription(SR.PC_CounterType)
]
public PerformanceCounterType CounterType {
get {
if (counterType == -1) {
string currentCategoryName = categoryName;
string currentMachineName = machineName;
// This is the same thing that NextSample does, except that it doesn't try to get the actual counter
// value. If we wanted the counter value, we would need to have an instance name.
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;
}
return(PerformanceCounterType) counterType;
}
}
[
DefaultValue(PerformanceCounterInstanceLifetime.Global),
SRDescription(SR.PCInstanceLifetime),
]
public PerformanceCounterInstanceLifetime InstanceLifetime {
get { return instanceLifetime; }
set {
if (value > PerformanceCounterInstanceLifetime.Process || value < PerformanceCounterInstanceLifetime.Global)
throw new ArgumentOutOfRangeException("value");
if (initialized)
throw new InvalidOperationException(SR.GetString(SR.CantSetLifetimeAfterInitialized));
instanceLifetime = value;
}
}
///
/// Sets/returns an instance name for this performance counter
///
[
ReadOnly(true),
DefaultValue(""),
TypeConverter("System.Diagnostics.Design.InstanceNameConverter, " + AssemblyRef.SystemDesign),
SRDescription(SR.PCInstanceName),
RecommendedAsConfigurable(true)
]
public string InstanceName {
get {
return instanceName;
}
set {
if (value == null && instanceName == null)
return;
if ((value == null && instanceName != null) ||
(value != null && instanceName == null) ||
String.Compare(instanceName, value, StringComparison.OrdinalIgnoreCase) != 0) {
instanceName = value;
Close();
}
}
}
///
/// Returns true if counter is read only (system counter, foreign extensible counter or remote counter)
///
[
Browsable(false),
DefaultValue(true),
MonitoringDescription(SR.PC_ReadOnly)
]
public bool ReadOnly {
get {
return isReadOnly;
}
set {
if (value != this.isReadOnly) {
this.isReadOnly = value;
Close();
}
}
}
///
/// Set/returns the machine name for this performance counter
///
[
Browsable(false),
DefaultValue("."),
SRDescription(SR.PCMachineName),
RecommendedAsConfigurable(true)
]
public string MachineName {
get {
return machineName;
}
set {
if (!SyntaxCheck.CheckMachineName(value))
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", value));
if (machineName != value) {
machineName = value;
Close();
}
}
}
///
/// Directly accesses the raw value of this counter. If counter type is of a 32-bit size, it will truncate
/// the value given to 32 bits. This can be significantly more performant for scenarios where
/// the raw value is sufficient. Note that this only works for custom counters created using
/// this component, non-custom counters will throw an exception if this property is accessed.
///
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
MonitoringDescription(SR.PC_RawValue)
]
public long RawValue {
get {
if (ReadOnly) {
//No need to initialize or Demand, since NextSample already does.
return NextSample().RawValue;
}
else {
Initialize();
return this.sharedCounter.Value;
}
}
set {
if (ReadOnly)
ThrowReadOnly();
Initialize();
this.sharedCounter.Value = value;
}
}
///
///
public void BeginInit() {
this.Close();
}
///
/// Frees all the resources allocated by this counter
///
public void Close() {
this.helpMsg = null;
this.oldSample = CounterSample.Empty;
this.sharedCounter = null;
this.initialized = false;
this.counterType = -1;
}
///
/// Frees all the resources allocated for all performance
/// counters, frees File Mapping used by extensible counters,
/// unloads dll's used to read counters.
///
public static void CloseSharedResources() {
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, ".", "*");
permission.Demand();
PerformanceCounterLib.CloseAllLibraries();
}
///
///
protected override void Dispose(bool disposing) {
// safe to call while finalizing or disposing
//
if (disposing) {
//Dispose managed and unmanaged resources
Close();
}
base.Dispose(disposing);
}
///
/// Decrements counter by one using an efficient atomic operation.
///
public long Decrement() {
if (ReadOnly)
ThrowReadOnly();
Initialize();
return this.sharedCounter.Decrement();
}
///
///
public void EndInit() {
Initialize();
}
///
/// Increments the value of this counter. If counter type is of a 32-bit size, it'll truncate
/// the value given to 32 bits. This method uses a mutex to guarantee correctness of
/// the operation in case of multiple writers. This method should be used with caution because of the negative
/// impact on performance due to creation of the mutex.
///
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public long IncrementBy(long value) {
if (isReadOnly)
ThrowReadOnly();
Initialize();
return this.sharedCounter.IncrementBy(value);
}
///
/// Increments counter by one using an efficient atomic operation.
///
public long Increment() {
if (isReadOnly)
ThrowReadOnly();
Initialize();
return this.sharedCounter.Increment();
}
private void ThrowReadOnly() {
throw new InvalidOperationException(SR.GetString(SR.ReadOnlyCounter));
}
///
/// Intializes required resources
///
//[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
private void Initialize() {
if (!initialized && ! DesignMode) {
bool tookLock = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
RuntimeHelpers.PrepareConstrainedRegions();
try {
}
finally {
Monitor.Enter(this);
tookLock = true;
}
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(this);
}
}
}
// Will cause an update, raw value
///
/// Obtains a counter sample and returns the raw value for it.
///
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);
}
}
///
/// Obtains a counter sample and returns the calculated value for it.
/// NOTE: For counters whose calculated value depend upon 2 counter reads,
/// the very first read will return 0.0.
///
public float NextValue() {
//No need to initialize or Demand, since NextSample already does.
CounterSample newSample = NextSample();
float retVal = 0.0f;
retVal = CounterSample.Calculate(oldSample, newSample);
oldSample = newSample;
return retVal;
}
///
/// Removes this counter instance from the shared memory
///
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public void RemoveInstance() {
if (isReadOnly)
throw new InvalidOperationException(SR.GetString(SR.ReadOnlyRemoveInstance));
Initialize();
sharedCounter.RemoveInstance(this.instanceName.ToLower(CultureInfo.InvariantCulture), instanceLifetime);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DbDataRecord.cs
- XPathException.cs
- SafeHandle.cs
- BitmapSourceSafeMILHandle.cs
- WsatServiceAddress.cs
- ConditionalWeakTable.cs
- DictionaryManager.cs
- MessageVersionConverter.cs
- WebPageTraceListener.cs
- KerberosReceiverSecurityToken.cs
- CustomAttributeFormatException.cs
- EpmCustomContentWriterNodeData.cs
- PagesSection.cs
- XPathNodeInfoAtom.cs
- TextParagraphProperties.cs
- Tool.cs
- EmissiveMaterial.cs
- AssemblyResourceLoader.cs
- SrgsDocument.cs
- SafeReversePInvokeHandle.cs
- ClientOptions.cs
- TypePropertyEditor.cs
- Delegate.cs
- CultureSpecificCharacterBufferRange.cs
- ClientConfigurationHost.cs
- ValidationHelpers.cs
- QilInvoke.cs
- SmtpDigestAuthenticationModule.cs
- EtwTrace.cs
- Highlights.cs
- AutomationPeer.cs
- RegularExpressionValidator.cs
- Crypto.cs
- UriScheme.cs
- ResourceContainer.cs
- GenericAuthenticationEventArgs.cs
- CngKey.cs
- PopOutPanel.cs
- WindowsEditBox.cs
- WebPartVerb.cs
- PasswordTextNavigator.cs
- AutomationElementCollection.cs
- SortKey.cs
- WorkflowHostingEndpoint.cs
- HashHelper.cs
- FormViewPagerRow.cs
- StsCommunicationException.cs
- TypeNameConverter.cs
- MenuStrip.cs
- MaterialGroup.cs
- CodeSnippetStatement.cs
- DbQueryCommandTree.cs
- XmlDomTextWriter.cs
- SystemTcpConnection.cs
- RtType.cs
- CompensatableTransactionScopeActivity.cs
- SafeSystemMetrics.cs
- ExpressionConverter.cs
- WindowsToolbarAsMenu.cs
- ExtensionQuery.cs
- WizardForm.cs
- HistoryEventArgs.cs
- QueryStringParameter.cs
- GuidelineCollection.cs
- WebPartConnectionsCancelVerb.cs
- METAHEADER.cs
- ZipIOLocalFileDataDescriptor.cs
- WeakReference.cs
- ItemContainerGenerator.cs
- WSHttpBindingBase.cs
- ComponentRenameEvent.cs
- TransformConverter.cs
- BitmapEncoder.cs
- ButtonRenderer.cs
- SectionRecord.cs
- UriTemplateLiteralQueryValue.cs
- Italic.cs
- TileBrush.cs
- HttpCapabilitiesEvaluator.cs
- ProfilePropertyNameValidator.cs
- PagesSection.cs
- UndirectedGraph.cs
- BamlLocalizationDictionary.cs
- designeractionbehavior.cs
- Hex.cs
- Vector3D.cs
- CharUnicodeInfo.cs
- SparseMemoryStream.cs
- InputManager.cs
- LoginCancelEventArgs.cs
- ScriptComponentDescriptor.cs
- TransformPattern.cs
- ScaleTransform3D.cs
- DecimalConverter.cs
- GregorianCalendar.cs
- WSSecureConversationFeb2005.cs
- FunctionDetailsReader.cs
- StringSource.cs
- EditorPartChrome.cs
- EntityCollectionChangedParams.cs