Dela via

Grunderna i nätverk

Saker du måste göra för alla nätverksaktiverade appar.

Förmågor

För att kunna använda nätverk måste du lägga till lämpliga funktionselement i appmanifestet. Om ingen nätverksfunktion anges i appens manifest har appen ingen nätverksfunktion och alla försök att ansluta till nätverket misslyckas.

Följande är de mest använda nätverksfunktionerna.

Kapacitet Beskrivning
internetklient Ger utgående åtkomst till Internet och nätverk på offentliga platser, till exempel flygplatser och kafé. De flesta appar som kräver Internetåtkomst bör använda den här funktionen.
internetClientServer Ger appen inkommande och utgående nätverksåtkomst från Internet och nätverk på offentliga platser som flygplatser och kaféer.
privatNätverkKlientServer Ger appen inkommande och utgående nätverksåtkomst på användarens betrodda platser, till exempel hem och arbete.

Det finns andra funktioner som kan vara nödvändiga för din app under vissa omständigheter.

Kapacitet Beskrivning
företagsautentisering Tillåter att en app ansluter till nätverksresurser som kräver domänautentiseringsuppgifter. Till exempel en app som hämtar data från SharePoint-servrar i ett privat intranät. Med den här funktionen kan dina autentiseringsuppgifter användas för att komma åt nätverksresurser i ett nätverk som kräver autentiseringsuppgifter. En app med den här funktionen kan personifiera dig i nätverket. Du behöver inte den här funktionen för att din app ska få åtkomst till Internet via en autentiseringsproxy.

Mer information finns i dokumentationen för kapacitetsscenariot Enterprise i begränsade funktioner.
närhet Krävs för närfältskommunikation med enheter i närheten av datorn. Närfältsteknik kan användas för att skicka till eller ansluta med en applikation på en närliggande enhet.

Med den här funktionen kan en app komma åt nätverket för att ansluta till en enhet i närheten, med användarens medgivande att skicka en inbjudan eller acceptera en inbjudan.
delade användarcertifikat Med den här funktionen kan en app komma åt programvaru- och maskinvarucertifikat, till exempel smartkortscertifikat. När den här funktionen anropas vid körning måste användaren vidta åtgärder, till exempel att infoga ett kort eller välja ett certifikat.

Med den här funktionen används dina programvaru- och maskinvarucertifikat eller ett smartkort för identifiering i appen. Den här funktionen kan användas av din arbetsgivare, bank eller myndighetstjänst för identifiering.

Kommunicera när din app inte är i förgrunden

Stöd för din app med bakgrundsaktiviteter innehåller allmän information om hur du använder bakgrundsaktiviteter för att utföra arbete när din app inte är i förgrunden. Mer specifikt måste din kod ta särskilda steg för att bli meddelad när den inte är den nuvarande förgrundsappen och data skickas över nätverket för dess skull. Du använde Control Channel-utlösare för detta ändamål i Windows 8, och de stöds fortfarande i Windows 10. Fullständig information om hur du använder Control Channel-utlösare finns här. En ny teknik i Windows 10 ger bättre funktioner med lägre omkostnader för vissa scenarier, till exempel push-aktiverade strömuttag: socket broker och socket-aktivitetsutlösare.

Om din app använder DatagramSocket, StreamSocketeller StreamSocketListener, kan appen överföra ägarskap av en öppen socket till en socket-förmedlare som tillhandahålls av systemet. Därefter kan appen lämna förgrunden eller till och med stängas. När en anslutning görs på den överförda sockeln, eller trafik kommer till sockeln, aktiveras din app eller dess avsedda bakgrundsaktivitet. Om appen inte körs startas den. Socket Broker meddelar sedan din app med hjälp av en SocketActivityTrigger att ny trafik har anlänt. Din app återtar socketen från socket-brokern och bearbetar trafiken på socketen. Det innebär att din app förbrukar mycket mindre systemresurser när den inte aktivt bearbetar nätverkstrafik.

Socket Broker är avsedd att ersätta Control Channel-utlösare där det är tillämpligt, eftersom det ger samma funktioner, men med färre begränsningar och ett mindre minnesfotavtryck. Socket broker kan användas av appar som inte är låsskärmsappar och som används på samma sätt på telefoner som på andra enheter. Appar behöver inte vara aktiva när trafiken kommer för att aktiveras av socket-brokern. Och socket-mäklaren har stöd för att lyssna på TCP-socketar, vilket Control Channel-utlösare inte stöder.

Välja en nätverksutlösare

Det finns vissa scenarier där någon av typerna av utlösare skulle vara lämpliga. När du väljer vilken typ av utlösare som ska användas i din app bör du överväga följande råd.

Mer information och exempel på hur du använder socket-förmedlaren finns i Nätverkskommunikation i bakgrunden.

Skyddade anslutningar

