Anvisningar: Använda befintlig C++-kod i en universell Windows-plattformsapp

Det finns olika sätt att använda befintlig C++-kod i UWP-projekt (Universal Windows Platform). Vissa sätt kräver inte att kod omkompileras med komponenttilläggen (C++/CX) aktiverade (dvs. med /ZW alternativet), och vissa gör det. Du kan behöva behålla kod i standard-C++, eller bevara en klassisk Win32-kompileringsmiljö för viss kod. Du kan fortfarande göra det med lämpliga arkitekturval. Överväg all kod som innehåller UWP-användargränssnitt och typer som exponeras för C#-, Visual Basic- och JavaScript-anropare. Den här koden ska finnas i Windows App-projekt och Windows Runtime-komponentprojekt. Kod som du bara anropar från C++ (inklusive C++/CX) kan antingen finnas i ett projekt som kompileras med /ZW alternativet eller ett C++-standardprojekt. Endast binär kod som inte använder otillåtna API:er kan användas genom att länka den till ett statiskt bibliotek. Eller så kan du paketera den med appen som innehåll och läsa in den i en DLL.

Det kanske enklaste sättet att få igång ditt skrivbordsprogram i UWP-miljön är att använda Desktop Bridge-teknikerna. De innehåller Konverteraren för skrivbordsapp, som paketera ditt befintliga program som en UWP-app utan att det krävs några kodändringar. Mer information finns i Desktop Bridge.

I resten av den här artikeln beskrivs hur du portar C++-bibliotek (DLL:er och statiska bibliotek) till den universella Windows-plattformen. Du kanske vill portera koden så att din C++-kärnlogik kan användas med flera UWP-appar.

UWP-appar körs i en skyddad miljö. Därför tillåts inte många Win32-, COM- och CRT API-anrop som kan äventyra plattformssäkerheten. Kompilatoralternativet /ZW kan identifiera sådana anrop och generera ett fel. Du kan använda App Certification Kit i ditt program för att identifiera kod som anropar otillåtna API:er. Mer information finns i Certifieringspaket för Windows-appar.

Om källkoden är tillgänglig för biblioteket kan du försöka eliminera de otillåtna API-anropen. En lista över API:er som inte är tillåtna finns i Win32- och COM-API:er för UWP-appar och CRT-funktioner som inte stöds i universella Windows Platform-appar. Vissa alternativ finns på Alternativ till Windows-API:er i UWP-appar.

Om du bara försöker lägga till en referens från ett Universellt Windows-projekt i ett klassiskt skrivbordsbibliotek får du ett felmeddelande om att biblioteket inte är kompatibelt. Om det är ett statiskt bibliotek kan du länka till biblioteket genom att lägga till biblioteket (.lib filen) i dina länkningsindata, på samma sätt som i ett klassiskt Win32-program. Om endast ett binärt bibliotek är tillgängligt är det det enda alternativet. Ett statiskt bibliotek är länkat till appens körbara fil. En Win32-DLL som du använder i en UWP-app måste dock paketeras i appen genom att inkludera den i projektet och markera den som Innehåll. Om du vill läsa in en Win32 DLL i en UWP-app måste du också anropa LoadPackagedLibrary i stället LoadLibrary för eller LoadLibraryEx.

Om du har källkod för DLL eller statiskt bibliotek kan du kompilera om det som ett UWP-projekt med hjälp av kompileringsalternativet /ZW . Sedan kan du lägga till en referens till den med hjälp av Solution Explorer och använda den i C++ UWP-appar. Länka DLL:en med hjälp av exportbiblioteket.

Om du vill exponera funktioner för anropare på andra språk kan du konvertera biblioteket till en Windows Runtime-komponent. Windows Runtime-komponenter skiljer sig från vanliga DLL:er eftersom de innehåller metadata i form av .winmd filer som beskriver innehållet på ett sätt som .NET- och JavaScript-konsumenter behöver. Om du vill exponera API-element för andra språk kan du lägga till C++/CX-konstruktioner, till exempel referensklasser, och göra dem offentliga. I Windows 10 och senare rekommenderar vi C++/WinRT-biblioteket i stället för C++/CX.

