DeviceInformation Classe

Definizione

Spazio dei nomi:

Windows.Devices.Enumeration

Rappresenta un dispositivo. Questa classe consente l'accesso alle proprietà del dispositivo note e alle proprietà aggiuntive specificate durante l'enumerazione del dispositivo.

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

Ereditarietà

Object Platform::Object IInspectable DeviceInformation

Attributi

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisiti Windows

Famiglia di dispositivi	Windows 10 (è stato introdotto in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (è stato introdotto in v1.0)

Esempio

Questo esempio enumera in modo incrementale i dispositivi, li aggiunge a un elenco ogni volta che viene trovato un dispositivo e gestisce anche le rimozioni e gli aggiornamenti.

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

Commenti

Un oggetto DeviceInformation è costituito da un'identità (DeviceInformation.Id), un tipo (DeviceInformation.Kind) e un contenitore delle proprietà (DeviceInformation.Properties). Tutte le altre proprietà di un oggetto DeviceInformation vengono derivate dal contenitore delle proprietà Properties. Ad esempio, Name viene derivato da System.ItemNameDisplay.

Il completamento corretto di FindAllAsync genera un oggetto DeviceInformationCollection contenente oggetti DeviceInformation.

Se una chiamata a CreateWatcher ha esito positivo, un oggetto DeviceInformation viene passato all'evento aggiunto per ogni dispositivo trovato.

La proprietà Name deve essere usata solo a scopo di visualizzazione e non per trovare un dispositivo perché il nome può cambiare a causa della localizzazione o di un utente che assegna un nome.

CreateFromIdAsync crea un oggetto DeviceInformation in caso di esito positivo.

La classe DeviceInformation fornisce informazioni sul dispositivo, ma in particolare fornisce proprietà dell'interfaccia del dispositivo, l'interfaccia che rappresenta le funzionalità esposte dal dispositivo. I dispositivi a più funzioni possono avere più di un'interfaccia del dispositivo. L'oggetto fisico visualizzato da un utente come dispositivo, è noto come contenitore di dispositivi e ha proprietà come Manufacturer e ModelID. Per altre informazioni sull'enumerazione dei dispositivi e sul ripristino delle proprietà, vedere Enumerare i dispositivi.

Proprietà

EnclosureLocation	Posizione fisica del dispositivo nell'enclosure. Ad esempio, può descrivere la posizione di una webcam all'interno di un portatile.
Id	Stringa che rappresenta l'identità del dispositivo.
IsDefault	Indica se il dispositivo è il dispositivo predefinito per la classe .
IsEnabled	Indica se il dispositivo è abilitato.
Kind	Ottiene il tipo di DeviceInformation rappresentato da questo oggetto.
Name	Nome del dispositivo. Questo nome si trova nella lingua migliore disponibile per l'app.
Pairing	Ottiene le informazioni sulle funzionalità che il dispositivo deve associare.
Properties	Archivio proprietà contenente valori noti e proprietà aggiuntive che possono essere specificate durante l'enumerazione del dispositivo.

Metodi

CreateFromIdAsync(String)	Crea un oggetto DeviceInformation da un ID DeviceInformation .
CreateFromIdAsync(String, IIterable<String>)	Crea un oggetto DeviceInformation da un ID DeviceInformation e un elenco di proprietà aggiuntive.
CreateFromIdAsync(String, IIterable<String>, DeviceInformationKind)	Crea un oggetto DeviceInformation da un ID DeviceInformation , un elenco di proprietà aggiuntive e un parametro DeviceInformationKind .
CreateWatcher()	Crea un DeviceWatcher per tutti i dispositivi.
CreateWatcher(DeviceClass)	Crea un Oggetto DeviceWatcher per i dispositivi corrispondenti alla classe DeviceClass specificata.
CreateWatcher(String)	Crea un DeviceWatcher per i dispositivi che corrispondono alla stringa AQS (Advanced Query Syntax) specificata.
CreateWatcher(String, IIterable<String>)	Crea un Oggetto DeviceWatcher per i dispositivi che corrispondono alla stringa AQS (Advanced Query Syntax) specificata e alla raccolta di proprietà specificata.
CreateWatcher(String, IIterable<String>, DeviceInformationKind)	Crea un Oggetto DeviceWatcher per i dispositivi che corrispondono alla stringa AQS (Advanced Query Syntax) specificata, alla raccolta di proprietà specificata e al tipo di dispositivi.
FindAllAsync()	Enumera tutti gli oggetti DeviceInformation .
FindAllAsync(DeviceClass)	Enumera gli oggetti DeviceInformation della classe specificata.
FindAllAsync(String)	Enumera gli oggetti DeviceInformation corrispondenti alla stringa del selettore dell'interfaccia del dispositivo Advanced Query Syntax (AQS) specificata.
FindAllAsync(String, IIterable<String>)	Enumera gli oggetti DeviceInformation corrispondenti alla stringa del selettore dell'interfaccia del dispositivo Advanced Query Syntax (AQS) specificata e include la raccolta specificata di proprietà.
FindAllAsync(String, IIterable<String>, DeviceInformationKind)	Enumera gli oggetti DeviceInformation corrispondenti alla stringa del selettore dell'interfaccia del dispositivo AQS (Advanced Query Syntax) specificata, al tipo di dispositivo e all'insieme specificato di proprietà.
GetAqsFilterFromDeviceClass(DeviceClass)	Crea un filtro da usare per enumerare tramite un subset di tipi di dispositivo.
GetGlyphThumbnailAsync()	Ottiene un glifo per il dispositivo.
GetThumbnailAsync()	Restituisce un'immagine di anteprima per il dispositivo.
Update(DeviceInformationUpdate)	Aggiornamenti le proprietà di un oggetto DeviceInformation esistente.

Vedi anche

• Esempio di profili fotocamera (Windows 10)
• Esempio di fotogrammi di anteprima della fotocamera (Windows 10)
• Esempio di app della fotocamera di base (Windows 10)
• Esempio di risoluzione della fotocamera (Windows 10)
• Esempio di dispositivo USB personalizzato (Windows 10)
• Esempio di rilevamento viso della fotocamera (Windows 10)
• Esempio di stabilizzazione video (Windows 10)
• Esempio di controlli della fotocamera manuale (Windows 10)
• Esempio di intervallo dinamico elevato (Windows 10)
• Esempio di acquisizione avanzata della fotocamera
• Esempio bluetooth a basso consumo energetico