DeviceInformation Klasse

Referenz

Definition

Namespace:: Windows.Devices.Enumeration

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Bearbeiten

Stellt ein Gerät dar. Diese Klasse ermöglicht den Zugriff auf bekannte Geräteeigenschaften sowie auf zusätzliche Eigenschaften, die während der Geräteenumeration angegeben werden.

public ref class DeviceInformation sealed

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class DeviceInformation final

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class DeviceInformation

Public NotInheritable Class DeviceInformation

Vererbung: Object Platform::Object IInspectable DeviceInformation

Attribute: ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Windows-Anforderungen

Gerätefamilie	Windows 10 (eingeführt in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (eingeführt in v1.0)

Beispiele

In diesem Beispiel werden Geräte inkrementell aufgelistet, bei jedem Auffinden eines Geräts zu einer Liste hinzugefügt und auch Entfernungen und Updates verarbeitet.

using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.IO;
using System.Diagnostics;
using System.Linq;
using System.Text;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
using Windows.UI.Xaml.Media.Imaging;

using Windows.Devices.Enumeration;
using Windows.Devices.Enumeration.Pnp;


// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234238

namespace Application1
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    /// 
    public sealed partial class BlankPage : Page
    {
        public BlankPage()
        {

            this.InitializeComponent();
        }
        Windows.UI.Core.CoreDispatcher dispatcher;
        public static DeviceWatcher watcher = null;
        public static int count = 0;
        public static DeviceInformation[] interfaces = new DeviceInformation[1000];
        public static bool isEnumerationComplete = false;
        public static string StopStatus = null;

        async void WatchDevices(object sender, RoutedEventArgs eventArgs)
        {
            try
            {
                dispatcher = Window.Current.CoreWindow.Dispatcher;
                watcher = DeviceInformation.CreateWatcher();
                // Add event handlers
                watcher.Added += watcher_Added;
                watcher.Removed += watcher_Removed;
                watcher.Updated += watcher_Updated;
                watcher.EnumerationCompleted += watcher_EnumerationCompleted;
                watcher.Stopped += watcher_Stopped;
                watcher.Start();
                OutputText.Text = "Enumeration started.";

            }
            catch (ArgumentException)
            {
                //The ArgumentException gets thrown by FindAllAsync when the GUID isn't formatted properly
                //The only reason we're catching it here is because the user is allowed to enter GUIDs without validation
                //In normal usage of the API, this exception handling probably wouldn't be necessary when using known-good GUIDs 
                OutputText.Text = "Caught ArgumentException. Failed to create watcher.";
            }
        }

        async void StopWatcher(object sender, RoutedEventArgs eventArgs)
        {
            try
            {
                if (watcher.Status == Windows.Devices.Enumeration.DeviceWatcherStatus.Stopped)
                {
                    StopStatus = "The enumeration is already stopped.";
                }
                else
                {
                    watcher.Stop();
                }
            }
            catch (ArgumentException)
            {
                OutputText.Text = "Caught ArgumentException. Failed to stop watcher.";
            }
        }

        async void watcher_Added(DeviceWatcher sender, DeviceInformation deviceInterface)
        {
            interfaces[count] = deviceInterface;
            count += 1;
            if (isEnumerationComplete)
            {
                await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    DisplayDeviceInterfaceArray();
                });
            }
        }

        async void watcher_Updated(DeviceWatcher sender, DeviceInformationUpdate devUpdate)
        {
            int count2 = 0;
            foreach (DeviceInformation deviceInterface in interfaces)
            {
                if (count2 < count)
                {
                    if (interfaces[count2].Id == devUpdate.Id)
                    {
                        //Update the element.
                        interfaces[count2].Update(devUpdate);
                    }

                }
                count2 += 1;
            }
            await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                OutputText.Text = "Enumeration updated. ";
                DisplayDeviceInterfaceArray();
            });
        }

        async void watcher_Removed(DeviceWatcher sender, DeviceInformationUpdate devUpdate)
        {
            int count2 = 0;
            //Convert interfaces array to a list (IList).
            List<DeviceInformation> interfaceList = new List<DeviceInformation>(interfaces);
            foreach (DeviceInformation deviceInterface in interfaces)
            {
                if (count2 < count)
                {
                    if (interfaces[count2].Id == devUpdate.Id)
                    {
                        //Remove the element.
                        interfaceList.RemoveAt(count2);
                    }

                }
                count2 += 1;
            }
            //Convert the list back to the interfaces array.
            interfaces = interfaceList.ToArray();
            count -= 1;
            await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                OutputText.Text = "Enumeration device was removed. ";
                DisplayDeviceInterfaceArray();
            });
        }

        async void watcher_EnumerationCompleted(DeviceWatcher sender, object args)
        {
            isEnumerationComplete = true;
            await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    OutputText.Text = "Enumeration complete. ";
                    DisplayDeviceInterfaceArray();
                });
        }

        async void watcher_Stopped(DeviceWatcher sender, object args)
        {
            if (watcher.Status == Windows.Devices.Enumeration.DeviceWatcherStatus.Aborted)
            {
                StopStatus = "Enumeration stopped unexpectedly. Click Watch to restart enumeration.";
            }
            else if (watcher.Status == Windows.Devices.Enumeration.DeviceWatcherStatus.Stopped)
            {
                StopStatus = "You requested to stop the enumeration. Click Watch to restart enumeration.";
            }
        }

        async void DisplayDeviceInterfaceArray()
        {
            DeviceInterfacesOutputList.Items.Clear();
            int count2 = 0;
            foreach (DeviceInformation deviceInterface in interfaces)
            {
                if (count2 < count)
                {
                    DisplayDeviceInterface(deviceInterface);
                }
                count2 += 1;
            }
        }

        async void DisplayDeviceInterface(DeviceInformation deviceInterface)
        {
            var id = "Id:" + deviceInterface.Id;
            var name = deviceInterface.Name;
            var isEnabled = "IsEnabled:" + deviceInterface.IsEnabled;


            var item = id + " is \n" + name + " and \n" + isEnabled;

            DeviceInterfacesOutputList.Items.Add(item);
        }
    }
}

