DeviceInformation Classe

Référence

Définition

Espace de noms:: Windows.Devices.Enumeration

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Modifier

Représente un appareil. Cette classe permet d’accéder aux propriétés d’appareil connues, ainsi qu’aux propriétés supplémentaires spécifiées lors de l’énumération de l’appareil.

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

Héritage: Object Platform::Object IInspectable DeviceInformation

Attributs: ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Configuration requise pour Windows

Famille d’appareils	Windows 10 (introduit dans 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (introduit dans v1.0)

Exemples

Cet exemple énumère de manière incrémentielle des appareils, les ajoutant à une liste chaque fois qu’un appareil est trouvé, et gère également les suppressions et les mises à jour.

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);
        }
    }
}

Remarques

Un objet DeviceInformation est composé d’une identité (DeviceInformation.Id), d’un genre (DeviceInformation.Kind) et d’un conteneur des propriétés (DeviceInformation.Properties). Toutes les autres propriétés d’un objet DeviceInformation sont dérivées du conteneur des propriétés Properties. Par exemple, la propriété Name est dérivée de System.ItemNameDisplay.

L’achèvement de FindAllAsync aboutit à un DeviceInformationCollection contenant des objets DeviceInformation.

Si un appel à CreateWatcher réussit, un objet DeviceInformation est passé à l’événement ajouté pour chaque appareil trouvé.

La propriété Name ne doit être utilisée qu’à des fins d’affichage et non pour rechercher un appareil, car le nom peut changer en raison de la localisation ou de l’attribution d’un nom par un utilisateur.

CreateFromIdAsync crée un objet DeviceInformation en cas de réussite.

La classe DeviceInformation fournit des informations sur l’appareil, mais plus spécifiquement, elle fournit les propriétés de l’interface de l’appareil, l’interface qui représente les fonctionnalités exposées par l’appareil. Les appareils multi-fonctions peuvent avoir plusieurs interface d’appareil. L’objet physique qu’un utilisateur voit comme un appareil, est appelé conteneur d’appareil et possède des propriétés telles que Manufacturer et ModelID. Pour plus d’informations sur l’énumération des appareils et la récupération des propriétés, consultez Énumérer des appareils.

Propriétés

EnclosureLocation	Emplacement physique de l’appareil dans son boîtier. Par exemple, il peut décrire l’emplacement d’une webcam à l’intérieur d’un ordinateur portable.
Id	Chaîne représentant l’identité de l’appareil.
IsDefault	Indique si cet appareil est l’appareil par défaut de la classe.
IsEnabled	Indique si cet appareil est activé.
Kind	Obtient le type de DeviceInformation représenté par cet objet.
Name	Nom de l’appareil Ce nom est dans la meilleure langue disponible pour l’application.
Pairing	Obtient les informations sur les fonctionnalités de cet appareil à coupler.
Properties	Magasin de propriétés contenant des valeurs connues ainsi que des propriétés supplémentaires qui peuvent être spécifiées lors de l’énumération de l’appareil.

Méthodes

CreateFromIdAsync(String)	Crée un objet DeviceInformation à partir d’un ID DeviceInformation .
CreateFromIdAsync(String, IIterable<String>)	Crée un objet DeviceInformation à partir d’un ID DeviceInformation et d’une liste de propriétés supplémentaires.
CreateFromIdAsync(String, IIterable<String>, DeviceInformationKind)	Crée un objet DeviceInformation à partir d’un ID DeviceInformation , d’une liste de propriétés supplémentaires et d’un paramètre DeviceInformationKind .
CreateFromIdAsync(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Représente un appareil. Cette classe permet d’accéder aux propriétés d’appareil connues, ainsi qu’aux propriétés supplémentaires spécifiées lors de l’énumération de l’appareil.
CreateWatcher()	Crée un DeviceWatcher pour tous les appareils.
CreateWatcher(DeviceClass)	Crée un DeviceWatcher pour les appareils correspondant à deviceClass spécifié.
CreateWatcher(String)	Crée un DeviceWatcher pour les appareils correspondant à la chaîne AQS (Advanced Query Syntax) spécifiée.
CreateWatcher(String, IIterable<String>)	Crée un DeviceWatcher pour les appareils correspondant à la chaîne AQS (Advanced Query Syntax) spécifiée et à la collection de propriétés spécifiée.
CreateWatcher(String, IIterable<String>, DeviceInformationKind)	Crée un DeviceWatcher pour les appareils correspondant à la chaîne AQS (Advanced Query Syntax) spécifiée, à la collection de propriétés spécifiée et au type d’appareils.
CreateWatcher(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Représente un appareil. Cette classe permet d’accéder aux propriétés d’appareil connues, ainsi qu’aux propriétés supplémentaires spécifiées lors de l’énumération de l’appareil.
FindAllAsync()	Énumère tous les objets DeviceInformation .
FindAllAsync(DeviceClass)	Énumère les objets DeviceInformation de la classe spécifiée.
FindAllAsync(String)	Énumère les objets DeviceInformation correspondant à la chaîne de sélecteur d’interface d’appareil AQS (Advanced Query Syntax) spécifiée.
FindAllAsync(String, IIterable<String>)	Énumère les objets DeviceInformation correspondant à la chaîne de sélecteur d’interface d’appareil AQS (Advanced Query Syntax) spécifiée et y compris la collection de propriétés spécifiée.
FindAllAsync(String, IIterable<String>, DeviceInformationKind)	Énumère les objets DeviceInformation correspondant à la chaîne de sélecteur d’interface d’appareil AQS (Advanced Query Syntax) spécifiée, au type d’appareil et y compris la collection de propriétés spécifiée.
FindAllAsync(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Représente un appareil. Cette classe permet d’accéder aux propriétés d’appareil connues, ainsi qu’aux propriétés supplémentaires spécifiées lors de l’énumération de l’appareil.
GetAqsFilterFromDeviceClass(DeviceClass)	Crée un filtre à utiliser pour énumérer un sous-ensemble de types d’appareils.
GetGlyphThumbnailAsync()	Obtient un glyphe pour l’appareil.
GetThumbnailAsync()	Retourne une image miniature pour l’appareil.
Update(DeviceInformationUpdate)	Mises à jour les propriétés d’un objet DeviceInformation existant.

S’applique à