Secure Sockets Layer (SSL) och den nyare TLS (Transport Layer Security) är kryptografiska protokoll som är utformade för att tillhandahålla autentisering och kryptering för nätverkskommunikation. Dessa protokoll är utformade för att förhindra avlyssning och manipulering när du skickar och tar emot nätverksdata. Dessa protokoll använder en klient-server-modell för protokollutbyten. Dessa protokoll använder också digitala certifikat och certifikatutfärdare för att verifiera att servern är den som den påstår sig vara.

Skapa säkra socketanslutningar

Ett StreamSocket-objekt kan konfigureras för att använda SSL/TLS för kommunikation mellan klienten och servern. Det här stödet för SSL/TLS är begränsat till att använda StreamSocket-objektet som klient i SSL/TLS-förhandlingen. Du kan inte använda SSL/TLS med StreamSocket som skapats av en StreamSocketListener när inkommande kommunikation tas emot, eftersom SSL/TLS-förhandling som server inte implementeras av klassen StreamSocket .

Det finns två sätt att skydda en StreamSocket-anslutning med SSL/TLS:

  • ConnectAsync – Upprätta den första anslutningen till en nätverkstjänst och förhandla omedelbart om att använda SSL/TLS för all kommunikation.
  • UpgradeToSslAsync – Anslut till en början till en nätverkstjänst utan kryptering. Appen kan skicka eller ta emot data. Uppgradera sedan anslutningen så att den använder SSL/TLS för all ytterligare kommunikation.

SocketProtectionLevel anger önskad socketskyddsnivå som appen vill upprätta eller uppgradera anslutningen med. Den slutliga skyddsnivån för den etablerade anslutningen bestäms dock i en förhandlingsprocess mellan båda slutpunkterna i anslutningen. Resultatet kan vara en lägre skyddsnivå än den du angav, om den andra slutpunkten begär en lägre nivå.

När asynkron åtgärden har slutförts kan du hämta den begärda skyddsnivån som används i ConnectAsync - eller UpgradeToSslAsync-anropet via egenskapen StreamSocketinformation.ProtectionLevel . Detta återspeglar dock inte den faktiska skyddsnivå som anslutningen använder.

Anmärkning

Koden bör inte implicit vara beroende av att använda en viss skyddsnivå, eller på antagandet att en viss säkerhetsnivå används som standard. Säkerhetslandskapet ändras ständigt och protokoll och standardskyddsnivåer ändras över tid för att undvika användning av protokoll med kända svagheter. Standardinställningarna kan variera beroende på individuell datorkonfiguration eller på vilken programvara som är installerad och vilka korrigeringar som har tillämpats. Om din app är beroende av användningen av en viss säkerhetsnivå måste du uttryckligen ange den nivån och sedan kontrollera att den faktiskt används på den etablerade anslutningen.

Använda ConnectAsync

ConnectAsync kan användas för att upprätta den första anslutningen med en nätverkstjänst och sedan förhandla omedelbart om att använda SSL/TLS för all kommunikation. Det finns två ConnectAsync-metoder som stöder överföring av en protectionLevel-parameter :

Om parametern protectionLevel är inställd på Windows.Networking.Sockets.SocketProtectionLevel.Ssl när du anropar någon av ovanstående ConnectAsync-metoder måste StreamSocket upprättas för att använda SSL/TLS för kryptering. Det här värdet kräver kryptering och tillåter aldrig att ett NULL-chiffer används.

Den normala sekvensen som ska användas med någon av dessa ConnectAsync-metoder är densamma.

I följande exempel skapas en StreamSocket och försöker upprätta en anslutning till nätverkstjänsten och förhandla omedelbart om att använda SSL/TLS. Om förhandlingen lyckas kommer all nätverkskommunikation med StreamSocket mellan klienten och nätverksservern att krypteras.

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

Använd UpgradeToSslAsync

När koden använder UpgradeToSslAsync upprättar den först en anslutning till en nätverkstjänst utan kryptering. Appen kan skicka eller ta emot vissa data och sedan uppgradera anslutningen så att den använder SSL/TLS för all ytterligare kommunikation.

Metoden UpgradeToSslAsync tar två parametrar. Parametern protectionLevel anger önskad skyddsnivå. Parametern validationHostName är värdnamnet för det fjärrnätverksmål som används för validering vid uppgradering till SSL. Normalt skulle validationHostName vara samma värdnamn som appen använde för att upprätta anslutningen. Om parametern protectionLevel är inställd på Windows.System.Socket.SocketProtectionLevel.Ssl när du anropar UpgradeToSslAsync, måste StreamSocket använda SSL/TLS för kryptering vid ytterligare kommunikation över socketen. Det här värdet kräver kryptering och tillåter aldrig att ett NULL-chiffer används.

Den normala sekvensen som ska användas med metoden UpgradeToSslAsync är följande:

I följande exempel skapas en StreamSocket, försöker upprätta en anslutning till nätverkstjänsten, skickar några initiala data och förhandlar sedan om att använda SSL/TLS. Om förhandlingen lyckas krypteras all nätverkskommunikation med StreamSocket mellan klienten och nätverksservern.

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