Föregående diskussion gäller inte för COM-komponenter, som måste hanteras på olika sätt. Om du har en COM-server i en EXE eller DLL kan du använda den i ett universellt Windows-projekt. Paketera den som en registreringsfri COM-komponent, lägg till den i projektet som en innehållsfil och instansiera den med hjälp av CoCreateInstanceFromApp. Mer information finns i Använda Free-COM DLL i Windows Store C++ Project.

Om du vill portera ett befintligt COM-bibliotek till UWP är det också möjligt att konvertera det till en Windows Runtime-komponent. Vi rekommenderar C++/WinRT-biblioteket för sådana portar, men det är också möjligt att använda Windows Runtime C++ Template Library (WRL). WRL är inaktuell och stöder inte alla funktioner i ATL och OLE. Om en sådan port är möjlig beror på funktionerna i COM, ATL och OLE som komponenten kräver.

Oavsett vilka utvecklingsscenarier du väljer bör du vara medveten om ett antal makrodefinitioner. Du kan använda dessa makron i koden för att kompilera kod villkorligt under både det klassiska skrivbordet Win32 och UWP.

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP)
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

Dessa instruktioner gäller för UWP-appar, Windows Phone Store-appar, båda eller ingetdera (endast klassiskt Win32-skrivbord). Dessa makron är endast tillgängliga i Windows SDK 8.1 och senare.

Den här artikeln innehåller följande procedurer:

Använda en Win32 DLL-fil i en UWP-app
Använda ett inbyggt C++-statiskt bibliotek i en UWP-app
Portera ett C++-bibliotek till en Windows Runtime-komponent

Använda en Win32 DLL i en UWP-app

För bättre säkerhet och tillförlitlighet körs Universella Windows-appar i en begränsad körningsmiljö. Du kan inte bara använda en inbyggd DLL på det sätt som du skulle göra i ett klassiskt Windows-skrivbordsprogram. Om du har källkod för en DLL kan du portera koden så att den körs på UWP. Du börjar med att ändra några projektinställningar och projektfilmetadata för att identifiera projektet som ett UWP-projekt. Du kommer att kompilera om bibliotekskoden med hjälp av /ZW alternativet som aktiverar C++/CX. Vissa API-anrop tillåts inte i UWP-appar på grund av strängare kontroller som är associerade med den miljön. Mer information finns i Win32- och COM-API:er för UWP-appar.

Om du har en inbyggd DLL som exporterar funktioner med __declspec(dllexport), kan du anropa dessa funktioner från en UWP-app genom att omkompilera DLL:en som ett UWP-projekt. Anta till exempel att vi har ett Win32 DLL-projekt med namnet Giraff som exporterar ett par klasser och deras metoder, med kod som följande rubrikfil:

// giraffe.h
// Define GIRAFFE_EXPORTS when building this DLL
#pragma once

#ifdef GIRAFFE_EXPORTS
#define GIRAFFE_API __declspec(dllexport)
#else
#define GIRAFFE_API
#endif

GIRAFFE_API int giraffeFunction();

class Giraffe
{
    int id;
        Giraffe(int id_in);
    friend class GiraffeFactory;

public:
    GIRAFFE_API int GetID();
};

class GiraffeFactory
{
    static int nextID;

public:
    GIRAFFE_API GiraffeFactory();
    GIRAFFE_API static int GetNextID();
    GIRAFFE_API static Giraffe* Create();
};

Och följande kodfil:

// giraffe.cpp
#include "pch.h"
#include "giraffe.h"

Giraffe::Giraffe(int id_in) : id(id_in)
{
}

int Giraffe::GetID()
{
    return id;
}

int GiraffeFactory::nextID = 0;

GiraffeFactory::GiraffeFactory()
{
    nextID = 0;
}

int GiraffeFactory::GetNextID()
{
    return nextID;
}

Giraffe* GiraffeFactory::Create()
{
    return new Giraffe(nextID++);
}

int giraffeFunction();

Allt annat i projektet (pch.h, dllmain.cpp) är en del av win32-standardprojektmallen. Koden definierar makrot GIRAFFE_API, som matchas till __declspec(dllexport) när GIRAFFE_EXPORTS har definierats. Det vill säga, det definieras när projektet byggs som en DLL, men inte när en klient använder header-filen. Den här DLL:en kan användas i ett UWP-projekt utan att källkoden ändras. Endast vissa projektinställningar och egenskaper behöver ändras.

