static void Main(string[] args)
{
//Represents the scoop for management operations
ManagementScope ms = new ManagementScope();
//Provides a wrapper for building paths to WMI objects
//Here we connect to the namespace called "CIMV2"
ManagementPath path = new ManagementPath(@"\localhostrootCIMV2");
//Represents a CIM management class
ManagementClass newClass = new ManagementClass(path);
//Provides a base class for query and enumeration-related options objects
EnumerationOptions options = new EnumerationOptions();
//Return class members that are immediately related to the class
options.EnumerateDeep = false;
//Retrieve the subclasses using the specified options
foreach (ManagementObject o in newClass.GetSubclasses(options))
{
Console.WriteLine(Convert.ToString(o["__Class"]));
}
Console.ReadLine();
}
public static void Main()
{
ManagementClass c =
new ManagementClass("CIM_LogicalDisk");
foreach (ManagementClass r in c.GetSubclasses())
{
Console.WriteLine(
"Instances of {0} are sub-classes",
r["__CLASS"]);
}
foreach (ManagementClass r in c.GetRelationshipClasses())
{
Console.WriteLine(
"{0} is a relationship class to " +
c.ClassPath.ClassName,
r["__CLASS"]);
foreach (ManagementClass related in c.GetRelatedClasses(
null, r.ClassPath.ClassName,
"Association", null, null, null, null))
{
Console.WriteLine(
"{0} is related to " + c.ClassPath.ClassName,
related.ClassPath.ClassName);
}
}
return;
}
}//ManagementSelectQuery
///<summary>LocalRootNamespacesClasses</summary>
///<remarks>Willy Denoyette [MVP] http://www.msdn.microsoft.com/newsgroups/default.aspx?pg=184&guid=&sloc=en-us&dg=microsoft.public.dotnet.languages.csharp&fltr=</remarks>
public static void LocalRootNamespacesClasses()
{
HttpContext httpContext = HttpContext.Current;
string cimRoot = "root\\";
string exceptionMessage = null;
EnumerationOptions enumerationOptions;
ManagementClass managementClass;
ManagementClass managementClassSub;
ManagementObjectCollection managementObjectCollection;
try
{
managementClass = new ManagementClass
(
new ManagementScope(@"root"),
new ManagementPath("__namespace"),
null
);
enumerationOptions = new EnumerationOptions();
enumerationOptions.EnumerateDeep = true; // set to false if only the root classes are needed
foreach ( ManagementObject managementObject in managementClass.GetInstances() )
{
System.Console.WriteLine(cimRoot + managementObject["Name"].ToString());
managementClassSub = new ManagementClass
(
cimRoot + managementObject["Name"].ToString()
);
managementObjectCollection = managementClassSub.GetSubclasses( enumerationOptions );
foreach( ManagementObject managementObjectSub in managementObjectCollection )
{
if ( managementObjectSub["__SuperClass"] == null )
{
System.Console.WriteLine( managementObjectSub["__Class"] ) ;
}//if ( managementObjectSub["__SuperClass"] == null )
else
{
System.Console.WriteLine( "\t" + managementObjectSub["__Class"] );
}
}//foreach( ManagementObject managementObjectSub in managementObjectCollection )
}//foreach ( ManagementObject managementObject in managementClass.GetInstances() )
}//try
catch( System.Exception exception )
{
exceptionMessage = "System.Exception" + exception.Message;
}
#if ( DEBUG )
if ( httpContext == null )
{
System.Console.WriteLine( exceptionMessage );
}//if ( httpContext == null )
else
{
httpContext.Response.Write( exceptionMessage );
}//else if ( httpContext == null )
#endif
}//public static void LocalRootNamespacesClasses()
private static EventSchema GetMofFromWbem(ManagementClass parent, EventKey eventKey)
{
if (parent == null)
{
return(null);
}
EventSchema eventSchema = null;
foreach (ManagementClass subclass in parent.GetSubclasses())
{
if (MatchEventType(subclass, eventKey.Type))
{
eventSchema = new EventSchema();
eventSchema.ManagementClass = subclass;
eventSchema.WmiDataTypes = GetMofTypes(subclass);
mofCollection.Add(eventKey, eventSchema);
}
else
{
eventSchema = GetMofFromWbem(subclass, eventKey);
}
if (eventSchema != null)
{
return(eventSchema);
}
}
return(eventSchema);
}
private static void FindGuid(ManagementClass managementClass)
{
QualifierDataCollection.QualifierDataEnumerator enumerator = managementClass.Qualifiers.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
QualifierData current = enumerator.Current;
if (current.Name.Equals("Guid", StringComparison.Ordinal))
{
Guid key = new Guid((string)current.Value);
if (GuidLookupTable.ContainsKey(key))
{
if (!managementClass.ClassPath.ToString().EndsWith("_V0", StringComparison.OrdinalIgnoreCase))
{
GuidLookupTable[key] = managementClass;
}
}
else
{
GuidLookupTable.Add(key, managementClass);
}
}
}
}
finally
{
(enumerator as IDisposable)?.Dispose();
}
foreach (ManagementClass subclass in managementClass.GetSubclasses())
{
FindGuid(subclass);
}
}
/// <summary>
/// Get List of classes
/// </summary>
/// <returns></returns>
public ModelWMIClasses GetListOfClasses()
{
ModelWMIClasses objData = new ModelWMIClasses();
ManagementClass wmiclass = new ManagementClass(this.MgmntScope.Path);
//Provides a base class for query and enumeration-related options objects
EnumerationOptions options = new EnumerationOptions();
//Return class members that are immediately related to the class
options.EnumerateDeep = false;
//Retrieve the sbuclasses using the specified options
foreach (ManagementObject mgmtObj in wmiclass.GetSubclasses(options))
{
ModelWMIClass objClass = new ModelWMIClass();
objClass.ClassName = mgmtObj.ClassPath.ClassName;
foreach (PropertyData prop in mgmtObj.Properties)
{
ModelWMIProperty objProp = new ModelWMIProperty();
objProp.Name = prop.Name;
objProp.CimType = prop.Type;
objClass.Properties.Add(objProp);
}
}
return(objData);
}
private static void AddClassNames(ManagementClass manClass, IList list)
{
var className = manClass.ClassPath.ClassName;
list.Add(className);
var objects = manClass.GetSubclasses();
foreach (ManagementClass subClass in objects)
{
AddClassNames(subClass, list);
}
}
public IEnumerable <ITreeNode> GetChildren(bool refresh)
{
var manClass = new ManagementClass(_scope.Path);
var objects = manClass.GetSubclasses();
var list = new List <ITreeNode>();
foreach (ManagementClass subClass in objects)
{
ITreeNode treeNode = new WmiClass(subClass);
list.Add(treeNode);
}
return(list.OrderBy(n => n.Name));
}
public static int Main(string[] args)
{
ManagementClass process = new ManagementClass("cim_process");
foreach (ManagementClass processSubClass in process.GetSubclasses())
{
Console.WriteLine("Name of subclass is " + processSubClass.ClassPath);
}
foreach (ManagementObject processInstance in process.GetInstances())
{
Console.WriteLine("Name of instance is " + processInstance.Path.RelativePath);
}
return(0);
}
public static void Main(string[] args)
{
ManagementClass c = new ManagementClass("Win32_PerfRawData");
foreach (ManagementClass mc in c.GetSubclasses())
{
Console.WriteLine("Class: {0}", mc["__CLASS"]);
foreach (PropertyData pd in mc.Properties)
{
try {
PerfCounterType ct = (PerfCounterType)ulong.Parse(
mc.GetPropertyQualifierValue(pd.Name, "CounterType").ToString());
Console.WriteLine(" {0} : {1}", pd.Name, ct);
} catch (Exception e) {}
}
Console.WriteLine();
}
}
/// <summary>
/// Targets the specified namespace on a specified computer, and scavenges it for all classes, if the bool is set to true. If false, it is used to setup the ManagementPath which
/// consists of the specified system and specified namespace
/// </summary>
/// <param name="pNamespace"></param>
/// <param name="pHostName"></param>
public WmiInformationGatherer(string pNamespace, string pHostName, bool pScavenge)
{
mRemoteWmiPath = new ManagementPath(@"\\" + pHostName + @"\root\" + pNamespace);
if (pScavenge)
{
try
{
ManagementClass managementClass = new ManagementClass(mRemoteWmiPath);
EnumerationOptions scavengeOptions = new EnumerationOptions();
scavengeOptions.EnumerateDeep = false;
WmiResults = new WmiResult(pHostName);
WmiResults.PopulateClassesList(managementClass.GetSubclasses());
}
catch (Exception e)
{
WmiResults.WmiError = e;
}
}
}
/// <summary>
/// Returns true if classObj has non-abstract subclasses (with deep enumeration)
/// </summary>
/// <param name="classObj"> </param>
static public bool HasNonAbstractChildren(ManagementClass classObj)
{
GetSubclassesOptions opts = new GetSubclassesOptions(null, //context
TimeSpan.MaxValue, //timeout
50, //block size
false, //rewindable
true, //return immediately
false, //amended
true); //deep
ManagementObjectCollection subClasses = classObj.GetSubclasses(opts);
ManagementObjectCollection.ManagementObjectEnumerator childEnum = subClasses.GetEnumerator();
while (childEnum.MoveNext())
{
ManagementClass curChild = (ManagementClass)childEnum.Current;
if (!WmiHelper.IsAbstract(curChild))
{
return(true);
}
}
return(false);
}
