DeviceInformation Classe

Referência

Definição

Namespace:: Windows.Devices.Enumeration

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Editar

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 .
CreateFromIdAsync(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Representa um dispositivo. Essa classe permite o acesso a propriedades de dispositivo conhecidas, bem como propriedades adicionais especificadas durante a enumeração do dispositivo.
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.
CreateWatcher(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Representa um dispositivo. Essa classe permite o acesso a propriedades de dispositivo conhecidas, bem como propriedades adicionais especificadas durante a enumeração do dispositivo.
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.
FindAllAsync(String, IIterable<String>, DeviceInformationKind, IDeviceEnumerationSettings)	Representa um dispositivo. Essa classe permite o acesso a propriedades de dispositivo conhecidas, bem como propriedades adicionais especificadas durante a enumeração do dispositivo.
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.

Aplica-se a

Compartilhar via

DeviceInformation Classe

Definição

Requisitos do Windows

Exemplos

Comentários

Propriedades

Métodos

Aplica-se a

Confira também

Comentários

Recursos adicionais