Följande procedur gäller när du har en intern DLL som exponerar funktioner med .__declspec(dllexport)

Så här porterar du en intern DLL till UWP utan att skapa ett nytt projekt

Öppna DLL-projektet i Visual Studio.
Öppna projektegenskaperna för DLL-projektet och ställ in konfigurationen på Alla konfigurationer.
På fliken Projektegenskaper under C/C++>Allmänt anger du Använd Windows Runtime-tillägg till Ja (/ZW).. Den här egenskapen aktiverar komponenttillägg (C++/CX).
I Solution Explorer väljer du projektnoden, öppnar snabbmenyn och väljer Ta bort projekt. Öppna sedan snabbmenyn på den borttagna projektnoden och välj att redigera projektfilen. Leta upp elementet WindowsTargetPlatformVersion och ersätt det med följande element.
```
<AppContainerApplication>true</AppContainerApplication>
<ApplicationType>Windows Store</ApplicationType>
<WindowsTargetPlatformVersion>10.0.10156.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformMinVersion>10.0.10156.0</WindowsTargetPlatformMinVersion>
<ApplicationTypeRevision>10.0</ApplicationTypeRevision>
```
.vcxproj Stäng filen, öppna snabbmenyn igen och välj Läsa in projekt igen.

Solution Explorer identifierar nu projektet som ett universellt Windows-projekt.
Kontrollera att ditt förkompilerade rubrikfilnamn är korrekt. I avsnittet Förkompilerade rubriker kan du behöva ändra den förkompilerade huvudfilen från pch.h till stdafx.h eller tvärtom om du ser ett fel som det här:

fel C2857: instruktionen "#include" som angavs med /Ycpch.h kommandoradsalternativet hittades inte i källfilen

Problemet är att äldre projektmallar använder en annan namngivningskonvention för den förkompilerade huvudfilen. Visual Studio 2019 och senare projekt använder pch.h.
Skapa projektet. Du kanske får några felmeddelanden om inkompatibla kommandoradsalternativ. Till exempel anges det nu inaktuella men ofta använda alternativet Aktivera minimal ombyggnad (/Gm) som standard i många äldre C++-projekt och är inte kompatibelt med /ZW.

Vissa funktioner är inte tillgängliga när du kompilerar för den universella Windows-plattformen. Du kommer att se kompilatorfel angående eventuella problem. Åtgärda dessa fel tills du har en ren version.
Om du vill använda DLL i en UWP-app i samma lösning öppnar du snabbmenyn för UWP-projektnoden och väljer Lägg till>referens.

Under Projektlösning> markerar du kryssrutan bredvid DLL-projektet och väljer knappen OK.
Inkludera bibliotekets huvudfil(er) i UWP-appens pch.h fil.
```
#include "..\Giraffe\giraffe.h"
```

Lägg till kod som vanligt i UWP-projektet för att anropa funktioner och skapa typer från DLL-filen.

MainPage::MainPage()
{
    InitializeComponent();
    GiraffeFactory gf;
    Giraffe* g = gf.Create();
    int id = g->GetID();
}

Använda ett inbyggt C++-statiskt bibliotek i en UWP-app

Du kan använda ett inbyggt C++-statiskt bibliotek i ett UWP-projekt, men det finns vissa begränsningar att känna till. Börja med att läsa om statiska bibliotek i C++/CX. Du kan komma åt den interna koden i ditt statiska bibliotek från UWP-appen, men vi rekommenderar inte att du skapar offentliga referenstyper i ett sådant statiskt bibliotek. Om du kompilerar ett statiskt bibliotek med /ZW alternativet varnar bibliotekarien (faktiskt länkaren i förklädnad):

LNK4264: arkivera objektfil som kompilerats med /ZW till ett statiskt bibliotek; Observera att när du redigerar Windows Runtime-typer rekommenderas det inte att länka till ett statiskt bibliotek som innehåller Windows Runtime-metadata

Du kan dock använda ett statiskt bibliotek i en UWP-app utan att kompilera om det med /ZW. Biblioteket kan inte deklarera några referenstyper eller använda C++/CX-konstruktioner. Men om ditt syfte bara är att använda ett bibliotek med inbyggd kod kan du göra det genom att följa dessa steg.

Så här använder du ett inbyggt C++-statiskt bibliotek i ett UWP-projekt

