mirror of https://github.com/dahall/Vanara.git
946 lines
40 KiB
C#
946 lines
40 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Vanara.Collections;
|
|
using Vanara.Extensions;
|
|
using Vanara.InteropServices;
|
|
using Vanara.PInvoke;
|
|
using static Vanara.PInvoke.SetupAPI;
|
|
|
|
namespace Vanara.Diagnostics
|
|
{
|
|
/// <summary>A dictionary of properties.</summary>
|
|
/// <typeparam name="TKey">The type of the key.</typeparam>
|
|
/// <typeparam name="TValue">The type of the value.</typeparam>
|
|
/// <seealso cref="System.Collections.Generic.IDictionary{TKey, TValue}"/>
|
|
public interface IPropertyProvider<TKey, TValue> : IDictionary<TKey, TValue>
|
|
{
|
|
}
|
|
|
|
/// <summary>Extension methods for SetupAPI functions and structs.</summary>
|
|
public static class DeviceExtensions
|
|
{
|
|
/// <summary>
|
|
/// Trys to get friendly name for the property key. If not available via <c>PSGetNameFromPropertyKey</c>, then the name of the
|
|
/// defined field is returned (i.e. "DEVPKEY_Device_Class"). If not available, then the Guid and ID are returned.
|
|
/// </summary>
|
|
/// <param name="propKey">The property key.</param>
|
|
/// <returns>The best string representation available.</returns>
|
|
public static string LookupName(this DEVPROPKEY propKey)
|
|
{
|
|
if (PropSys.PSGetNameFromPropertyKey(new Ole32.PROPERTYKEY(propKey.fmtid, propKey.pid), out var str).Succeeded)
|
|
return str;
|
|
return LookupField(propKey)?.Name ?? $"{propKey.fmtid:B}[{propKey.pid}]";
|
|
}
|
|
|
|
internal static IEnumerable<Type> GetCorrespondingTypes(this DEVPROPKEY propKey)
|
|
{
|
|
var fi = LookupField(propKey);
|
|
if (fi is null) return Enumerable.Empty<Type>();
|
|
return fi.GetCustomAttributes<CorrespondingTypeAttribute>().Select(a => a.TypeRef);
|
|
}
|
|
|
|
internal static System.Reflection.FieldInfo LookupField(this DEVPROPKEY propKey) =>
|
|
typeof(SetupAPI).GetFields(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public).
|
|
Where(fi => fi.FieldType == typeof(DEVPROPKEY) && fi.Name.StartsWith("DEVPKEY") && propKey.Equals((DEVPROPKEY)fi.GetValue(null))).FirstOrDefault();
|
|
}
|
|
|
|
/// <summary>A class that represents a device on a machine.</summary>
|
|
public class Device : IDisposable
|
|
{
|
|
private readonly SafeHDEVINFO hdi;
|
|
private readonly Lazy<SP_DEVINSTALL_PARAMS> instParam;
|
|
private readonly Lazy<string> name, desc, instId;
|
|
private SP_DEVINFO_DATA data;
|
|
private DeviceProperties props;
|
|
private DeviceRegProperties rprops;
|
|
|
|
internal Device(SafeHDEVINFO hdi, SP_DEVINFO_DATA data)
|
|
{
|
|
this.hdi = hdi;
|
|
this.data = data;
|
|
name = new Lazy<string>(() => Properties[DEVPKEY_NAME]?.ToString() ?? "");
|
|
desc = new Lazy<string>(() => RegistryProperties[SPDRP.SPDRP_DEVICEDESC]?.ToString() ?? "");
|
|
instId = new Lazy<string>(() => Properties[DEVPKEY_Device_InstanceId]?.ToString() ?? "");
|
|
instParam = new Lazy<SP_DEVINSTALL_PARAMS>(GetInstallParams);
|
|
}
|
|
|
|
/// <summary>The GUID of the device's setup class.</summary>
|
|
public Guid ClassGuid => data.ClassGuid;
|
|
|
|
/// <summary>Gets the data the identifies the device.</summary>
|
|
/// <value>A SP_DEVINFO_DATA structure with identifying device information.</value>
|
|
public SP_DEVINFO_DATA Data => data;
|
|
|
|
/// <summary>The description of the device instance.</summary>
|
|
/// <value>The description.</value>
|
|
public string Description => desc.Value;
|
|
|
|
/// <summary>Gets the driver path.</summary>
|
|
public string DriverPath => instParam.Value.DriverPath;
|
|
|
|
/// <summary>Gets the handle to the device.</summary>
|
|
/// <value>A HDEVINFO handle.</value>
|
|
public HDEVINFO Handle => hdi;
|
|
|
|
/// <summary>
|
|
/// Gets the flags that control installation and user interface operations. Some flags can be set before sending the device
|
|
/// installation request while other flags are set automatically during the processing of some requests.
|
|
/// </summary>
|
|
public DI_FLAGS InstallFlags => instParam.Value.Flags;
|
|
|
|
/// <summary>
|
|
/// Gets additional flags that provide control over installation and user interface operations. Some flags can be set before calling
|
|
/// the device installer functions while other flags are set automatically during the processing of some functions.
|
|
/// </summary>
|
|
public DI_FLAGSEX InstallFlagsEx => instParam.Value.FlagsEx;
|
|
|
|
/// <summary>The instance identifier of the device instance.</summary>
|
|
/// <value>The instance identifier.</value>
|
|
public string InstanceId => instId.Value;
|
|
|
|
/// <summary>
|
|
/// A string that contains the name of the remote computer. If the device information set is for the local computer, this member is
|
|
/// <see langword="null"/>.
|
|
/// </summary>
|
|
public string MachineName => hdi.MachineName;
|
|
|
|
/// <summary>The name of the device instance.</summary>
|
|
/// <value>The name.</value>
|
|
public string Name => name.Value;
|
|
|
|
/// <summary>Gets a dictionary of properties.</summary>
|
|
/// <value>The properties.</value>
|
|
public IPropertyProvider<DEVPROPKEY, object> Properties =>
|
|
props ??= (MachineName is null ? new DeviceProperties(this) : throw new InvalidOperationException("Properties cannot be retrieved for remote devices."));
|
|
|
|
/// <summary>Gets a dictionary of registry properties.</summary>
|
|
/// <value>The registry properties.</value>
|
|
public IPropertyProvider<SPDRP, object> RegistryProperties =>
|
|
rprops ??= (MachineName is null ? new DeviceRegProperties(this) : throw new InvalidOperationException("Properties cannot be retrieved for remote devices."));
|
|
|
|
/// <inheritdoc/>
|
|
public void Dispose() { }
|
|
|
|
/// <summary>Retrieves a specified custom device property from the registry.</summary>
|
|
/// <param name="propName">A registry value name representing a custom property.</param>
|
|
/// <param name="combine">
|
|
/// If <see langword="true"/>, the function retrieves both device instance-specific property values and hardware ID-specific
|
|
/// property values, concatenated as a REG_MULTI_SZ-typed string.
|
|
/// </param>
|
|
/// <returns>The requested property information or <see langword="null"/> if the property does not exist.</returns>
|
|
public object GetCustomProperty(string propName, bool combine = false)
|
|
{
|
|
if (!SetupDiGetCustomDeviceProperty(hdi, data, propName, combine ? DICUSTOMDEVPROP.DICUSTOMDEVPROP_MERGE_MULTISZ : 0, out _, default, 0, out var bufSz) &&
|
|
Win32Error.GetLastError() == Win32Error.ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
using var mem = new SafeCoTaskMemHandle(bufSz);
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiGetCustomDeviceProperty(hdi, data, propName, combine ? DICUSTOMDEVPROP.DICUSTOMDEVPROP_MERGE_MULTISZ : 0, out var regType, mem, mem.Size, out bufSz));
|
|
return DeviceClass.DeviceClassRegProperties.GetRegValue(mem, regType);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Retrieves an icon for this device.</summary>
|
|
/// <param name="iconSize">
|
|
/// The size, in pixels, of the icon to be retrieved. Use the system metric index SM_CXICON to specify a default-sized icon or use
|
|
/// the system metric index SM_CXSMICON to specify a small icon.
|
|
/// </param>
|
|
/// <returns>A safe handle to the icon that this function retrieves.</returns>
|
|
/// <remarks>
|
|
/// <para><c>GetIcon</c> attempts to retrieve an icon for the device as follows:</para>
|
|
/// <list type="bullet">
|
|
/// <item>
|
|
/// <term>
|
|
/// If the DEVPKEY_DrvPkg_Icon device property of the device includes a list of resource-identifier strings, the function attempts
|
|
/// to retrieve the icon that is specified by the first resource-identifier string in the list.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>
|
|
/// If the function cannot retrieve a device-specific icon, it will then attempt to retrieve the class icon for the device. For
|
|
/// information about class icons, see SetupDiLoadClassIcon.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>
|
|
/// If the function cannot retrieve the class icon for the device, it will then attempt to retrieve the icon for the Unknown device
|
|
/// setup class, where the icon for the Unknown device setup class includes the image of a question mark (?).
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </remarks>
|
|
public User32.SafeHICON GetIcon(System.Drawing.Size iconSize)
|
|
{
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiLoadDeviceIcon(hdi, data, (uint)iconSize.Width, (uint)iconSize.Height, 0, out var hIcon));
|
|
return new User32.SafeHICON((IntPtr)hIcon);
|
|
}
|
|
|
|
private SP_DEVINSTALL_PARAMS GetInstallParams()
|
|
{
|
|
var p = StructHelper.InitWithSize<SP_DEVINSTALL_PARAMS>();
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiGetDeviceInstallParams(hdi, data, ref p));
|
|
return p;
|
|
}
|
|
|
|
/// <summary>Accesses properties with a device.</summary>
|
|
public class DeviceProperties : VirtualDictionary<DEVPROPKEY, object>, IPropertyProvider<DEVPROPKEY, object>
|
|
{
|
|
private readonly Device parent;
|
|
|
|
internal DeviceProperties(Device dev) : base(false) => parent = dev;
|
|
|
|
private DeviceProperties() : base(false) => throw new InvalidOperationException();
|
|
|
|
/// <inheritdoc/>
|
|
public override int Count
|
|
{
|
|
get
|
|
{
|
|
SetupDiGetDevicePropertyKeys(parent.hdi, parent.data, null, 0, out var cnt);
|
|
Win32Error.ThrowLastErrorUnless(Win32Error.ERROR_INSUFFICIENT_BUFFER);
|
|
return (int)cnt;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public override ICollection<DEVPROPKEY> Keys
|
|
{
|
|
get
|
|
{
|
|
SetupDiGetDevicePropertyKeys(parent.hdi, parent.data, null, 0, out var cnt);
|
|
Win32Error.ThrowLastErrorUnless(Win32Error.ERROR_INSUFFICIENT_BUFFER);
|
|
var propKeys = new DEVPROPKEY[(int)cnt];
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiGetDevicePropertyKeys(parent.hdi, parent.data, propKeys, cnt, out _));
|
|
return propKeys;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Remove(DEVPROPKEY key) =>
|
|
SetupDiSetDeviceProperty(parent.hdi, parent.data, key, 0, default, 0);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool TryGetValue(DEVPROPKEY key, out object value) => GetValue(key, out value).Succeeded;
|
|
|
|
/// <inheritdoc/>
|
|
protected override void SetValue(DEVPROPKEY key, object value)
|
|
{
|
|
value = DeviceClass.DeviceClassProperties.CommonPropConv(value);
|
|
var type = GetPropType(key, value?.GetType());
|
|
var mem = DeviceClass.DeviceClassProperties.PrepValue(value, type);
|
|
try
|
|
{
|
|
if (mem is null)
|
|
throw new ArgumentException("Unable to convert object to property type.", nameof(value));
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiSetDeviceProperty(parent.hdi, parent.data, key, type, mem.DangerousGetHandle(), mem.Size));
|
|
}
|
|
finally
|
|
{
|
|
mem?.Dispose();
|
|
}
|
|
}
|
|
|
|
private DEVPROPTYPE GetPropType(DEVPROPKEY propKey, Type valType)
|
|
{
|
|
if (SetupDiGetDeviceProperty(parent.hdi, parent.data, propKey, out var type, default, default, out _))
|
|
return type;
|
|
var fi = typeof(DEVPROPTYPE).GetFields().Where(fi => fi.IsLiteral && fi.GetCustomAttributes<CorrespondingTypeAttribute>(false, a => a.TypeRef == valType).Any()).FirstOrDefault();
|
|
return fi is not null ? (DEVPROPTYPE)fi.GetValue(null) : throw new ArgumentException("Unable to determine DEVPROPTYPE.");
|
|
}
|
|
|
|
private Win32Error GetValue(in DEVPROPKEY propKey, out object value)
|
|
{
|
|
value = null;
|
|
if (!SetupDiGetDeviceProperty(parent.hdi, parent.data, propKey, out _, default, 0, out var bufSz))
|
|
{
|
|
var err = Win32Error.GetLastError();
|
|
if (err != Win32Error.ERROR_INSUFFICIENT_BUFFER)
|
|
return err;
|
|
using var mem = new SafeCoTaskMemHandle(bufSz);
|
|
if (!SetupDiGetDeviceProperty(parent.hdi, parent.data, propKey, out var propType, mem, mem.Size, out bufSz))
|
|
return Win32Error.GetLastError();
|
|
value = SetupDiPropertyToManagedObject(mem, propType, propKey.GetCorrespondingTypes().FirstOrDefault());
|
|
}
|
|
return Win32Error.ERROR_SUCCESS;
|
|
}
|
|
}
|
|
|
|
/// <summary>Accesses registry properties with a device class.</summary>
|
|
public class DeviceRegProperties : VirtualDictionary<SPDRP, object>, IPropertyProvider<SPDRP, object>
|
|
{
|
|
private readonly Device parent;
|
|
|
|
internal DeviceRegProperties(Device dev) : base(false) => parent = dev;
|
|
|
|
private DeviceRegProperties() : base(false) => throw new InvalidOperationException();
|
|
|
|
/// <inheritdoc/>
|
|
public override int Count => Enum.GetValues(typeof(SPDRP)).Length;
|
|
|
|
/// <inheritdoc/>
|
|
public override ICollection<SPDRP> Keys => (ICollection<SPDRP>)Enum.GetValues(typeof(SPDRP));
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Remove(SPDRP key) => SetupDiSetDeviceRegistryProperty(parent.hdi, ref parent.data, key, default, 0);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool TryGetValue(SPDRP key, out object value) => GetValue(key, out value).Succeeded;
|
|
|
|
/// <inheritdoc/>
|
|
protected override void SetValue(SPDRP key, object value)
|
|
{
|
|
if (value is null)
|
|
throw new ArgumentNullException(nameof(value));
|
|
value = DeviceClass.DeviceClassRegProperties.CommonPropConv(value);
|
|
if (!CorrespondingTypeAttribute.CanSet(key, value.GetType()))
|
|
throw new ArgumentException("Value type not valid for key.");
|
|
SafeAllocatedMemoryHandle mem = value switch
|
|
{
|
|
var v when v.GetType().IsValueType && !v.GetType().IsEnum => SafeCoTaskMemHandle.CreateFromStructure(value),
|
|
var v when v.GetType().IsValueType && v.GetType().IsEnum => SafeCoTaskMemHandle.CreateFromStructure((uint)value),
|
|
IEnumerable<string> ies => SafeCoTaskMemHandle.CreateFromStringList(ies),
|
|
byte[] ba => new SafeCoTaskMemHandle(ba),
|
|
string s => new SafeCoTaskMemString(s, System.Runtime.InteropServices.CharSet.Auto),
|
|
_ => throw new ArgumentException("Unable to convert object to property type.", nameof(value))
|
|
};
|
|
try
|
|
{
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiSetDeviceRegistryProperty(parent.hdi, ref parent.data, key, mem.DangerousGetHandle(), mem.Size));
|
|
}
|
|
finally
|
|
{
|
|
mem?.Dispose();
|
|
}
|
|
}
|
|
|
|
private Win32Error GetValue(SPDRP propKey, out object value)
|
|
{
|
|
value = null;
|
|
if (!SetupDiGetDeviceRegistryProperty(parent.hdi, parent.data, propKey, out _, default, 0, out var bufSz))
|
|
{
|
|
if (bufSz == 0)
|
|
return Win32Error.ERROR_NOT_FOUND;
|
|
using var mem = new SafeCoTaskMemHandle(bufSz);
|
|
if (!SetupDiGetDeviceRegistryProperty(parent.hdi, parent.data, propKey, out var propType, mem, mem.Size, out bufSz))
|
|
return Win32Error.GetLastError();
|
|
value = DeviceClass.DeviceClassRegProperties.GetRegValue(propKey, mem, propType);
|
|
}
|
|
return Win32Error.ERROR_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>A class that provides detail about a device setup class available on a machine.</summary>
|
|
/// <remarks>
|
|
/// Device setup classes provide a mechanism for grouping devices that are installed and configured in the same way. A setup class
|
|
/// identifies the class installer and class co-installers that are involved in installing the devices that belong to the class. For
|
|
/// example, all CD-ROM drives belong to the CDROM setup class and will use the same co-installer when installed.
|
|
/// </remarks>
|
|
public class DeviceClass : IDisposable
|
|
{
|
|
private static readonly Dictionary<string, SP_CLASSIMAGELIST_DATA> imgListData = new();
|
|
#pragma warning disable IDE0052 // Remove unread private members
|
|
private static readonly FinalizeImgLists imgListFinalizer = new();
|
|
#pragma warning restore IDE0052 // Remove unread private members
|
|
private readonly Lazy<int?> bmpIdx, imgIdx;
|
|
private readonly Lazy<string> name, desc;
|
|
private DeviceClassProperties props;
|
|
private DeviceClassRegProperties rprops;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="DeviceClass"/> class with its GUID and optional machine name.</summary>
|
|
/// <param name="guid">The GUID for the device setup class.</param>
|
|
/// <param name="machineName">
|
|
/// The name of the machine on which devices are managed. <see langword="null"/> indicates the local machine.
|
|
/// </param>
|
|
public DeviceClass(Guid guid, string machineName = null)
|
|
{
|
|
Guid = guid;
|
|
MachineName = machineName;
|
|
name = new Lazy<string>(() => GetClassString(SetupDiClassNameFromGuidEx, 32));
|
|
desc = new Lazy<string>(() => GetClassString(SetupDiGetClassDescriptionEx, 256));
|
|
bmpIdx = new Lazy<int?>(() => SetupDiGetClassBitmapIndex(Guid, out var idx) ? idx : null);
|
|
imgIdx = new Lazy<int?>(() => SetupDiGetClassImageIndex(GetImageList(), Guid, out var idx) ? idx : null);
|
|
}
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="DeviceClass"/> class from its class name and optional machine name.</summary>
|
|
/// <param name="name">The name of the class.</param>
|
|
/// <param name="machineName">
|
|
/// The name of the machine on which devices are managed. <see langword="null"/> indicates the local machine.
|
|
/// </param>
|
|
public DeviceClass(string name, string machineName = null) : this(FromName(name, machineName), machineName)
|
|
{
|
|
}
|
|
|
|
private delegate bool GetClassStringDelegate(in Guid ClassGuid, StringBuilder ClassName, uint ClassNameSize, out uint RequiredSize,
|
|
string MachineName, IntPtr Reserved = default);
|
|
|
|
/// <summary>Gets the index of the mini-icon supplied for this class.</summary>
|
|
/// <value>The index of the mini-icon supplied for this class.</value>
|
|
public int? BitmapIndex => bmpIdx.Value;
|
|
|
|
/// <summary>Gets the class description associated with the specified setup class GUID.</summary>
|
|
/// <value>The class description associated with the specified setup class GUID.</value>
|
|
/// <remarks>
|
|
/// If there is a friendly name in the registry key for the class, this routine returns the friendly name. Otherwise, this routine
|
|
/// returns the class name.
|
|
/// </remarks>
|
|
public string Description => desc.Value;
|
|
|
|
/// <summary>Gets the GUID for this setup class.</summary>
|
|
/// <value>The GUID for this setup class.</value>
|
|
public Guid Guid { get; }
|
|
|
|
/// <summary>Gets the index within the class image list.</summary>
|
|
/// <value>The index within the class image list.</value>
|
|
public int? ImageIndex => imgIdx.Value;
|
|
|
|
/// <summary>Gets the image list of bitmaps for every class installed on this system.</summary>
|
|
/// <value>The image list handle of bitmaps for every class installed on this system.</value>
|
|
public HIMAGELIST ImageListHandle => GetImageList().ImageList;
|
|
|
|
/// <summary>Gets the name of the machine on which devices are managed. <see langword="null"/> indicates the local machine.</summary>
|
|
/// <value>The machine name for this manager.</value>
|
|
public string MachineName { get; }
|
|
|
|
/// <summary>Gets the class name associated with a class GUID.</summary>
|
|
/// <value>The class name associated with a class GUID.</value>
|
|
public string Name => name.Value;
|
|
|
|
/// <summary>Gets a value that controls whether devices in this setup class are displayed by the Device Manager.</summary>
|
|
public bool? NoDisplay => (bool?)Properties[DEVPKEY_DeviceClass_NoDisplayClass];
|
|
|
|
/// <summary>Gets a value that controls whether devices in this device setup class are displayed in the <c>Add Hardware Wizard</c>.</summary>
|
|
public bool? NoInstall => (bool?)Properties[DEVPKEY_DeviceClass_NoInstallClass];
|
|
|
|
/// <summary>Gets a dictionary of properties.</summary>
|
|
/// <value>The properties.</value>
|
|
public IPropertyProvider<DEVPROPKEY, object> Properties => props ??= new DeviceClassProperties(Guid, MachineName);
|
|
|
|
/// <summary>Gets a dictionary of registry properties.</summary>
|
|
/// <value>The registry properties.</value>
|
|
public IPropertyProvider<SPCRP, object> RegistryProperties => rprops ??= new DeviceClassRegProperties(Guid, MachineName);
|
|
|
|
/// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
/// <summary>Gets the devices associated with this device class.</summary>
|
|
/// <returns>A sequence of <see cref="Device"/> instances with this device class.</returns>
|
|
public IEnumerable<Device> GetDevices() => new DeviceCollection(Guid, null, MachineName);
|
|
|
|
private static Guid FromName(string name, string machine)
|
|
{
|
|
SetupDiClassGuidsFromNameEx(name, null, 0, out var len, machine);
|
|
if (len == 0) Win32Error.ThrowLastError();
|
|
var guids = new Guid[(int)len];
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiClassGuidsFromNameEx(name, guids, len, out _, machine));
|
|
return guids[0];
|
|
}
|
|
|
|
private string GetClassString(GetClassStringDelegate f, uint initSz)
|
|
{
|
|
var sz = initSz;
|
|
var sb = new StringBuilder((int)sz);
|
|
if (!f(Guid, sb, sz, out sz, MachineName))
|
|
{
|
|
Win32Error.ThrowLastErrorUnless(Win32Error.ERROR_INSUFFICIENT_BUFFER);
|
|
sb.Capacity = (int)sz;
|
|
Win32Error.ThrowLastErrorIfFalse(f(Guid, sb, sz, out _, MachineName));
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private SP_CLASSIMAGELIST_DATA GetImageList()
|
|
{
|
|
if (!imgListData.TryGetValue(MachineName ?? "", out var data))
|
|
{
|
|
data = StructHelper.InitWithSize<SP_CLASSIMAGELIST_DATA>();
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiGetClassImageListEx(ref data, MachineName));
|
|
imgListData.Add(MachineName ?? "", data);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/// <summary>Accesses properties with a device class.</summary>
|
|
public class DeviceClassProperties : VirtualDictionary<DEVPROPKEY, object>, IPropertyProvider<DEVPROPKEY, object>
|
|
{
|
|
private readonly Guid Guid;
|
|
|
|
private readonly string MachineName;
|
|
|
|
internal DeviceClassProperties(Guid guid, string machineName) : base(false)
|
|
{
|
|
Guid = guid;
|
|
MachineName = machineName;
|
|
}
|
|
|
|
private DeviceClassProperties() : base(false) => throw new InvalidOperationException();
|
|
|
|
/// <inheritdoc/>
|
|
public override int Count
|
|
{
|
|
get
|
|
{
|
|
SetupDiGetClassPropertyKeysEx(Guid, null, 0, out var cnt, DICLASSPROP.DICLASSPROP_INSTALLER, MachineName);
|
|
Win32Error.ThrowLastErrorUnless(Win32Error.ERROR_INSUFFICIENT_BUFFER);
|
|
return (int)cnt;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public override ICollection<DEVPROPKEY> Keys
|
|
{
|
|
get
|
|
{
|
|
SetupDiGetClassPropertyKeysEx(Guid, null, 0, out var cnt, DICLASSPROP.DICLASSPROP_INSTALLER, MachineName);
|
|
Win32Error.ThrowLastErrorUnless(Win32Error.ERROR_INSUFFICIENT_BUFFER);
|
|
var propKeys = new DEVPROPKEY[(int)cnt];
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiGetClassPropertyKeysEx(Guid, propKeys, cnt, out _, DICLASSPROP.DICLASSPROP_INSTALLER, MachineName));
|
|
return propKeys;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Remove(DEVPROPKEY key) =>
|
|
SetupDiSetClassPropertyEx(Guid, key, 0, default, 0, DICLASSPROP.DICLASSPROP_INSTALLER, MachineName);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool TryGetValue(DEVPROPKEY key, out object value) => GetValue(key, out value).Succeeded;
|
|
|
|
internal static object CommonPropConv(object value) => value switch
|
|
{
|
|
bool b => (BOOLEAN)b,
|
|
DateTime dt => dt.ToFileTimeStruct(),
|
|
decimal dec => new CY(dec),
|
|
ISafeMemoryHandle h => h.GetBytes(0, h.Size),
|
|
_ => value,
|
|
};
|
|
|
|
internal static ISafeMemoryHandle PrepValue(object value, DEVPROPTYPE type)
|
|
{
|
|
// Changes types that need conversion or quick outs
|
|
if (value is null)
|
|
return SafeCoTaskMemHandle.Null;
|
|
if (value is IEnumerable<string> sa && (type.IsFlagSet(DEVPROPTYPE.DEVPROP_TYPEMOD_LIST) && (type.IsFlagSet(DEVPROPTYPE.DEVPROP_TYPE_STRING) || type.IsFlagSet(DEVPROPTYPE.DEVPROP_TYPE_SECURITY_DESCRIPTOR_STRING))))
|
|
return SafeCoTaskMemHandle.CreateFromStringList(sa, StringListPackMethod.Concatenated, System.Runtime.InteropServices.CharSet.Unicode);
|
|
var valType = value.GetType();
|
|
|
|
// Validate type of property against supplied type
|
|
if (type.IsFlagSet(DEVPROPTYPE.DEVPROP_TYPEMOD_LIST))
|
|
throw new ArgumentException("Invalid list.", nameof(value));
|
|
if (type.IsFlagSet(DEVPROPTYPE.DEVPROP_TYPEMOD_ARRAY))
|
|
{
|
|
if (!valType.IsArray)
|
|
throw new ArgumentException("Array required.", nameof(value));
|
|
valType = valType.GetElementType();
|
|
type &= DEVPROPTYPE.DEVPROP_MASK_TYPE;
|
|
}
|
|
var cTypes = CorrespondingTypeAttribute.GetCorrespondingTypes(type & DEVPROPTYPE.DEVPROP_MASK_TYPE).ToArray();
|
|
if (cTypes.Length > 0 && Array.IndexOf(cTypes, valType) < 0)
|
|
throw new ArgumentException($"Value type or element type cannot be {valType.Name}", nameof(value));
|
|
|
|
// Push value into mem
|
|
switch (value)
|
|
{
|
|
case byte[] ba:
|
|
return new SafeCoTaskMemHandle(ba);
|
|
|
|
case string s:
|
|
return new SafeCoTaskMemHandle(s);
|
|
|
|
default:
|
|
var sz = InteropExtensions.SizeOf(valType);
|
|
if (valType.IsArray) sz *= ((Array)value).Length;
|
|
var mem = new SafeCoTaskMemHandle(sz);
|
|
mem.DangerousGetHandle().Write(value, 0, mem.Size);
|
|
return mem;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
protected override void SetValue(DEVPROPKEY key, object value)
|
|
{
|
|
value = CommonPropConv(value);
|
|
var type = GetPropType(key, value?.GetType());
|
|
var mem = PrepValue(value, type);
|
|
try
|
|
{
|
|
if (mem is null)
|
|
throw new ArgumentException("Unable to convert object to property type.", nameof(value));
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiSetClassPropertyEx(Guid, key, type, mem.DangerousGetHandle(), mem.Size, DICLASSPROP.DICLASSPROP_INSTALLER, MachineName));
|
|
}
|
|
finally
|
|
{
|
|
mem?.Dispose();
|
|
}
|
|
}
|
|
|
|
private DEVPROPTYPE GetPropType(DEVPROPKEY propKey, Type valType)
|
|
{
|
|
if (SetupDiGetClassPropertyEx(Guid, propKey, out var type, default, default, out _, DICLASSPROP.DICLASSPROP_INSTALLER, MachineName))
|
|
return type;
|
|
var fi = typeof(DEVPROPTYPE).GetFields().Where(fi => fi.IsLiteral && fi.GetCustomAttributes<CorrespondingTypeAttribute>(false, a => a.TypeRef == valType).Any()).FirstOrDefault();
|
|
return fi is not null ? (DEVPROPTYPE)fi.GetValue(null) : throw new ArgumentException("Unable to determine DEVPROPTYPE.");
|
|
}
|
|
|
|
private Win32Error GetValue(in DEVPROPKEY propKey, out object value)
|
|
{
|
|
value = null;
|
|
if (!SetupDiGetClassPropertyEx(Guid, propKey, out _, default, 0, out var bufSz, DICLASSPROP.DICLASSPROP_INSTALLER, MachineName))
|
|
{
|
|
var err = Win32Error.GetLastError();
|
|
if (err != Win32Error.ERROR_INSUFFICIENT_BUFFER)
|
|
return err;
|
|
using var mem = new SafeCoTaskMemHandle(bufSz);
|
|
if (!SetupDiGetClassPropertyEx(Guid, propKey, out var propType, mem, mem.Size, out bufSz, DICLASSPROP.DICLASSPROP_INSTALLER, MachineName))
|
|
return Win32Error.GetLastError();
|
|
value = SetupDiPropertyToManagedObject(mem, propType, propKey.GetCorrespondingTypes().FirstOrDefault());
|
|
}
|
|
return Win32Error.ERROR_SUCCESS;
|
|
}
|
|
}
|
|
|
|
/// <summary>Accesses registry properties with a device class.</summary>
|
|
public class DeviceClassRegProperties : VirtualDictionary<SPCRP, object>, IPropertyProvider<SPCRP, object>
|
|
{
|
|
private readonly Guid Guid;
|
|
|
|
private readonly string MachineName;
|
|
|
|
internal DeviceClassRegProperties(Guid guid, string machineName) : base(false)
|
|
{
|
|
Guid = guid;
|
|
MachineName = machineName;
|
|
}
|
|
|
|
private DeviceClassRegProperties() : base(false) => throw new InvalidOperationException();
|
|
|
|
/// <inheritdoc/>
|
|
public override int Count => Enum.GetValues(typeof(SPCRP)).Length;
|
|
|
|
/// <inheritdoc/>
|
|
public override ICollection<SPCRP> Keys => (ICollection<SPCRP>)Enum.GetValues(typeof(SPCRP));
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Remove(SPCRP key) => SetupDiSetClassRegistryProperty(Guid, key, default, 0, MachineName);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool TryGetValue(SPCRP key, out object value) => GetValue(key, out value).Succeeded;
|
|
|
|
internal static object CommonPropConv(object value) => value switch
|
|
{
|
|
bool b => (BOOL)b,
|
|
ISafeMemoryHandle h => h.GetBytes(0, h.Size),
|
|
_ => value,
|
|
};
|
|
|
|
internal static object GetRegValue<T>(T key, SafeAllocatedMemoryHandle mem, REG_VALUE_TYPE propType) where T : Enum =>
|
|
GetRegValue(mem, propType, CorrespondingTypeAttribute.GetCorrespondingTypes(key).FirstOrDefault());
|
|
|
|
internal static object GetRegValue(SafeAllocatedMemoryHandle mem, REG_VALUE_TYPE propType, Type cType = null) => propType switch
|
|
{
|
|
REG_VALUE_TYPE.REG_DWORD when cType is not null => ((IntPtr)mem).Convert(mem.Size, cType),
|
|
REG_VALUE_TYPE.REG_BINARY when cType is not null && cType != typeof(byte[]) => ((IntPtr)mem).Convert(mem.Size, cType),
|
|
_ => propType.GetValue(mem, mem.Size),
|
|
};
|
|
|
|
/// <inheritdoc/>
|
|
protected override void SetValue(SPCRP key, object value)
|
|
{
|
|
if (value is null)
|
|
throw new ArgumentNullException(nameof(value));
|
|
value = CommonPropConv(value);
|
|
if (!CorrespondingTypeAttribute.CanSet(key, value.GetType()))
|
|
throw new ArgumentException("Value type not valid for key.");
|
|
SafeAllocatedMemoryHandle mem = key switch
|
|
{
|
|
SPCRP.SPCRP_UPPERFILTERS => value is IEnumerable<string> uf ? SafeCoTaskMemHandle.CreateFromStringList(uf) : null,
|
|
SPCRP.SPCRP_LOWERFILTERS => value is IEnumerable<string> lf ? SafeCoTaskMemHandle.CreateFromStringList(lf) : null,
|
|
SPCRP.SPCRP_SECURITY => value is byte[] ba ? new SafeCoTaskMemHandle(ba) : null,
|
|
SPCRP.SPCRP_SECURITY_SDS => value is string s ? new SafeCoTaskMemString(s, System.Runtime.InteropServices.CharSet.Auto) : null,
|
|
SPCRP.SPCRP_DEVTYPE => value is FILE_DEVICE fd ? SafeCoTaskMemHandle.CreateFromStructure(fd) : null,
|
|
SPCRP.SPCRP_EXCLUSIVE => value is BOOL b ? SafeCoTaskMemHandle.CreateFromStructure(b) : null,
|
|
SPCRP.SPCRP_CHARACTERISTICS => value is uint u ? SafeCoTaskMemHandle.CreateFromStructure(u) : null,
|
|
_ => null,
|
|
};
|
|
try
|
|
{
|
|
if (mem is null)
|
|
throw new ArgumentException("Unable to convert object to property type.", nameof(value));
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiSetClassRegistryProperty(Guid, key, mem.DangerousGetHandle(), mem.Size, MachineName));
|
|
}
|
|
finally
|
|
{
|
|
mem?.Dispose();
|
|
}
|
|
}
|
|
|
|
private Win32Error GetValue(SPCRP propKey, out object value)
|
|
{
|
|
value = null;
|
|
if (!SetupDiGetClassRegistryProperty(Guid, propKey, out _, default, 0, out var bufSz, MachineName))
|
|
{
|
|
_ = Win32Error.GetLastError();
|
|
if (bufSz == 0)
|
|
return Win32Error.ERROR_NOT_FOUND;
|
|
using var mem = new SafeCoTaskMemHandle(bufSz);
|
|
if (!SetupDiGetClassRegistryProperty(Guid, propKey, out var propType, mem, mem.Size, out bufSz, MachineName))
|
|
return Win32Error.GetLastError();
|
|
value = GetRegValue(propKey, mem, propType);
|
|
}
|
|
return Win32Error.ERROR_SUCCESS;
|
|
}
|
|
}
|
|
|
|
private sealed class FinalizeImgLists
|
|
{
|
|
~FinalizeImgLists()
|
|
{
|
|
foreach (var val in imgListData.Values)
|
|
SetupDiDestroyClassImageList(val);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>A class that provides the collection of device setup classes available on a machine.</summary>
|
|
public class DeviceClassCollection : IReadOnlyCollection<DeviceClass>, IDisposable
|
|
{
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="DeviceClassCollection"/> class with the flags and machine name to be used by <see
|
|
/// cref="SetupDiBuildClassInfoListEx"/> to retrieve the classes.
|
|
/// </summary>
|
|
/// <param name="flags">
|
|
/// <para>
|
|
/// Flags used to control exclusion of classes from the list. If no flags are specified, all setup classes are included in the list.
|
|
/// Can be a combination of the following values:
|
|
/// </para>
|
|
/// <para>DIBCI_NOINSTALLCLASS</para>
|
|
/// <para>Exclude a class if it has the <c>NoInstallClass</c> value entry in its registry key.</para>
|
|
/// <para>DIBCI_NODISPLAYCLASS</para>
|
|
/// <para>Exclude a class if it has the <c>NoDisplayClass</c> value entry in its registry key.</para>
|
|
/// </param>
|
|
/// <param name="machineName">
|
|
/// A string that contains the name of a remote computer from which to retrieve installed setup classes. This parameter is optional
|
|
/// and can be <see langword="null"/>. If MachineName is <see langword="null"/>, this class provides a list of classes installed on
|
|
/// the local computer.
|
|
/// </param>
|
|
public DeviceClassCollection(DIBCI flags = 0, string machineName = null)
|
|
{
|
|
Flags = flags;
|
|
MachineName = machineName;
|
|
}
|
|
|
|
/// <summary>Gets the number of elements in the collection.</summary>
|
|
/// <value>The number of elements in the collection.</value>
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
SetupDiBuildClassInfoListEx(Flags, null, 0, out var len, MachineName);
|
|
return (int)len;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the flags used to control exclusion of classes from the list. If no flags are specified, all setup classes are included in
|
|
/// the list.
|
|
/// </summary>
|
|
/// <value>
|
|
/// Flags used to control exclusion of classes from the list. If no flags are specified, all setup classes are included in the list.
|
|
/// </value>
|
|
public DIBCI Flags { get; }
|
|
|
|
/// <summary>Gets the name of the machine on which devices are managed. <see langword="null"/> indicates the local machine.</summary>
|
|
/// <value>The machine name for this manager.</value>
|
|
public string MachineName { get; }
|
|
|
|
// TODO
|
|
//bool ICollection<DeviceClass>.IsReadOnly => false;
|
|
//public void Add(DeviceClass item) => throw new NotImplementedException();
|
|
//public void Clear() => throw new NotImplementedException();
|
|
//public bool Contains(DeviceClass item) => throw new NotImplementedException();
|
|
//public void CopyTo(DeviceClass[] array, int arrayIndex) => throw new NotImplementedException();
|
|
//public bool Remove(DeviceClass item) => throw new NotImplementedException();
|
|
|
|
/// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
/// <summary>Returns an enumerator that iterates through the collection.</summary>
|
|
/// <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.</returns>
|
|
public IEnumerator<DeviceClass> GetEnumerator()
|
|
{
|
|
SetupDiBuildClassInfoListEx(Flags, null, 0, out var len, MachineName);
|
|
if (len == 0) Win32Error.ThrowLastError();
|
|
|
|
var guids = new Guid[(int)len];
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiBuildClassInfoListEx(Flags, guids, len, out _, MachineName));
|
|
for (int i = 0; i < len; i++)
|
|
yield return new DeviceClass(guids[i], MachineName);
|
|
}
|
|
|
|
/// <summary>Returns an enumerator that iterates through a collection.</summary>
|
|
/// <returns>An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.</returns>
|
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
|
}
|
|
|
|
/// <summary>A class that provides the collection of devices available on a machine.</summary>
|
|
/// <seealso cref="System.Collections.Generic.IEnumerable{T}"/>
|
|
/// <seealso cref="System.IDisposable"/>
|
|
public class DeviceCollection : IEnumerable<Device>, IDisposable
|
|
{
|
|
private SafeHDEVINFO devInfoSet;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="DeviceCollection"/> class.</summary>
|
|
/// <param name="classGuid">
|
|
/// The GUID for a device setup class or a device interface class. This value is optional and can be <see langword="null"/>. If a
|
|
/// GUID value is not used to select devices, set <paramref name="classGuid"/> to <see langword="null"/>.
|
|
/// </param>
|
|
/// <param name="enumerator">
|
|
/// <para>A string that specifies:</para>
|
|
/// <list type="bullet">
|
|
/// <item>
|
|
/// <term>
|
|
/// An identifier (ID) of a Plug and Play (PnP) enumerator. This ID can either be the enumerator's globally unique identifier (GUID)
|
|
/// or symbolic name. For example, "PCI" can be used to specify the PCI PnP enumerator. Other examples of symbolic names for PnP
|
|
/// enumerators include "USB", "PCMCIA", and "SCSI".
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>
|
|
/// A PnP device instance IDs. When specifying a PnP device instance ID, DIGCF_DEVICEINTERFACE must be set in the <see
|
|
/// cref="Filter"/> property.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>This value is optional and can be <see langword="null"/>.</para>
|
|
/// </param>
|
|
/// <param name="machineName">
|
|
/// A string that contains the name of a remote computer on which the devices reside. A value of <see langword="null"/> for
|
|
/// <paramref name="machineName"/> specifies that the device is installed on the local computer.
|
|
/// </param>
|
|
/// <param name="filter">
|
|
/// Specifies control options that filter the device information elements that are added to the device information set. This
|
|
/// property can be a bitwise OR of one or more of the <see cref="DIGCF"/> flags.
|
|
/// </param>
|
|
public DeviceCollection(Guid? classGuid = null, string enumerator = null, string machineName = null, DIGCF filter = DIGCF.DIGCF_PRESENT)
|
|
{
|
|
ClassGuid = classGuid;
|
|
PnPEnumeratorOrDevInstId = enumerator;
|
|
MachineName = machineName;
|
|
Filter = PnPEnumeratorOrDevInstId is null ? filter : filter.SetFlags(DIGCF.DIGCF_DEVICEINTERFACE, PnPEnumeratorOrDevInstId.Contains("\\"));
|
|
Reset();
|
|
}
|
|
|
|
/// <summary>Gets the GUID for the device's setup class or interface class. This value is optional and may be <see langword="null"/>.</summary>
|
|
/// <value>The GUID for the device's setup class or interface class. This value is optional and may be <see langword="null"/>.</value>
|
|
public Guid? ClassGuid { get; }
|
|
|
|
/// <summary>
|
|
/// Gets a value that specifies control options that filter the device information elements that are added to the device information
|
|
/// set. This property can be a bitwise OR of one or more of the <see cref="DIGCF"/> flags.
|
|
/// </summary>
|
|
/// <value>The filter options.</value>
|
|
public DIGCF Filter { get; }
|
|
|
|
/// <summary>
|
|
/// Gets the name of a remote computer on which the devices reside. A value of <see langword="null"/> specifies that the device is
|
|
/// installed on the local computer.
|
|
/// </summary>
|
|
/// <value>
|
|
/// The name of a remote computer on which the devices reside. A value of <see langword="null"/> specifies that the device is
|
|
/// installed on the local computer.
|
|
/// </value>
|
|
public string MachineName { get; }
|
|
|
|
/// <summary>
|
|
/// <para>Gets a string that specifies:</para>
|
|
/// <list type="bullet">
|
|
/// <item>
|
|
/// <term>
|
|
/// An identifier (ID) of a Plug and Play (PnP) enumerator. This ID can either be the enumerator's globally unique identifier (GUID)
|
|
/// or symbolic name. For example, "PCI" can be used to specify the PCI PnP enumerator. Other examples of symbolic names for PnP
|
|
/// enumerators include "USB", "PCMCIA", and "SCSI".
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>
|
|
/// A PnP device instance IDs. When specifying a PnP device instance ID, DIGCF_DEVICEINTERFACE must be set in the <see
|
|
/// cref="Filter"/> property.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>This value is optional and can be <see langword="null"/>.</para>
|
|
/// </summary>
|
|
/// <value>The PnP enumerator or device instance ID.</value>
|
|
public string PnPEnumeratorOrDevInstId { get; }
|
|
|
|
/// <summary>Releases unmanaged and - optionally - managed resources.</summary>
|
|
public void Dispose() { }
|
|
|
|
/// <inheritdoc/>
|
|
public IEnumerator<Device> GetEnumerator()
|
|
{
|
|
var data = StructHelper.InitWithSize<SP_DEVINFO_DATA>();
|
|
for (uint i = 0; SetupDiEnumDeviceInfo(devInfoSet, i, ref data); i++)
|
|
yield return new Device(devInfoSet, data);
|
|
Win32Error.ThrowLastErrorUnless(Win32Error.ERROR_NO_MORE_ITEMS);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
|
|
|
private void Reset()
|
|
{
|
|
devInfoSet?.Dispose();
|
|
devInfoSet = SafeHDEVINFO.Create(ClassGuid, Filter, PnPEnumeratorOrDevInstId, MachineName);
|
|
Win32Error.ThrowLastErrorIfInvalid(devInfoSet);
|
|
}
|
|
}
|
|
|
|
/// <summary>Class to manage local and remote devices.</summary>
|
|
public class DeviceManager
|
|
{
|
|
private static readonly Lazy<DeviceManager> local = new(() => new DeviceManager(null));
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="DeviceManager"/> class on a specified machine.</summary>
|
|
/// <param name="machineName">Name of the machine on which to manage devices. Specify <see langword="null"/> for the local machine.</param>
|
|
public DeviceManager(string machineName = null) => MachineName = machineName;
|
|
|
|
/// <summary>Provides access to the local machine's devices.</summary>
|
|
public static DeviceManager LocalInstance => local.Value;
|
|
|
|
/// <summary>Gets the name of the machine on which devices are managed. <see langword="null"/> indicates the local machine.</summary>
|
|
/// <value>The machine name for this manager.</value>
|
|
public string MachineName { get; }
|
|
|
|
/// <summary>Gets the devices associated with this machine.</summary>
|
|
/// <param name="filter">
|
|
/// Specifies control options that filter the device information elements that are added to the device information set. This
|
|
/// property can be a bitwise OR of one or more of the <see cref="DIGCF"/> flags.
|
|
/// </param>
|
|
/// <returns>A sequence of <see cref="Device"/> instances on this machine.</returns>
|
|
public IEnumerable<Device> GetDevices(DIGCF filter = DIGCF.DIGCF_PRESENT) => new DeviceCollection(null, null, MachineName, filter);
|
|
|
|
/// <summary>Gets the setup classes available on the machine.</summary>
|
|
/// <value>A class that provides the collection of setup classes.</value>
|
|
public IEnumerable<DeviceClass> GetSetupClasses() => new DeviceClassCollection(0, MachineName);
|
|
|
|
internal static SP_DEVINFO_LIST_DETAIL_DATA GetDevInfoDetail(HDEVINFO hdi)
|
|
{
|
|
var disData = StructHelper.InitWithSize<SP_DEVINFO_LIST_DETAIL_DATA>();
|
|
Win32Error.ThrowLastErrorIfFalse(SetupDiGetDeviceInfoListDetail(hdi, ref disData));
|
|
return disData;
|
|
}
|
|
}
|
|
|
|
// TODO
|
|
internal class DeviceInterface
|
|
{
|
|
}
|
|
} |