DeviceInformation Classe

Definição

Namespace:

Windows.Devices.Enumeration

Representa um dispositivo. Essa classe permite o acesso a propriedades de dispositivo conhecidas, bem como propriedades adicionais especificadas durante a enumeração do 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

Herança

Object Platform::Object IInspectable DeviceInformation

Atributos

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisitos do Windows

Família de dispositivos	Windows 10 (introduzida na 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (introduzida na v1.0)

Exemplos

Este exemplo enumera incrementalmente os dispositivos, adicionando-os a uma lista sempre que um dispositivo é encontrado e também manipulando remoções e atualizações.

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

Comentários

Um objeto DeviceInformation é composto por uma identidade (DeviceInformation.Id), um tipo (DeviceInformation.Kind) e um recipiente de propriedades (DeviceInformation.Properties). Todas as outras propriedades de um objeto DeviceInformation são derivadas do recipiente de propriedades Properties. Por exemplo, Name é derivado de System.ItemNameDisplay.

A conclusão bem-sucedida de FindAllAsync resulta em um DeviceInformationCollection contendo objetos DeviceInformation.

Se uma chamada para CreateWatcher for bem-sucedida, um objeto DeviceInformation será passado para o evento adicionado para cada dispositivo encontrado.

A propriedade Name só deve ser usada para fins de exibição e não para localizar um dispositivo porque o Nome pode ser alterado devido à localização ou a um usuário atribuindo um nome.

CreateFromIdAsync criará um objeto DeviceInformation se tiver êxito.

A classe DeviceInformation fornece informações de dispositivo, mas, mais especificamente, fornece propriedades da interface do dispositivo, a interface que representa a funcionalidade que o dispositivo expõe. Dispositivos com várias funções podem ter mais de uma interface de dispositivo. O objeto físico que um usuário vê como um dispositivo, é conhecido como o contêiner do dispositivo e tem propriedades como Manufacturer e ModelID. Para obter mais informações sobre como enumerar dispositivos e recuperar propriedades, consulte Enumerar dispositivos.

Propriedades

EnclosureLocation	A localização física do dispositivo em seu compartimento. Por exemplo, ele pode descrever o local de uma webcam dentro de um laptop.
Id	Uma cadeia de caracteres que representa a identidade do dispositivo.
IsDefault	Indica se este dispositivo é o dispositivo padrão para a classe .
IsEnabled	Indica se este dispositivo está habilitado.
Kind	Obtém o tipo de DeviceInformation representado por este objeto .
Name	O nome do dispositivo. Esse nome está no melhor idioma disponível para o aplicativo.
Pairing	Obtém as informações sobre os recursos para este dispositivo emparelhar.
Properties	Repositório de propriedades que contém valores conhecidos, bem como propriedades adicionais que podem ser especificadas durante a enumeração do dispositivo.

Métodos

CreateFromIdAsync(String)	Cria um objeto DeviceInformation de uma ID DeviceInformation .
CreateFromIdAsync(String, IIterable<String>)	Cria um objeto DeviceInformation de uma ID DeviceInformation e uma lista de propriedades adicionais.
CreateFromIdAsync(String, IIterable<String>, DeviceInformationKind)	Cria um objeto DeviceInformation de uma ID DeviceInformation , uma lista de propriedades adicionais e um parâmetro DeviceInformationKind .
CreateWatcher()	Cria um DeviceWatcher para todos os dispositivos.
CreateWatcher(DeviceClass)	Cria um DeviceWatcher para dispositivos que correspondem ao DeviceClass especificado.
CreateWatcher(String)	Cria um DeviceWatcher para dispositivos que correspondem à cadeia de caracteres AQS (Sintaxe de Consulta Avançada) especificada.
CreateWatcher(String, IIterable<String>)	Cria um DeviceWatcher para dispositivos que correspondem à cadeia de caracteres AQS (Advanced Query Syntax) especificada e à coleção de propriedades especificada.
CreateWatcher(String, IIterable<String>, DeviceInformationKind)	Cria um DeviceWatcher para dispositivos que correspondem à cadeia de caracteres AQS (Sintaxe de Consulta Avançada) especificada, à coleção de propriedades especificada e ao tipo de dispositivos.
FindAllAsync()	Enumera todos os objetos DeviceInformation .
FindAllAsync(DeviceClass)	Enumera objetos DeviceInformation da classe especificada.
FindAllAsync(String)	Enumera objetos DeviceInformation que correspondem à cadeia de caracteres do seletor de interface do dispositivo AQS (Advanced Query Syntax) especificada.
FindAllAsync(String, IIterable<String>)	Enumera objetos DeviceInformation que correspondem à cadeia de caracteres do seletor de interface do dispositivo AQS (Advanced Query Syntax) especificada e incluindo a coleção de propriedades especificada.
FindAllAsync(String, IIterable<String>, DeviceInformationKind)	Enumera objetos DeviceInformation correspondentes à cadeia de caracteres do seletor de interface do dispositivo AQS (Advanced Query Syntax) especificada, o tipo de dispositivo e incluindo a coleção de propriedades especificada.
GetAqsFilterFromDeviceClass(DeviceClass)	Cria um filtro a ser usado para enumerar por meio de um subconjunto de tipos de dispositivo.
GetGlyphThumbnailAsync()	Obtém um glifo para o dispositivo.
GetThumbnailAsync()	Retorna uma imagem em miniatura para o dispositivo.
Update(DeviceInformationUpdate)	Atualizações as propriedades de um objeto DeviceInformation existente.

Confira também

• Exemplo de perfis de câmera (Windows 10)
• Amostra de quadro de visualização da câmera (Windows 10)
• Exemplo de aplicativo de câmera básico (Windows 10)
• Exemplo de resolução de câmera (Windows 10)
• Exemplo de dispositivo USB personalizado (Windows 10)
• Amostra de detecção facial da câmera (Windows 10)
• Exemplo de estabilização de vídeo (Windows 10)
• Exemplo de controles manuais de câmera (Windows 10)
• Exemplo de intervalo dinâmico alto (Windows 10)
• Exemplo de Captura Avançada da Câmera
• Exemplo de bluetooth de baixa energia