DeviceInformation Clase

Definición

Espacio de nombres:

Windows.Devices.Enumeration

Representa un dispositivo. Esta clase permite el acceso a propiedades de dispositivo conocidas, así como a propiedades adicionales especificadas durante la enumeración de dispositivos.

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

Herencia

Object Platform::Object IInspectable DeviceInformation

Atributos

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisitos de Windows

Familia de dispositivos	Windows 10 (se introdujo en la versión 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (se introdujo en la versión v1.0)

Ejemplos

En este ejemplo se enumeran incrementalmente los dispositivos, se agregan a una lista cada vez que se encuentra un dispositivo y también se controlan las eliminaciones y las actualizaciones.

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

Comentarios

Un objeto DeviceInformation se compone de una identidad (DeviceInformation.Id), un tipo (DeviceInformation.Kind) y un contenedor de propiedades (DeviceInformation.Properties). Todas las otras propiedades de un objeto DeviceInformation derivan del contenedor de propiedades Properties. Por ejemplo, Name se deriva de System.ItemNameDisplay.

La finalización correcta de FindAllAsync da como resultado una deviceInformationCollection que contiene objetos DeviceInformation.

Si una llamada a CreateWatcher se realiza correctamente, se pasa un objeto DeviceInformation al evento agregado para cada dispositivo que se encuentra.

La propiedad Name solo debe usarse con fines para mostrar y no para buscar un dispositivo porque el nombre puede cambiar debido a la localización o a un usuario que asigna un nombre.

CreateFromIdAsync crea un objeto DeviceInformation si se ejecuta correctamente.

La clase DeviceInformation proporciona información del dispositivo, pero más concretamente, proporciona propiedades de la interfaz de dispositivo, la interfaz que representa la funcionalidad que expone el dispositivo. Los dispositivos de varias funciones pueden tener más de una interfaz de dispositivo. El objeto físico que un usuario ve como un dispositivo, se conoce como contenedor de dispositivos y tiene propiedades como Fabricante y ModelID. Para obtener más información sobre cómo enumerar dispositivos y recuperar propiedades, vea Enumerar dispositivos.

Propiedades

EnclosureLocation	Ubicación física del dispositivo en su gabinete. Por ejemplo, puede describir la ubicación de una cámara web dentro de un portátil.
Id	Cadena que representa la identidad del dispositivo.
IsDefault	Indica si este dispositivo es el dispositivo predeterminado para la clase .
IsEnabled	Indica si este dispositivo está habilitado.
Kind	Obtiene el tipo de DeviceInformation representado por este objeto.
Name	Nombre del dispositivo. Este nombre está en el mejor idioma disponible para la aplicación.
Pairing	Obtiene la información sobre las funcionalidades de este dispositivo que se van a emparejar.
Properties	Almacén de propiedades que contiene valores conocidos, así como propiedades adicionales que se pueden especificar durante la enumeración del dispositivo.

Métodos

CreateFromIdAsync(String)	Crea un objeto DeviceInformation a partir de un identificador deviceInformation .
CreateFromIdAsync(String, IIterable<String>)	Crea un objeto DeviceInformation a partir de un identificador deviceInformation y una lista de propiedades adicionales.
CreateFromIdAsync(String, IIterable<String>, DeviceInformationKind)	Crea un objeto DeviceInformation a partir de un identificador deviceInformation , una lista de propiedades adicionales y un parámetro DeviceInformationKind .
CreateWatcher()	Crea un DeviceWatcher para todos los dispositivos.
CreateWatcher(DeviceClass)	Crea un DeviceWatcher para dispositivos que coincidan con deviceClass especificado.
CreateWatcher(String)	Crea un DeviceWatcher para dispositivos que coincidan con la cadena de sintaxis de consulta avanzada (AQS) especificada.
CreateWatcher(String, IIterable<String>)	Crea un DeviceWatcher para dispositivos que coinciden con la cadena de sintaxis de consulta avanzada (AQS) especificada y la colección de propiedades especificada.
CreateWatcher(String, IIterable<String>, DeviceInformationKind)	Crea un DeviceWatcher para dispositivos que coinciden con la cadena de sintaxis de consulta avanzada (AQS) especificada, la colección especificada de propiedades y el tipo de dispositivos.
FindAllAsync()	Enumera todos los objetos DeviceInformation .
FindAllAsync(DeviceClass)	Enumera los objetos DeviceInformation de la clase especificada.
FindAllAsync(String)	Enumera los objetos DeviceInformation que coinciden con la cadena de selector de interfaz de dispositivo de la sintaxis de consulta avanzada (AQS) especificada.
FindAllAsync(String, IIterable<String>)	Enumera los objetos DeviceInformation que coinciden con la cadena de selector de interfaz de dispositivo de la sintaxis de consulta avanzada (AQS) especificada e incluye la colección especificada de propiedades.
FindAllAsync(String, IIterable<String>, DeviceInformationKind)	Enumera los objetos DeviceInformation que coinciden con la cadena de selector de interfaz de dispositivo de la sintaxis avanzada de consulta (AQS) especificada, el tipo de dispositivo e incluye la colección de propiedades especificada.
GetAqsFilterFromDeviceClass(DeviceClass)	Crea un filtro que se usará para enumerar a través de un subconjunto de tipos de dispositivo.
GetGlyphThumbnailAsync()	Obtiene un glifo para el dispositivo.
GetThumbnailAsync()	Devuelve una imagen en miniatura para el dispositivo.
Update(DeviceInformationUpdate)	Novedades las propiedades de un objeto DeviceInformation existente.

Consulte también

• Ejemplo de perfiles de cámara (Windows 10)
• Ejemplo de fotograma de vista previa de la cámara (Windows 10)
• Ejemplo de aplicación de cámara básica (Windows 10)
• Muestra de resolución de cámara (Windows 10)
• Ejemplo de dispositivo USB personalizado (Windows 10)
• Ejemplo de detección de caras de cámara (Windows 10)
• Ejemplo de estabilización de vídeo (Windows 10)
• Ejemplo manual de controles de cámara (Windows 10)
• Ejemplo de intervalo dinámico alto (Windows 10)
• Ejemplo de captura avanzada de cámara
• Muestra de baja energía bluetooth