Nota
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Las cosas que debe hacer para cualquier aplicación habilitada para la red.
Capacidades
Para usar las redes, debes agregar los elementos de funcionalidad adecuados al manifiesto de la aplicación. Si no se especifica ninguna funcionalidad de red en el manifiesto de la aplicación, la aplicación no tendrá ninguna funcionalidad de red y se producirá un error en cualquier intento de conexión a la red.
A continuación se muestran las funcionalidades de red más usadas.
Capacidad | Descripción |
---|---|
internetClient | Proporciona acceso saliente a Internet y redes en lugares públicos, como aeropuertos y cafeterías. La mayoría de las aplicaciones que requieren acceso a Internet deben usar esta funcionalidad. |
internetClientServer | Proporciona a la aplicación acceso de red entrante y saliente desde Internet y redes en lugares públicos como aeropuertos y cafeterías. |
ClienteServidorDeRedPrivada | Proporciona a la aplicación acceso de red entrante y saliente en los lugares de confianza del usuario, como el hogar y el trabajo. |
Hay otras funcionalidades que podrían ser necesarias para la aplicación, en determinadas circunstancias.
Capacidad | Descripción |
---|---|
autenticación empresarial | Permite a una aplicación conectarse a recursos de red que requieren credenciales de dominio. Por ejemplo, una aplicación que recupera datos de servidores de SharePoint en una intranet privada. Con esta funcionalidad, las credenciales se pueden usar para acceder a los recursos de red de una red que requiera credenciales. Una aplicación con esta funcionalidad puede suplantar a usted en la red. No necesita esta funcionalidad para permitir que la aplicación acceda a Internet a través de un proxy de autenticación. Para obtener más información, consulte la documentación del escenario de funcionalidad de Enterprise en funcionalidades restringidas. |
de proximidad | Es necesario para la comunicación de campo cercano con dispositivos en proximidad al ordenador. La tecnología de proximidad de campo cercano se puede utilizar para enviar o conectarse a una aplicación en un dispositivo cercano. Esta funcionalidad permite a una aplicación acceder a la red para conectarse a un dispositivo cerca, con el consentimiento del usuario para enviar una invitación o aceptar una invitación. |
certificadosDeUsuarioCompartidos | Esta funcionalidad permite a una aplicación acceder a certificados de software y hardware, como certificados de tarjeta inteligente. Cuando se invoca esta funcionalidad en tiempo de ejecución, el usuario debe tomar medidas, como insertar una tarjeta o seleccionar un certificado. Con esta funcionalidad, los certificados de software y hardware o una tarjeta inteligente se usan para la identificación en la aplicación. Esta funcionalidad puede ser utilizada por su empleador, banco o servicios gubernamentales para su identificación. |
Comunicación cuando la aplicación no está en primer plano
Apoya tu aplicación con tareas en segundo plano contiene información general sobre el uso de tareas en segundo plano para realizar trabajo cuando tu aplicación no está en primer plano. En concreto, el código debe tomar medidas especiales para poder recibir notificaciones cuando no es la aplicación en primer plano actual y los datos llegan a través de la red específicamente para ella. Ha utilizado los desencadenadores del canal de control para este propósito en Windows 8, y todavía son compatibles en Windows 10. La información completa sobre el uso de desencadenadores de canal de control está disponible aquí. Una nueva tecnología en Windows 10 proporciona una mejor funcionalidad con una menor sobrecarga para algunos escenarios, como los sockets de flujo con capacidad de inserción, el agente de socket y los desencadenadores de actividad de socket.
Si la aplicación usa DatagramSocket, StreamSocket o StreamSocketListener, la aplicación puede transferir la propiedad de un socket abierto a un agente de socket proporcionado por el sistema y, a continuación, dejar el primer plano o incluso finalizar. Cuando se realiza una conexión en el socket transferido, o el tráfico llega a ese socket, la aplicación o su tarea en segundo plano designada se activan. Si la aplicación no se está ejecutando, esta se inicia. A continuación, el intermediario de socket notifica a tu aplicación mediante un SocketActivityTrigger que ha llegado nuevo tráfico. La aplicación reclama el socket del agente de sockets y procesa el tráfico en el socket. Esto significa que la aplicación consume mucho menos recursos del sistema cuando no está procesando activamente el tráfico de red.
El intermediario de sockets está diseñado para reemplazar los desencadenadores de canal de control cuando sea aplicable, ya que proporciona la misma funcionalidad, pero con menos restricciones y un menor uso de memoria. El broker de sockets se puede usar en aplicaciones que no son de pantalla de bloqueo, y se usa de la misma manera en teléfonos que en otros dispositivos. Las aplicaciones no necesitan estar ejecutándose cuando llega el tráfico para que sean activadas por el agente de socket. Y el gestor de sockets admite la escucha en sockets TCP, que los activadores de canal de control no admiten.
Elección de un desencadenador de red
Hay algunos escenarios en los que cualquier tipo de desencadenador sería adecuado. Al elegir qué tipo de desencadenador usar en la aplicación, tenga en cuenta los siguientes consejos.
- Si usa IXMLHTTPRequest2, System.Net.Http.HttpClient o System.Net.Http.HttpClientHandler, debe usar ControlChannelTrigger.
- Si utiliza StreamSockets habilitados para inserción, puede usar desencadenadores de canal de control, pero prefiera SocketActivityTrigger. Esta última opción permite al sistema liberar memoria y reducir los requisitos de energía cuando la conexión no se usa activamente.
- Si quiere minimizar la superficie de memoria de la aplicación cuando no atiende activamente las solicitudes de red, prefiera SocketActivityTrigger siempre que sea posible.
- Si quieres que la aplicación pueda recibir datos mientras el sistema está en modo de espera conectado, usa SocketActivityTrigger.
Para obtener detalles y ejemplos de cómo usar el adaptador de sockets, consulte Comunicaciones de red en segundo plano.
Conexiones protegidas
Capa de sockets seguros (SSL) y la seguridad de la capa de transporte (TLS) más reciente son protocolos criptográficos diseñados para proporcionar autenticación y cifrado para la comunicación de red. Estos protocolos están diseñados para evitar interceptaciones y alteraciones al enviar y recibir datos de red. Estos protocolos usan un modelo de cliente-servidor para los intercambios de protocolos. Estos protocolos también usan certificados digitales y entidades de certificación para comprobar que el servidor es quien dice ser.
Creación de conexiones de sockets seguros
Se puede configurar un objeto StreamSocket para usar SSL/TLS para las comunicaciones entre el cliente y el servidor. Esta compatibilidad con SSL/TLS se limita al uso del objeto StreamSocket como cliente en la negociación SSL/TLS. No puede usar SSL/TLS con el StreamSocket creado por un StreamSocketListener cuando se reciben las comunicaciones entrantes, ya que la negociación SSL/TLS como servidor no se implementa mediante la clase StreamSocket.
Hay dos maneras de proteger una conexión StreamSocket con SSL/TLS:
- ConnectAsync : realice la conexión inicial a un servicio de red y negocie inmediatamente el uso de SSL/TLS para todas las comunicaciones.
- UpgradeToSslAsync : conéctese inicialmente a un servicio de red sin cifrado. La aplicación puede enviar o recibir datos. A continuación, actualice la conexión para usar SSL/TLS para todas las comunicaciones adicionales.
SocketProtectionLevel especifica el nivel de protección de socket deseado con el que la aplicación quiere establecer o actualizar la conexión. Sin embargo, el nivel de protección final de la conexión establecida se determina en un proceso de negociación entre ambos puntos de conexión de la conexión. El resultado puede ser un nivel de protección inferior al especificado, si el otro punto de conexión solicita un nivel inferior.
Una vez completada correctamente la operación asincrónica, puede recuperar el nivel de protección solicitado usado en la llamada ConnectAsync o UpgradeToSslAsync a través de la propiedad StreamSocketinformation.ProtectionLevel . Sin embargo, esto no refleja el nivel de protección real que usa la conexión.
Nota:
El código no debe depender implícitamente del uso de un nivel de protección determinado o de la suposición de que se usa de forma predeterminada un nivel de seguridad determinado. El panorama de seguridad cambia constantemente, y los protocolos y los niveles de protección predeterminados cambian con el tiempo para evitar el uso de protocolos con puntos débiles conocidos. Los valores predeterminados pueden variar en función de la configuración de la máquina individual o en qué software está instalado y qué revisiones se han aplicado. Si la aplicación depende del uso de un nivel de seguridad determinado, debe especificar explícitamente ese nivel y, a continuación, comprobar que realmente está en uso en la conexión establecida.
Uso de ConnectAsync
ConnectAsync se puede usar para establecer la conexión inicial con un servicio de red y, a continuación, negociar inmediatamente para usar SSL/TLS para todas las comunicaciones. Hay dos métodos ConnectAsync que permiten incluir un parámetro protectionLevel:
- ConnectAsync(EndpointPair, SocketProtectionLevel) - Inicia una operación asincrónica en un objeto StreamSocket para conectarse a un destino de red remoto especificado como un objeto EndpointPair y un SocketProtectionLevel.
- ConnectAsync(HostName, String, SocketProtectionLevel): inicia una operación asincrónica en un objeto StreamSocket de para conectarse a un destino remoto especificado por un nombre de host remoto, un nombre de servicio remoto y un SocketProtectionLevel.
Si el parámetro protectionLevel se establece en Windows.Networking.Sockets.SocketProtectionLevel.Ssl al llamar a cualquiera de los métodos ConnectAsync mencionados anteriormente, el StreamSocket se debe establecer para utilizar SSL/TLS para el cifrado. Este valor requiere cifrado y nunca permite usar un cifrado NULL.
La secuencia normal para usar con uno de estos métodos de ConnectAsync es la misma.
- Cree un StreamSocket .
- Si se necesita una opción avanzada en el socket, use la propiedad StreamSocket.Control para obtener la instancia StreamSocketControl asociada a un objeto StreamSocket. Establezca una propiedad en el StreamSocketControl.
- Llame a uno de los métodos anteriores ConnectAsync para iniciar una operación de conexión a un destino remoto y negociar inmediatamente el uso de SSL/TLS.
- La fuerza de la SSL negociada mediante ConnectAsync se puede determinar obteniendo la propiedad StreamSocketinformation.ProtectionLevel una vez que la operación asincrónica se haya completado correctamente.
En el ejemplo siguiente se crea un objeto StreamSocket y se intenta establecer una conexión con el servicio de red y establecer inmediatamente el uso de SSL/TLS. Si la negociación se realiza correctamente, toda la comunicación de red mediante StreamSocket entre el cliente que el servidor de red se cifrará.
using Windows.Networking;
using Windows.Networking.Sockets;
// Define some variables and set values
StreamSocket clientSocket = new StreamSocket();
HostName serverHost = new HostName("www.contoso.com");
string serverServiceName = "https";
// For simplicity, the sample omits implementation of the
// NotifyUser method used to display status and error messages
// Try to connect to contoso using HTTPS (port 443)
try {
// Call ConnectAsync method with SSL
await clientSocket.ConnectAsync(serverHost, serverServiceName, SocketProtectionLevel.Ssl);
NotifyUser("Connected");
}
catch (Exception exception) {
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) {
throw;
}
NotifyUser("Connect failed with error: " + exception.Message);
// Could retry the connection, but for this simple example
// just close the socket.
clientSocket.Dispose();
clientSocket = null;
}
// Add code to send and receive data using the clientSocket
// and then close the clientSocket
#include <winrt/Windows.Networking.Sockets.h>
using namespace winrt;
...
// Define some variables, and set values.
Windows::Networking::Sockets::StreamSocket clientSocket;
Windows::Networking::HostName serverHost{ L"www.contoso.com" };
winrt::hstring serverServiceName{ L"https" };
// For simplicity, the sample omits implementation of the
// NotifyUser method used to display status and error messages.
// Try to connect to the server using HTTPS and SSL (port 443).
try
{
co_await clientSocket.ConnectAsync(serverHost, serverServiceName, Windows::Networking::Sockets::SocketProtectionLevel::Tls12);
NotifyUser(L"Connected");
}
catch (winrt::hresult_error const& exception)
{
NotifyUser(L"Connect failed with error: " + exception.message());
clientSocket = nullptr;
}
// Add code to send and receive data using the clientSocket,
// then set the clientSocket to nullptr when done to close it.
using Windows::Networking;
using Windows::Networking::Sockets;
// Define some variables and set values
StreamSocket^ clientSocket = new ref StreamSocket();
HostName^ serverHost = new ref HostName("www.contoso.com");
String serverServiceName = "https";
// For simplicity, the sample omits implementation of the
// NotifyUser method used to display status and error messages
// Try to connect to the server using HTTPS and SSL (port 443)
task<void>(clientSocket->ConnectAsync(serverHost, serverServiceName, SocketProtectionLevel::SSL)).then([this] (task<void> previousTask) {
try
{
// Try getting all exceptions from the continuation chain above this point.
previousTask.Get();
NotifyUser("Connected");
}
catch (Exception^ exception)
{
NotifyUser("Connect failed with error: " + exception->Message);
clientSocket.Close();
clientSocket = null;
}
});
// Add code to send and receive data using the clientSocket
// Then close the clientSocket when done
Uso de UpgradeToSslAsync
Cuando el código usa UpgradeToSslAsync, primero establece una conexión a un servicio de red sin cifrado. La aplicación puede enviar o recibir algunos datos y, a continuación, actualizar la conexión para usar SSL/TLS para todas las comunicaciones posteriores.
El método upgradeToSslAsync de
La secuencia normal que se va a usar con el método UpgradeToSslAsync es la siguiente:
- Cree un StreamSocket .
- Si se necesita una opción avanzada en el socket, use la propiedad StreamSocket.Control para obtener la instancia StreamSocketControl asociada a un objeto StreamSocket. Establezca una propiedad en el StreamSocketControl.
- Si es necesario enviar y recibir datos sin cifrar, envíelos ahora.
- Llame al método UpgradeToSslAsync para iniciar una operación para actualizar la conexión para usar SSL/TLS.
- La seguridad SSL realmente negociada mediante UpgradeToSslAsync se puede determinar obteniendo la propiedad StreamSocketInformation.ProtectionLevel después de que la operación asincrónica se complete correctamente.
En el ejemplo siguiente se crea un objeto StreamSocket, se intenta establecer una conexión con el servicio de red, se envían algunos datos iniciales y, a continuación, se negocia el uso de SSL/TLS. Si la negociación se realiza correctamente, se cifrará toda la comunicación de red mediante StreamSocket entre el cliente y el servidor de red.
using Windows.Networking;
using Windows.Networking.Sockets;
using Windows.Storage.Streams;
// Define some variables and set values
StreamSocket clientSocket = new StreamSocket();
HostName serverHost = new HostName("www.contoso.com");
string serverServiceName = "http";
// For simplicity, the sample omits implementation of the
// NotifyUser method used to display status and error messages
// Try to connect to contoso using HTTP (port 80)
try {
// Call ConnectAsync method with a plain socket
await clientSocket.ConnectAsync(serverHost, serverServiceName, SocketProtectionLevel.PlainSocket);
NotifyUser("Connected");
}
catch (Exception exception) {
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) {
throw;
}
NotifyUser("Connect failed with error: " + exception.Message, NotifyType.ErrorMessage);
// Could retry the connection, but for this simple example
// just close the socket.
clientSocket.Dispose();
clientSocket = null;
return;
}
// Now try to send some data
DataWriter writer = new DataWriter(clientSocket.OutputStream);
string hello = "Hello, World! ☺ ";
Int32 len = (int) writer.MeasureString(hello); // Gets the UTF-8 string length.
writer.WriteInt32(len);
writer.WriteString(hello);
NotifyUser("Client: sending hello");
try {
// Call StoreAsync method to store the hello message
await writer.StoreAsync();
NotifyUser("Client: sent data");
writer.DetachStream(); // Detach stream, if not, DataWriter destructor will close it.
}
catch (Exception exception) {
NotifyUser("Store failed with error: " + exception.Message);
// Could retry the store, but for this simple example
// just close the socket.
clientSocket.Dispose();
clientSocket = null;
return;
}
// Now upgrade the client to use SSL
try {
// Try to upgrade to SSL
await clientSocket.UpgradeToSslAsync(SocketProtectionLevel.Ssl, serverHost);
NotifyUser("Client: upgrade to SSL completed");
// Add code to send and receive data
// The close clientSocket when done
}
catch (Exception exception) {
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) {
throw;
}
NotifyUser("Upgrade to SSL failed with error: " + exception.Message);
clientSocket.Dispose();
clientSocket = null;
return;
}
#include <winrt/Windows.Networking.Sockets.h>
#include <winrt/Windows.Storage.Streams.h>
using namespace winrt;
using namespace Windows::Storage::Streams;
...
// Define some variables, and set values.
Windows::Networking::Sockets::StreamSocket clientSocket;
Windows::Networking::HostName serverHost{ L"www.contoso.com" };
winrt::hstring serverServiceName{ L"https" };
// For simplicity, the sample omits implementation of the
// NotifyUser method used to display status and error messages.
// Try to connect to the server using HTTP (port 80).
try
{
co_await clientSocket.ConnectAsync(serverHost, serverServiceName, Windows::Networking::Sockets::SocketProtectionLevel::PlainSocket);
NotifyUser(L"Connected");
}
catch (winrt::hresult_error const& exception)
{
NotifyUser(L"Connect failed with error: " + exception.message());
clientSocket = nullptr;
}
// Now, try to send some data.
DataWriter writer{ clientSocket.OutputStream() };
winrt::hstring hello{ L"Hello, World! ☺ " };
uint32_t len{ writer.MeasureString(hello) }; // Gets the size of the string, in bytes.
writer.WriteInt32(len);
writer.WriteString(hello);
NotifyUser(L"Client: sending hello");
try
{
co_await writer.StoreAsync();
NotifyUser(L"Client: sent hello");
writer.DetachStream(); // Detach the stream when you want to continue using it; otherwise, the DataWriter destructor closes it.
}
catch (winrt::hresult_error const& exception)
{
NotifyUser(L"Store failed with error: " + exception.message());
// We could retry the store operation. But, for this simple example, just close the socket by setting it to nullptr.
clientSocket = nullptr;
co_return;
}
// Now, upgrade the client to use SSL.
try
{
co_await clientSocket.UpgradeToSslAsync(Windows::Networking::Sockets::SocketProtectionLevel::Tls12, serverHost);
NotifyUser(L"Client: upgrade to SSL completed");
// Add code to send and receive data using the clientSocket,
// then set the clientSocket to nullptr when done to close it.
}
catch (winrt::hresult_error const& exception)
{
// If this is an unknown status, then the error is fatal and retry will likely fail.
Windows::Networking::Sockets::SocketErrorStatus socketErrorStatus{ Windows::Networking::Sockets::SocketError::GetStatus(exception.to_abi()) };
if (socketErrorStatus == Windows::Networking::Sockets::SocketErrorStatus::Unknown)
{
throw;
}
NotifyUser(L"Upgrade to SSL failed with error: " + exception.message());
// We could retry the store operation. But for this simple example, just close the socket by setting it to nullptr.
clientSocket = nullptr;
co_return;
}
using Windows::Networking;
using Windows::Networking::Sockets;
using Windows::Storage::Streams;
// Define some variables and set values
StreamSocket^ clientSocket = new ref StreamSocket();
Hostname^ serverHost = new ref HostName("www.contoso.com");
String serverServiceName = "http";
// For simplicity, the sample omits implementation of the
// NotifyUser method used to display status and error messages
// Try to connect to contoso using HTTP (port 80)
task<void>(clientSocket->ConnectAsync(serverHost, serverServiceName, SocketProtectionLevel::PlainSocket)).then([this] (task<void> previousTask) {
try
{
// Try getting all exceptions from the continuation chain above this point.
previousTask.Get();
NotifyUser("Connected");
}
catch (Exception^ exception)
{
NotifyUser("Connect failed with error: " + exception->Message);
clientSocket->Close();
clientSocket = null;
}
});
// Now try to send some data
DataWriter^ writer = new ref DataWriter(clientSocket.OutputStream);
String hello = "Hello, World! ☺ ";
Int32 len = (int) writer->MeasureString(hello); // Gets the UTF-8 string length.
writer->writeInt32(len);
writer->writeString(hello);
NotifyUser("Client: sending hello");
task<void>(writer->StoreAsync()).then([this] (task<void> previousTask) {
try {
// Try getting all exceptions from the continuation chain above this point.
previousTask.Get();
NotifyUser("Client: sent hello");
writer->DetachStream(); // Detach stream, if not, DataWriter destructor will close it.
}
catch (Exception^ exception) {
NotifyUser("Store failed with error: " + exception->Message);
// Could retry the store, but for this simple example
// just close the socket.
clientSocket->Close();
clientSocket = null;
return
}
});
// Now upgrade the client to use SSL
task<void>(clientSocket->UpgradeToSslAsync(clientSocket.SocketProtectionLevel.Ssl, serverHost)).then([this] (task<void> previousTask) {
try {
// Try getting all exceptions from the continuation chain above this point.
previousTask.Get();
NotifyUser("Client: upgrade to SSL completed");
// Add code to send and receive data
// Then close clientSocket when done
}
catch (Exception^ exception) {
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) {
throw;
}
NotifyUser("Upgrade to SSL failed with error: " + exception.Message);
clientSocket->Close();
clientSocket = null;
return;
}
});
Creación de conexiones seguras de WebSocket
Al igual que las conexiones de socket tradicionales, las conexiones de WebSocket también se pueden cifrar con la seguridad de la capa de transporte (TLS)/Capa de sockets seguros (SSL) al usar el StreamWebSocket de
Para obtener ejemplos de cómo crear o actualizar a una conexión de socket seguro a un servicio de red, consulte Protección de conexiones de WebSocket con TLS/SSL.
Además del cifrado TLS/SSL, un servidor puede requerir un valor del encabezado Sec-WebSocket-Protocol para completar el handshake inicial. Este valor, representado por las propiedades de StreamWebSocketInformation.Protocol y MessageWebSocketInformation.Protocol, indica la versión del protocolo de conexión y permite al servidor interpretar correctamente el apretón de manos de apertura y los datos que se intercambian posteriormente. Con esta información de protocolo, si en algún momento el servidor no puede interpretar los datos entrantes de forma segura, se puede cerrar la conexión.
Si la solicitud inicial del cliente no contiene este valor o proporciona un valor que no coincide con lo que espera el servidor, el valor esperado se envía desde el servidor al cliente en el error de protocolo de enlace WebSocket.
Autenticación
Cómo proporcionar credenciales de autenticación al conectarse a través de la red.
Proporcionar un certificado de cliente con la clase StreamSocket
La clase Windows.Networking.Sockets.StreamSocket admite el uso de SSL/TLS para autenticar el servidor al que está hablando la aplicación. En determinados casos, la aplicación también debe autenticarse en el servidor mediante un certificado de cliente TLS. En Windows 10, puedes proporcionar un certificado de cliente en el objeto StreamSocket.Control (debe establecerse antes de iniciar el protocolo de enlace TLS). Si el servidor solicita el certificado de cliente, Windows responderá con el certificado proporcionado.
Este es un fragmento de código que muestra cómo implementar esto:
var socket = new StreamSocket();
Windows.Security.Cryptography.Certificates.Certificate certificate = await GetClientCert();
socket.Control.ClientCertificate = certificate;
await socket.ConnectAsync(destination, SocketProtectionLevel.Tls12);
Proporcionar credenciales de autenticación a un servicio web
Las API de red que permiten a las aplicaciones interactuar con servicios web seguros proporcionan sus propios métodos para inicializar un cliente o establecer un encabezado de solicitud con credenciales de autenticación de servidor y proxy. Cada método se establece con un objeto PasswordCredential que indica un nombre de usuario, una contraseña y el recurso para el que se usan estas credenciales. En la tabla siguiente se proporciona una asignación de estas API:
WebSockets | MessageWebSocketControl.ServerCredential |
---|---|
MessageWebSocketControl.ProxyCredential | |
StreamWebSocketControl.ServerCredential | |
StreamWebSocketControl.ProxyCredential | |
Transferencia en segundo plano | BackgroundDownloader.ServerCredential |
BackgroundDownloader.ProxyCredential | |
BackgroundUploader.ServerCredential | |
BackgroundUploader.ProxyCredential | |
Distribución | SyndicationClient(PasswordCredential) |
SyndicationClient.ServerCredential | |
SyndicationClient.ProxyCredential | |
AtomPub | AtomPubClient(PasswordCredential) |
AtomPubClient.ServerCredential | |
AtomPubClient.ProxyCredential |
Control de excepciones de red
En la mayoría de las áreas de programación, una excepción indica un problema o error significativo, causado por algún error en el programa. En la programación de red, hay un origen adicional para las excepciones: la propia red y la naturaleza de las comunicaciones de red. Las comunicaciones de red son intrínsecamente poco confiables y propensas a errores inesperados. Para cada una de las formas en que tu aplicación utiliza conexiones de red, debes mantener cierta información de estado; y el código de la aplicación debe manejar las excepciones de red actualizando esa información de estado e iniciando la lógica apropiada para que tu aplicación pueda resolver o reintentar fallos de comunicación.
Cuando las aplicaciones universales de Windows inician una excepción, el controlador de excepciones puede recuperar información más detallada sobre la causa de la excepción para comprender mejor el error y tomar las decisiones adecuadas.
Cada proyección de lenguaje admite un método para acceder a esta información más detallada. Una excepción se proyecta como un valor HRESULT en aplicaciones universales de Windows. La winerror.h archivo de inclusión contiene una lista muy extensa de posibles valores HRESULT, que incluye errores de red.
Las API de red admiten diferentes métodos para recuperar esta información detallada sobre la causa de una excepción.
- Algunas API proporcionan un método auxiliar que convierte el valor HRESULT de la excepción a un valor de enumeración.
- Otras API proporcionan un método para recuperar el valor HRESULT real.
Temas relacionados
- Mejoras de la API de redes de en Windows 10