Hinweise

Ein DeviceInformation-Objekt besteht aus einer Identität (DeviceInformation.Id), einer Art (DeviceInformation.Kind) und einer Eigenschaftensammlung (DeviceInformation.Properties). Alle anderen Eigenschaften eines DeviceInformation-Objekts werden von der Properties-Eigenschaftensammlung abgeleitet. Name wird beispielsweise von System.ItemNameDisplay abgeleitet.

Ein erfolgreicher Abschluss von FindAllAsync führt zu einer DeviceInformationCollection mit DeviceInformation-Objekten.

Wenn ein Aufruf von CreateWatcher erfolgreich ist, wird für jedes gefundene Gerät ein DeviceInformation-Objekt an das hinzugefügte Ereignis übergeben.

Die Name-Eigenschaft sollte nur für Anzeigezwecke und nicht für die Suche nach einem Gerät verwendet werden, da sich der Name aufgrund der Lokalisierung oder eines Benutzers ändern kann, der einen Namen zuweist.

CreateFromIdAsync erstellt bei erfolgreicher Ausführung ein DeviceInformation-Objekt.

Die DeviceInformation-Klasse stellt Geräteinformationen bereit, aber genauer gesagt, sie stellt Eigenschaften der Geräteschnittstelle bereit, der Schnittstelle, die die Funktionalität darstellt, die das Gerät verfügbar macht. Multifunktionsgeräte können über mehrere Geräteschnittstellen verfügen. Das physische Objekt, das ein Benutzer als Gerät sieht, wird als Gerätecontainer bezeichnet und verfügt über Eigenschaften wie Manufacturer und ModelID. Weitere Informationen zum Aufzählen von Geräten und zum Wiederherstellen von Eigenschaften finden Sie unter Auflisten von Geräten.

Eigenschaften

EnclosureLocation	Die physische Position des Geräts in seinem Gehäuse. Es kann beispielsweise den Standort einer Webcam in einem Laptop beschreiben.
Id	Eine Zeichenfolge, die die Identität des Geräts darstellt.
IsDefault	Gibt an, ob dieses Gerät das Standardgerät für die -Klasse ist.
IsEnabled	Gibt an, ob dieses Gerät aktiviert ist.
Kind	Ruft den Typ von DeviceInformation ab, der von diesem -Objekt dargestellt wird.
Name	Der Name des Geräts. Dieser Name ist in der besten verfügbaren Sprache für die App verfügbar.
Pairing	Ruft die Informationen zu den Funktionen ab, die dieses Gerät koppeln soll.
Properties	Eigenschaftenspeicher mit bekannten Werten sowie zusätzlichen Eigenschaften, die während der Geräteenumeration angegeben werden können.