I projektegenskaperna för UWP-projektet väljer du Konfigurationsegenskaper>Länkindata> i den vänstra rutan. I den högra rutan lägger du till sökvägen till biblioteket i egenskapen Ytterligare beroenden . Till exempel, för ett bibliotek i projektet som placerar utdata i <SolutionFolder>\Debug\MyNativeLibrary\MyNativeLibrary.lib, lägger du till den relativa sökvägen Debug\MyNativeLibrary\MyNativeLibrary.lib.
Lägg till en include-instruktion för att referera till huvudfilen i pch.h filen (om den finns) eller i valfri .cpp fil efter behov och börja lägga till kod som använder biblioteket.
```
#include "..\MyNativeLibrary\MyNativeLibrary.h"
```
Lägg inte till någon referens i noden Referenser i Solution Explorer. Den mekanismen fungerar bara för Windows Runtime-komponenter.

Portera ett C++-bibliotek till en Windows Runtime-komponent

Anta att du vill använda interna API:er i ett statiskt bibliotek från en UWP-app. Om du har källkoden för det interna biblioteket kan du portera koden till en Windows Runtime-komponent. Det kommer inte att vara ett statiskt bibliotek längre. du gör den till en DLL som du kan använda i valfri C++ UWP-app. Den här proceduren beskriver hur du skapar en ny Windows Runtime-komponent som använder C++/CX-tillägg. Information om hur du skapar en komponent som använder C++/WinRT i stället finns i Windows Runtime-komponenter med C++/WinRT.

När du använder C++/CX kan du lägga till referenstyper och andra C++/CX-konstruktioner som är tillgängliga för klienter i valfri UWP-appkod. Du kan komma åt dessa typer från C#, Visual Basic eller JavaScript. Den grundläggande proceduren är:

Skapa ett Windows Runtime-komponentprojekt (Universal Windows),
kopiera koden för ditt statiska bibliotek till den och
åtgärda eventuella fel från kompilatorn som orsakas av alternativet /ZW .

Så här porterar du ett C++-bibliotek till en Windows Runtime-komponent

Skapa ett Windows Runtime Component-projekt (Universal Windows).
Stäng projektet.
Leta reda på det nya projektet i Utforskaren i Windows. Leta sedan upp det C++-biblioteksprojekt som innehåller den kod som du vill porta. Kopiera källfilerna (huvudfiler, kodfiler och andra resurser, inklusive i underkataloger) från ditt C++-biblioteksprojekt. Klistra in dem i den nya projektmappen och se till att bevara samma mappstruktur.
Öppna Windows Runtime-komponentprojektet igen. Öppna snabbmenyn för projektnoden i Solution Explorer och välj Lägg till>befintligt objekt.
Välj alla filer som ska läggas till från det ursprungliga projektet och välj OK. Upprepa om det behövs för undermappar.
Du kan nu ha viss duplicerad kod. Om det finns fler än en fördefinierad rubrik (till exempel både stdafx.h och pch.h), väljer du en att behålla. Kopiera all nödvändig kod, till exempel inkluderingsinstruktioner, i den du behåller. Ta sedan bort den andra och under Förkompilerade rubriker i projektegenskaperna kontrollerar du att namnet på huvudfilen är korrekt.

Om du har ändrat filen så att den används som förkompilerad rubrik kontrollerar du att de förkompilerade sidhuvudalternativen är korrekta för varje fil. Markera varje .cpp fil i tur och ordning, öppna dess egenskapsfönster och se till att alla är inställda på Använd (/Yu), förutom den förkompilerade rubriken, som ska vara inställd på Skapa (/Yc).
Skapa projektet och lös eventuella fel. Dessa fel kan orsakas av alternativet /ZW eller orsakas av en ny version av Windows SDK. Eller så kan de återspegla beroenden, till exempel huvudfiler som biblioteket är beroende av, eller skillnader i projektinställningar mellan ditt gamla projekt och det nya.
Lägg till offentliga referenstyper i projektet eller konvertera vanliga typer till referenstyper. Använd dessa typer för att exponera startpunkter för de funktioner som du vill anropa från UWP-appar.
Testa komponenten genom att lägga till en referens till den från ett UWP-appprojekt och lägg till kod för att anropa de offentliga API:er som du skapade.

Se även

Portering till den universella Windows-plattformen

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-07