//
using System.Security.Permissions;
+using System.Runtime.CompilerServices;
namespace System.Diagnostics
{
{
private string categoryName;
private string machineName;
+ private PerformanceCounterCategoryType type = PerformanceCounterCategoryType.Unknown;
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ static extern bool CategoryDelete (string name);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ static extern string CategoryHelpInternal (string category, string machine);
+
+ /* this icall allows a null counter and it will just search for the category */
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ static extern bool CounterCategoryExists (string counter, string category, string machine);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ static extern bool Create (string categoryName, string categoryHelp,
+ PerformanceCounterCategoryType categoryType, CounterCreationData[] items);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ static extern int InstanceExistsInternal (string instance, string category, string machine);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ static extern string[] GetCategoryNames (string machine);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ static extern string[] GetCounterNames (string category, string machine);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ static extern string[] GetInstanceNames (string category, string machine);
+
+ static void CheckCategory (string categoryName) {
+ if (categoryName == null)
+ throw new ArgumentNullException ("categoryName");
+ if (categoryName == "")
+ throw new ArgumentException ("categoryName");
+ }
public PerformanceCounterCategory ()
: this ("", ".")
}
// may throw ArgumentException (""), ArgumentNullException
- [MonoTODO]
- public PerformanceCounterCategory (string categoryName,
- string machineName)
+ public PerformanceCounterCategory (string categoryName, string machineName)
{
+ CheckCategory (categoryName);
+ if (machineName == null)
+ throw new ArgumentNullException ("machineName");
// TODO checks and whatever else is needed
this.categoryName = categoryName;
this.machineName = machineName;
- throw new NotImplementedException ();
}
// may throw InvalidOperationException, Win32Exception
- [MonoTODO]
public string CategoryHelp {
- get {throw new NotImplementedException ();}
+ get {
+ string res = CategoryHelpInternal (categoryName, machineName);
+ if (res != null)
+ return res;
+ throw new InvalidOperationException ();
+ }
}
// may throw ArgumentException (""), ArgumentNullException
- [MonoTODO]
public string CategoryName {
get {return categoryName;}
set {
- // TODO needs validity checks
+ if (value == null)
+ throw new ArgumentNullException ("value");
+ if (value == "")
+ throw new ArgumentException ("value");
categoryName = value;
}
}
// may throw ArgumentException
- [MonoTODO]
public string MachineName {
get {return machineName;}
set {
- // TODO needs validity checks
+ if (value == null)
+ throw new ArgumentNullException ("value");
+ if (value == "")
+ throw new ArgumentException ("value");
machineName = value;
}
}
- // may throw ArgumentNullException, InvalidOperationException
- // (categoryName isn't set), Win32Exception
- [MonoTODO]
+ public PerformanceCounterCategoryType CategoryType {
+ get {
+ return type;
+ }
+ }
+
public bool CounterExists (string counterName)
{
- throw new NotImplementedException ();
+ return CounterExists (counterName, categoryName, machineName);
}
- // may throw ArgumentNullException, InvalidOperationException
- // (categoryName is ""), Win32Exception
- [MonoTODO]
- public static bool CounterExists (string counterName,
- string categoryName)
+ public static bool CounterExists (string counterName, string categoryName)
{
- throw new NotImplementedException ();
+ return CounterExists (counterName, categoryName, ".");
}
// may throw ArgumentNullException, InvalidOperationException
// (categoryName is "", machine name is bad), Win32Exception
- [MonoTODO]
- public static bool CounterExists (string counterName,
+ public static bool CounterExists (string counterName, string categoryName, string machineName)
+ {
+ if (counterName == null)
+ throw new ArgumentNullException ("counterName");
+ CheckCategory (categoryName);
+ if (machineName == null)
+ throw new ArgumentNullException ("machineName");
+ return CounterCategoryExists (counterName, categoryName, machineName);
+ }
+
+ [Obsolete ("Use another overload that uses PerformanceCounterCategoryType instead")]
+ public static PerformanceCounterCategory Create (
string categoryName,
- string machineName)
+ string categoryHelp,
+ CounterCreationDataCollection counterData)
{
- throw new NotImplementedException ();
+ return Create (categoryName, categoryHelp,
+ PerformanceCounterCategoryType.Unknown, counterData);
}
- [MonoTODO]
+ [Obsolete ("Use another overload that uses PerformanceCounterCategoryType instead")]
public static PerformanceCounterCategory Create (
string categoryName,
string categoryHelp,
+ string counterName,
+ string counterHelp)
+ {
+ return Create (categoryName, categoryHelp,
+ PerformanceCounterCategoryType.Unknown, counterName, counterHelp);
+ }
+
+ public static PerformanceCounterCategory Create (
+ string categoryName,
+ string categoryHelp,
+ PerformanceCounterCategoryType categoryType,
CounterCreationDataCollection counterData)
{
- throw new NotImplementedException ();
+ CheckCategory (categoryName);
+ if (counterData == null)
+ throw new ArgumentNullException ("counterData");
+ if (counterData.Count == 0)
+ throw new ArgumentException ("counterData");
+ CounterCreationData[] items = new CounterCreationData [counterData.Count];
+ counterData.CopyTo (items, 0);
+ if (!Create (categoryName, categoryHelp, categoryType, items))
+ throw new InvalidOperationException ();
+ return new PerformanceCounterCategory (categoryName, categoryHelp);
}
- [MonoTODO]
public static PerformanceCounterCategory Create (
string categoryName,
string categoryHelp,
+ PerformanceCounterCategoryType categoryType,
string counterName,
string counterHelp)
{
- throw new NotImplementedException ();
+ CheckCategory (categoryName);
+ CounterCreationData[] items = new CounterCreationData [1];
+ // we use PerformanceCounterType.NumberOfItems32 as the default type
+ items [0] = new CounterCreationData (counterName, counterHelp, PerformanceCounterType.NumberOfItems32);
+ if (!Create (categoryName, categoryHelp, categoryType, items))
+ throw new InvalidOperationException ();
+ return new PerformanceCounterCategory (categoryName, categoryHelp);
}
- [MonoTODO]
public static void Delete (string categoryName)
{
- throw new NotImplementedException ();
+ CheckCategory (categoryName);
+ if (!CategoryDelete (categoryName))
+ throw new InvalidOperationException ();
}
- [MonoTODO]
public static bool Exists (string categoryName)
{
- throw new NotImplementedException ();
+ return Exists (categoryName, ".");
}
- [MonoTODO]
- public static bool Exists (string categoryName,
- string machineName)
+ public static bool Exists (string categoryName, string machineName)
{
- throw new NotImplementedException ();
+ CheckCategory (categoryName);
+ return CounterCategoryExists (null, categoryName, machineName);
}
- [MonoTODO]
public static PerformanceCounterCategory[] GetCategories ()
{
- throw new NotImplementedException ();
+ return GetCategories (".");
}
- [MonoTODO]
- public static PerformanceCounterCategory[] GetCategories (
- string machineName)
+ public static PerformanceCounterCategory[] GetCategories (string machineName)
{
- throw new NotImplementedException ();
+ if (machineName == null)
+ throw new ArgumentNullException ("machineName");
+ string[] catnames = GetCategoryNames (machineName);
+ PerformanceCounterCategory[] cats = new PerformanceCounterCategory [catnames.Length];
+ for (int i = 0; i < catnames.Length; ++i)
+ cats [i] = new PerformanceCounterCategory (catnames [i], machineName);
+ return cats;
}
- [MonoTODO]
public PerformanceCounter[] GetCounters ()
{
- throw new NotImplementedException ();
+ return GetCounters ("");
}
- [MonoTODO]
public PerformanceCounter[] GetCounters (string instanceName)
{
- throw new NotImplementedException ();
+ string[] countnames = GetCounterNames (categoryName, machineName);
+ PerformanceCounter[] counters = new PerformanceCounter [countnames.Length];
+ for (int i = 0; i < countnames.Length; ++i) {
+ counters [i] = new PerformanceCounter (categoryName, countnames [i], instanceName, machineName);
+ }
+ return counters;
}
- [MonoTODO]
public string[] GetInstanceNames ()
{
- throw new NotImplementedException ();
+ return GetInstanceNames (categoryName, machineName);
}
- [MonoTODO]
public bool InstanceExists (string instanceName)
{
- throw new NotImplementedException ();
+ return InstanceExists (instanceName, categoryName, machineName);
}
- [MonoTODO]
- public static bool InstanceExists (string instanceName,
- string categoryName)
+ public static bool InstanceExists (string instanceName, string categoryName)
{
- throw new NotImplementedException ();
+ return InstanceExists (instanceName, categoryName, ".");
}
- [MonoTODO]
- public static bool InstanceExists (string instanceName,
- string categoryName,
- string machineName)
+ public static bool InstanceExists (string instanceName, string categoryName, string machineName)
{
- throw new NotImplementedException ();
+ if (instanceName == null)
+ throw new ArgumentNullException ("instanceName");
+ CheckCategory (categoryName);
+ if (machineName == null)
+ throw new ArgumentNullException ("machineName");
+ int val = InstanceExistsInternal (instanceName, categoryName, machineName);
+ if (val == 0)
+ return false;
+ if (val == 1)
+ return true;
+ throw new InvalidOperationException ();
}
[MonoTODO]
projects / mono.git / blobdiff