Skapa säkra WebSocket-anslutningar

Precis som traditionella socketanslutningar kan WebSocket-anslutningar också krypteras med TLS (Transport Layer Security)/Secure Sockets Layer (SSL) när du använder funktionerna StreamWebSocket och MessageWebSocket för en UWP-app. I de flesta fall vill du använda en säker WebSocket-anslutning. Detta ökar risken för att anslutningen lyckas, eftersom många proxyservrar avvisar okrypterade WebSocket-anslutningar.

Exempel på hur du skapar eller uppgraderar till en säker socketanslutning till en nätverkstjänst finns i Skydda WebSocket-anslutningar med TLS/SSL.

Förutom TLS/SSL-kryptering kan en server kräva ett Sec-WebSocket-Protocol- huvudvärde för att slutföra det första handskakningen. Det här värdet, som representeras av egenskaperna StreamWebSocketInformation.Protocol och MessageWebSocketInformation.Protocol , anger protokollversionen av anslutningen och gör det möjligt för servern att korrekt tolka den inledande handskakningen och de data som utbyts efteråt. Om servern inte kan tolka inkommande data på ett säkert sätt kan anslutningen stängas med hjälp av den här protokollinformationen.

Om den första begäran från klienten antingen inte innehåller det här värdet eller ger ett värde som inte matchar vad servern förväntar sig skickas det förväntade värdet från servern till klienten på WebSocket-handskakningsfelet.

Autentisering

Så här anger du autentiseringsuppgifter när du ansluter via nätverket.

Tillhandahålla ett klientcertifikat med klassen StreamSocket

Klassen Windows.Networking.Sockets.StreamSocket stöder användning av SSL/TLS för att autentisera servern som appen pratar med. I vissa fall måste appen även autentisera sig till servern med hjälp av ett TLS-klientcertifikat. I Windows 10 kan du ange ett klientcertifikat på objektet StreamSocket.Control (detta måste anges innan TLS-handskakningen startas). Om servern begär klientcertifikatet svarar Windows med det angivna certifikatet.

Här är ett kodfragment som visar hur du implementerar detta:

var socket = new StreamSocket();
Windows.Security.Cryptography.Certificates.Certificate certificate = await GetClientCert();
socket.Control.ClientCertificate = certificate;
await socket.ConnectAsync(destination, SocketProtectionLevel.Tls12);

Tillhandahålla autentiseringsuppgifter till en webbtjänst

De nätverks-API:er som gör det möjligt för appar att interagera med säkra webbtjänster tillhandahåller var och en sina egna metoder för att antingen initiera en klient eller ange ett begärandehuvud med autentiseringsuppgifter för server och proxy. Varje metod anges med ett PasswordCredential-objekt som anger ett användarnamn, lösenord och den resurs som dessa autentiseringsuppgifter används för. Följande tabell innehåller en mappning av dessa API:er:

WebSockets MessageWebSocketControl.ServerCredential
MessageWebSocketControl.ProxyCredential
StreamWebSocketControl.ServerCredential
StreamWebSocketControl.ProxyCredential
Bakgrundsöverföring BackgroundDownloader.ServerCredential
BackgroundDownloader.ProxyCredential
BackgroundUploader.ServerCredential
BackgroundUploader.ProxyCredential
Syndikering SyndicationClient(PasswordCredential)
SyndicationClient.ServerCredential
SyndicationClient.ProxyCredential
AtomPub AtomPubClient(PasswordCredential)
AtomPubClient.ServerCredential
AtomPubClient.ProxyCredential

Hantera nätverksfel

I de flesta programmeringsområden indikerar ett undantag ett betydande problem eller fel som orsakas av vissa fel i programmet. I nätverksprogrammering finns det ytterligare en källa för undantag: själva nätverket och nätverkskommunikationens natur. Nätverkskommunikation är i sig opålitlig och kan drabbas av oväntade fel. För vart och ett av sätten som din app använder nätverk på måste du ha viss tillståndsinformation. och din appkod måste hantera nätverksfel genom att uppdatera tillståndsinformationen och initiera lämplig logik för att appen ska kunna återupprätta eller försöka kommunicera igen.

När Universella Windows-appar utlöser ett undantag kan undantagshanteraren hämta mer detaljerad information om orsaken till undantaget för att bättre förstå felet och fatta lämpliga beslut.

Varje språkprojektion stöder en metod för att komma åt den här mer detaljerade informationen. Ett undantag representeras som ett HRESULT--värde i universella Windows-appar. Winerror.h innehåller en mycket stor lista över möjliga HRESULT värden, inklusive nätverksfel.

Nätverks-API:erna stöder olika metoder för att hämta den här detaljerade informationen om orsaken till ett undantag.

  • Vissa API:er tillhandahåller en hjälpmetod som konverterar HRESULT-värdet från undantaget till ett uppräkningsvärde.
  • Andra API:er tillhandahåller en metod för att hämta det faktiska HRESULT-värdet .
  • Last updated on