Methoden

CreateFromIdAsync(String)	Erstellt ein DeviceInformation-Objekt aus einer DeviceInformation-ID .
CreateFromIdAsync(String, IIterable<String>)	Erstellt ein DeviceInformation-Objekt aus einer DeviceInformation-ID und einer Liste zusätzlicher Eigenschaften.
CreateFromIdAsync(String, IIterable<String>, DeviceInformationKind)	Erstellt ein DeviceInformation-Objekt aus einer DeviceInformation-ID , einer Liste zusätzlicher Eigenschaften und einem DeviceInformationKind-Parameter .
CreateFromIdAsync(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Stellt ein Gerät dar. Diese Klasse ermöglicht den Zugriff auf bekannte Geräteeigenschaften sowie auf zusätzliche Eigenschaften, die während der Geräteenumeration angegeben werden.
CreateWatcher()	Erstellt einen DeviceWatcher für alle Geräte.
CreateWatcher(DeviceClass)	Erstellt einen DeviceWatcher für Geräte, die der angegebenen DeviceClass entsprechen.
CreateWatcher(String)	Erstellt einen DeviceWatcher für Geräte, die der angegebenen AQS-Zeichenfolge (Advanced Query Syntax) entsprechen.
CreateWatcher(String, IIterable<String>)	Erstellt einen DeviceWatcher für Geräte, die der angegebenen AQS-Zeichenfolge (Advanced Query Syntax) und der angegebenen Auflistung von Eigenschaften entsprechen.
CreateWatcher(String, IIterable<String>, DeviceInformationKind)	Erstellt einen DeviceWatcher für Geräte, die der angegebenen AQS-Zeichenfolge (Advanced Query Syntax), der angegebenen Auflistung von Eigenschaften und der Art der Geräte entsprechen.
CreateWatcher(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Stellt ein Gerät dar. Diese Klasse ermöglicht den Zugriff auf bekannte Geräteeigenschaften sowie auf zusätzliche Eigenschaften, die während der Geräteenumeration angegeben werden.
FindAllAsync()	Listet alle DeviceInformation-Objekte auf.
FindAllAsync(DeviceClass)	Listet DeviceInformation-Objekte der angegebenen Klasse auf.
FindAllAsync(String)	Listet DeviceInformation-Objekte auf, die der angegebenen AQS-Geräteschnittstellenauswahlzeichenfolge (Advanced Query Syntax) entsprechen.
FindAllAsync(String, IIterable<String>)	Listet DeviceInformation-Objekte auf, die der angegebenen AQS-Geräteschnittstellenauswahlzeichenfolge (Advanced Query Syntax) und der angegebenen Auflistung von Eigenschaften entsprechen.
FindAllAsync(String, IIterable<String>, DeviceInformationKind)	Listet DeviceInformation-Objekte auf, die der angegebenen AQS-Geräteschnittstellenauswahlzeichenfolge (Advanced Query Syntax) entsprechen, der Geräteart und einschließlich der angegebenen Auflistung von Eigenschaften.
FindAllAsync(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Stellt ein Gerät dar. Diese Klasse ermöglicht den Zugriff auf bekannte Geräteeigenschaften sowie auf zusätzliche Eigenschaften, die während der Geräteenumeration angegeben werden.
GetAqsFilterFromDeviceClass(DeviceClass)	Erstellt einen Filter, der verwendet werden soll, um eine Teilmenge von Gerätetypen aufzulisten.
GetGlyphThumbnailAsync()	Ruft eine Glyphe für das Gerät ab.
GetThumbnailAsync()	Gibt eine Miniaturansicht für das Gerät zurück.
Update(DeviceInformationUpdate)	Updates die Eigenschaften eines vorhandenen DeviceInformation-Objekts.

Gilt für:

Freigeben über