Novità di C++/WinRTWhat's new in C++/WinRT

Man mano che vengono rilasciate versioni di C++/WinRT successive, questo argomento descrive le novità e le modifiche.As subsequent versions of C++/WinRT are released, this topic describes what's new, and what's changed.

Riepilogo dei miglioramenti o delle aggiunte recenti al mese di marzo 2020Rollup of recent improvements/additions as of March 2020

Tempi di compilazione ridotti del 23%Up to 23% shorter build times

I team di C++/WinRT e del compilatore C++ hanno collaborato per ridurre il più possibile i tempi di compilazione.The C++/WinRT and C++ compiler teams have collaborated to do everything possible to shorten build times. I dati di analisi del compilatore sono stati esaminati attentamente per comprendere come ristrutturare gli elementi interni di C++/WinRT, in modo da consentire al compilatore C++ di eliminare il sovraccarico in fase di compilazione, e come migliorare il compilatore C++ stesso per gestire la libreria C++/WinRT.We've pored over compiler analytics to figure out how the internals of C++/WinRT can be restructured to help the C++ compiler eliminate compile-time overhead, as well as how the C++ compiler itself can be improved to handle the C++/WinRT library. C++/WinRT è stato ottimizzato per il compilatore e quest'ultimo è stato ottimizzato per C++/WinRT.C++/WinRT has been optimized for the compiler; and the compiler has been optimized for C++/WinRT.

Prendiamo ad esempio lo scenario del caso peggiore in cui viene creata un'intestazione precompilata (PCH) che contiene ogni singola intestazione dello spazio dei nomi della proiezione C++/WinRT.Let's take for example the worst case scenario of building a pre-compiled header (PCH) that contains every single C++/WinRT projection namespace header.

VersionVersion Dimensione PCH (byte)PCH size (bytes) OreTime (s)
C++/WinRT di luglio, con Visual C++ 16.3C++/WinRT from July, with Visual C++ 16.3 3.004.104.6323,004,104,632 3131
C++/WinRT versione 2.0.200316.3, con Visual C++ 16.5version 2.0.200316.3 of C++/WinRT, with Visual C++ 16.5 2.393.515.3362,393,515,336 2424

Abbiamo ottenuto una riduzione della dimensione del 20% e una riduzione del tempo di compilazione del 23%.A 20% reduction in size, and a 23% reduction in build time.

Supporto di MSBuild miglioratoImproved MSBuild support

Abbiamo dedicato molto impegno a migliorare il supporto di MSBuild per una vasta gamma di scenari diversi.We've invested a lot of work into improving MSBuild support for a large selection of different scenarios.

Memorizzazione nella cache di factory ancora più veloceEven faster factory caching

Abbiamo migliorato l'inlining della cache di factory per ottenere percorsi critici inline più efficienti, consentendo così un'esecuzione più veloce.We've improved inlining of the factory cache in order to better inline hot paths, which leads to faster execution.

Questo miglioramento non influisce sulla dimensione del codice, come descritto di seguito in Generazione del codice con gestione delle eccezioni ottimizzata, se l'applicazione usa la gestione delle eccezioni C++ in modo intensivo. Puoi quindi compattare il codice binario usando l'opzione /d2FH4, che è attiva per impostazione predefinita nei nuovi progetti creati con Visual Studio 2019, versione 16.3 e successive.That improvement doesn't affect code size—as described below in Optimized EH code-gen, if your application uses C++ exception handling heavily, then you can shrink your binary by using the /d2FH4 option, which is on by default in new projects created with Visual Studio 2019 16.3, and later.

Conversione boxing più efficienteMore efficient boxing

Quando viene usato in un'applicazione XAML, winrt::box_value è ora più efficiente (vedi Boxing e unboxing).When used in a XAML application, winrt::box_value is now more efficient (see Boxing and unboxing). Anche per le applicazioni che eseguono molte conversioni boxing potrai notare una riduzione della dimensione del codice.Applications that do a lot of boxing will also notice a reduction in code size.

Supporto per l'implementazione di interfacce COM che implementano IInspectableSupport for implementing COM interfaces that implement IInspectable

Se devi implementare un'interfaccia COM (non Windows Runtime) che sta semplicemente implementando IInspectable, puoi ora eseguire questa operazione con C++/WinRT.If you need to implement a (non-Windows-Runtime) COM interface that just happens to implement IInspectable, then you can now do so with C++/WinRT. Vedi Interfacce COM che implementano IInspectable.See COM interfaces that implement IInspectable.

Miglioramenti del blocco dei moduliModule-locking improvements

Il controllo del blocco dei moduli consente ora sia scenari di hosting personalizzati sia l'eliminazione del blocco a livello di modulo.Control over module-locking now allows both custom hosting scenarios and the elimination of module-level locking altogether. Vedi la richiesta pull sui miglioramenti del blocco dei moduli.See Module-locking improvements.

Supporto per le informazioni sugli errori di runtime non WindowsSupport for non-Windows-Runtime error information

Alcune API (anche di Windows Runtime) segnalano errori senza usare API di origine degli errori di Windows Runtime.Some APIs (even some Windows Runtime APIs) report errors without using Windows Runtime error origination APIs. In casi come questi, C++/WinRT ora ricorre all'uso delle informazioni sugli errori COM.In cases like that, C++/WinRT now falls back to using COM error info. Vedi Supporto di C++/WinRT per informazioni sugli errori non WinRT.See C++/WinRT support for non-WinRT error information.

Abilitazione del supporto per i moduli C++Enable C++ module support

Il supporto per i moduli C++ è di nuovo disponibile, ma solo in via sperimentale.C++ module support is back, but only in an experimental form. La funzionalità non è ancora completa nel compilatore C++.The feature isn't complete in the C++ compiler, as yet.

Ripresa più efficiente delle coroutineMore efficient coroutine resumption

Le coroutine C++/WinRT funzionano già bene, ma siamo costantemente alla ricerca di soluzioni per migliorarle.C++/WinRT coroutines already perform well, but we continue to look for ways to improve that. Vedi la richiesta pull su come migliorare la scalabilità della ripresa delle coroutine.See Improve scalability of coroutine resumption.

Nuovi helper asincroni when_all e when_anyNew when_all and when_any async helpers

La funzione helper when_all crea un oggetto IAsyncAction, che viene completato al termine di tutti gli elementi awaitable forniti.The when_all helper function creates an IAsyncAction object that completes when all of the supplied awaitables have completed. La funzione helper when_any crea un oggetto IAsyncAction, che viene completato al termine di uno degli elementi awaitable forniti.The when_any helper creates an IAsyncAction that completes when any of the supplied awaitables have completed.

Vedi le richieste pull su come aggiungere un helper asincrono when_any e un helper asincrono when_all.See Add when_any async helper and Add when_all async helper.

Altre ottimizzazioni e aggiunteOther optimizations and additions

Abbiamo introdotto anche numerose correzioni di bug e ottimizzazioni e aggiunte secondarie, inclusi vari miglioramenti per semplificare il debug e ottimizzare gli elementi interni e le implementazioni predefinite.In addition, many bug fixes and minor optimizations and additions have been introduced, including various improvements to simplify debugging and to optimize internals and default implementations. Segui questo collegamento per un elenco completo: https://github.com/microsoft/xlang/pulls?q=is%3Apr+is%3Aclosed.Follow this link for an exhaustive list: https://github.com/microsoft/xlang/pulls?q=is%3Apr+is%3Aclosed.

Funzionalità nuove e aggiornate di C++/WinRT 2.0News, and changes, in C++/WinRT 2.0

Per altre informazioni sull'estensione di Visual Studio C++/WinRT (VSIX), sul pacchetto NuGet Microsoft.Windows.CppWinRT e sullo strumento cppwinrt.exe, incluse le istruzioni su come installarli, vedi Supporto di Visual Studio per C++/WinRT, XAML, l'estensione VSIX e il pacchetto NuGet.For more info about the C++/WinRT Visual Studio Extension (VSIX), the Microsoft.Windows.CppWinRT NuGet package, and the the cppwinrt.exe tool—including how to acquire and install them—see Visual Studio support for C++/WinRT, XAML, the VSIX extension, and the NuGet package.

Modifiche all'estensione di Visual Studio C++/WinRT (VSIX) per la versione 2.0Changes to the C++/WinRT Visual Studio Extension (VSIX) for version 2.0

  • Il visualizzatore di debug supporta ora Visual Studio 2019, oltre a continuare a supportare Visual Studio 2017.The debug visualizer now supports Visual Studio 2019; as well as continuing to support Visual Studio 2017.
  • Sono state apportate numerose correzioni di bug.Numerous bug fixes have been made.

Modifiche al pacchetto NuGet Microsoft.Windows.CppWinRT per la versione 2.0Changes to the Microsoft.Windows.CppWinRT NuGet package for version 2.0

  • Nel pacchetto NuGet Microsoft.Windows.CppWinRT è ora incluso lo strumento cppwinrt.exe che genera su richiesta intestazioni di proiezione della piattaforma per ogni progetto.The cppwinrt.exe tool is now included in the Microsoft.Windows.CppWinRT NuGet package, and the tool generates platfom projection headers for each project on demand. Pertanto, lo strumento cppwinrt.exe non dipende più da Windows SDK, anche se viene ancora distribuito con l'SDK per motivi di compatibilità.Consequently, the cppwinrt.exe tool no longer depends on the Windows SDK (although, the tool still ships with the SDK for compatibility reasons).
  • cppwinrt.exe genera ora le intestazioni di proiezione in ogni cartella intermedia specifica della configurazione o della piattaforma ($IntDir) per consentire la generazione di build parallele.cppwinrt.exe now generates projection headers under each platform/configuration-specific intermediate folder ($IntDir) to enable parallel builds.
  • Il supporto per la compilazione in C++/WinRT (props/targets) è ora interamente documentato, offrendo così la possibilità di personalizzare i file di progetto in modo manuale.The C++/WinRT build support (props/targets) is now fully documented, in case you want to manually customize your project files. Vedi il file readme del pacchetto NuGet Microsoft.Windows.CppWinRT.See the Microsoft.Windows.CppWinRT NuGet package readme.
  • Sono state apportate numerose correzioni di bug.Numerous bug fixes have been made.

Modifiche a C++/WinRT per la versione 2.0Changes to C++/WinRT for version 2.0

Open sourceOpen source

A partire da un file di metadati di Windows Runtime (.winmd), lo strumento cppwinrt.exe genera una libreria C++ standard che proietta le API descritte nei metadati.The cppwinrt.exe tool takes a Windows Runtime metadata (.winmd) file, and generates from it a header-file-based standard C++ library that projects the APIs described in the metadata. Puoi così utilizzare tali API dal codice C++/WinRT.That way, you can consume those APIs from your C++/WinRT code.

Questo strumento è ora un progetto completamente open source, disponibile su GitHub.This tool is now an entirely open source project, available on GitHub. Visita Microsoft/cppwinrt.Visit Microsoft/cppwinrt.

Librerie xlangxlang libraries

Una libreria di sole intestazioni completamente portabile (per l'analisi del formato di metadati ECMA-335 usato da Windows Runtime) costituirà la base di tutti gli strumenti di Windows Runtimes e xlang in futuro.A completely portable header-only library (for parsing the ECMA-335 metadata format used by the Windows Runtime) forms the basis of all the Windows Runtime and xlang tooling going forward. In particolare, abbiamo anche riscritto completamente lo strumento cppwinrt.exe usando le librerie xlang.Notably, we also rewrote the cppwinrt.exe tool from the ground up using the xlang libraries. Ciò consentirà di eseguire query sui metadati più accurate, risolvendo alcuni annosi problemi relativi alla proiezione del linguaggio C++/WinRT.This provides far more accurate metadata queries, solving a few long-standing issues with the C++/WinRT language projection.

Minori dipendenzeFewer dependencies

Grazie al lettore di metadati xlang, lo strumento cppwinrt.exe ha meno dipendenze.Due to the xlang metadata reader, the cppwinrt.exe tool itself has fewer dependencies. È quindi molto più flessibile, oltre a essere utilizzabile in diversi scenari, soprattutto in ambienti di compilazione vincolati.This makes it far more flexible, as well as being usable in more scenarios—especially in constrained build environments. In particolare, non dipende più da RoMetadata.dll.Notably, it no longer relies on RoMetadata.dll.

Ecco le dipendenze per cppwinrt.exe 2.0.These are the dependencies for cppwinrt.exe 2.0.

  • ADVAPI32.dllADVAPI32.dll
  • KERNEL32.dllKERNEL32.dll
  • SHLWAPI.dllSHLWAPI.dll
  • XmlLite.dllXmlLite.dll

Tutte queste DLL sono disponibili non solo in Windows 10, ma anche in Windows 7 e Windows Vista.All of those DLLs are available not only on Windows 10, but all the way down to Windows 7, and even Windows Vista. Se lo vuoi, il server di compilazione precedente che esegue Windows 7 può ora eseguire cppwinrt.exe per generare intestazioni C++ per il progetto.If you want it to, your old build server running Windows 7 can now run cppwinrt.exe to generate C++ headers for your project. Con un po' di lavoro, se ti interessa puoi anche eseguire C++/WinRT in Windows 7.With a bit of work, you can even run C++/WinRT on Windows 7, if that interests you.

Confronta l'elenco sopra riportato con queste dipendenze di cppwinrt.exe 1.0.Contrast the list above with these dependencies, which cppwinrt.exe 1.0 has.

  • ADVAPI32.dllADVAPI32.dll
  • SHELL32.dllSHELL32.dll
  • api-ms-win-core-file-l1-1-0.dllapi-ms-win-core-file-l1-1-0.dll
  • XmlLite.dllXmlLite.dll
  • api-ms-win-core-libraryloader-l1-2-0.dllapi-ms-win-core-libraryloader-l1-2-0.dll
  • api-ms-win-core-processenvironment-l1-1-0.dllapi-ms-win-core-processenvironment-l1-1-0.dll
  • RoMetadata.dllRoMetadata.dll
  • SHLWAPI.dllSHLWAPI.dll
  • KERNEL32.dllKERNEL32.dll
  • api-ms-win-core-rtlsupport-l1-1-0.dllapi-ms-win-core-rtlsupport-l1-1-0.dll
  • api-ms-win-core-heap-l1-1-0.dllapi-ms-win-core-heap-l1-1-0.dll
  • api-ms-win-core-timezone-l1-1-0.dllapi-ms-win-core-timezone-l1-1-0.dll
  • api-ms-win-core-console-l1-1-0.dllapi-ms-win-core-console-l1-1-0.dll
  • api-ms-win-core-localization-l1-2-0.dllapi-ms-win-core-localization-l1-2-0.dll
  • OLEAUT32.dllOLEAUT32.dll
  • api-ms-win-core-winrt-error-l1-1-0.dllapi-ms-win-core-winrt-error-l1-1-0.dll
  • api-ms-win-core-winrt-error-l1-1-1.dllapi-ms-win-core-winrt-error-l1-1-1.dll
  • api-ms-win-core-winrt-l1-1-0.dllapi-ms-win-core-winrt-l1-1-0.dll
  • api-ms-win-core-winrt-string-l1-1-0.dllapi-ms-win-core-winrt-string-l1-1-0.dll
  • api-ms-win-core-synch-l1-1-0.dllapi-ms-win-core-synch-l1-1-0.dll
  • api-ms-win-core-threadpool-l1-2-0.dllapi-ms-win-core-threadpool-l1-2-0.dll
  • api-ms-win-core-com-l1-1-0.dllapi-ms-win-core-com-l1-1-0.dll
  • api-ms-win-core-com-l1-1-1.dllapi-ms-win-core-com-l1-1-1.dll
  • api-ms-win-core-synch-l1-2-0.dllapi-ms-win-core-synch-l1-2-0.dll

Attributo noexcept di Windows RuntimeThe Windows Runtime noexcept attribute

Windows Runtime ha un nuovo attributo [noexcept] che puoi aggiungere ai metodi e alle proprietà in MIDL 3.0.The Windows Runtime has a new [noexcept] attribute, which you may use to decorate your methods and properties in MIDL 3.0. La presenza dell'attributo indica agli strumenti di supporto che l'implementazione non genera un'eccezione (né restituisce un errore HRESULT).The presence of the attribute indicates to supporting tools that your implementation doesn't throw an exception (nor return a failing HRESULT). Ciò consente proiezioni del linguaggio per ottimizzare la generazione di codice, evitando così il sovraccarico per la gestione delle eccezioni necessario per supportare eventuali errori delle chiamate all'interfaccia binaria dell'applicazione (ABI).This allows language projections to optimize code-generation by avoiding the exception-handling overhead that's required to support application binary interface (ABI) calls that can potentially fail.

C++/WinRT sfrutta questo vantaggio generando implementazioni noexcept C++ di codice per l'utilizzo e la creazione di dati.C++/WinRT takes advantage of this by producing C++ noexcept implementations of both the consuming and authoring code. Se hai metodi o proprietà di API che non generano errori e la dimensione del codice è per te motivo di preoccupazione, puoi prendere in considerazione questo attributo.If you have API methods or properties that are fail-free, and you're concerned about code size, then you can investigate this attribute.

Generazione del codice ottimizzataOptimized code-generation

C++/WinRT genera ora (dietro le quinte) codice sorgente C++ ancora più efficiente, consentendo così al compilatore C++ di generare codice binario il più compatto ed efficiente possibile.C++/WinRT now generates even more efficient C++ source code (behind the scenes) so that the C++ compiler can produce the smallest and most efficient binary code possible. Molti dei miglioramenti sono stati pensati per ridurre il costo legato alla gestione delle eccezioni, evitando inutili informazioni di correzione.Many of the improvements are geared toward reducing the cost of exception-handling by avoiding unnecessary unwind information. Nei file binari che usano grandi quantità di codice C++/WinRT si noterà una riduzione delle dimensioni del codice di circa il 4%.Binaries that use large amounts of C++/WinRT code will see roughly a 4% reduction in code size. Il codice risulta anche più efficiente (e viene eseguito più rapidamente) grazie al numero minore di istruzioni.The code is also more efficient (it runs faster) due to the reduced instruction count.

Questi miglioramenti si basano su una nuova funzionalità di interoperabilità disponibile per gli sviluppatori.These improvements rely on a new interop feature that's available to you, as well. Tutti i tipi C++/WinRT che sono proprietari di risorse includono ora un costruttore per acquisire direttamente la proprietà, evitando l'approccio precedente in due fasi.All of the C++/WinRT types that are resource owners now include a constructor for taking ownership directly, avoiding the previous two-step approach.

ABI::Windows::Foundation::IStringable* raw = ...

IStringable projected(raw, take_ownership_from_abi);

printf("%ls\n", projected.ToString().c_str());

Generazione del codice con gestione delle eccezioni ottimizzataOptimized exception-handling (EH) code-generation

Questa modifica si integra con il lavoro svolto dal team Microsoft dedicato all'ottimizzazione del codice C++ per ridurre il costo legato alla gestione delle eccezioni.This change complements work that has been done by the Microsoft C++ optimizer team to reduce the cost of exception-handling. Se nel codice usi una notevole quantità di interfacce binarie di applicazione (ABI), ad esempio COM, puoi osservare che una grande quantità di codice segue questo modello.If you use application binary interfaces (ABIs) (such as COM) heavily in your code, then you'll observe a lot of code following this pattern.

int32_t Function() noexcept
{
    try
    {
        // code here constitutes unique value.
    }
    catch (...)
    {
        // code here is always duplicated.
    }
}

Lo stesso C++/WinRT genera questo modello per ogni API implementata.C++/WinRT itself generates this pattern for every API that's implemented. Con migliaia di funzioni API, qualsiasi ottimizzazione può avere un peso rilevante.With thousands of API functions, any optimization here can be significant. In passato, l'ottimizzatore non rilevava che i blocchi catch sono tutti identici e quindi duplicava una grande quantità di codice attorno a ogni interfaccia ABI, contribuendo così alla convinzione che l'uso di eccezioni nel codice di sistema ha l'effetto di generare file binari di grandi dimensioni.In the past, the optimizer wouldn't detect that those catch blocks are all identical, so it was duplicating a lot of code around each ABI (which in turn contributed to the belief that using exceptions in system code produces large binaries). A partire da Visual Studio 2019, tuttavia, il compilatore C++ comprime tutti i funclet catch e archivia solo quelli univoci.However, from Visual Studio 2019 on, the C++ compiler folds all of those catch funclets, and only stores those that are unique. Questo comportamento consente di ottenere un'ulteriore riduzione complessiva del 18% nella dimensione del codice per i file binari che si basano in maniera significativa su questo modello.The result is a further and overall 18% reduction in code size for binaries that rely heavily on this pattern. Non solo il codice di gestione delle eccezioni è ora più efficiente rispetto all'uso di codici restituiti, ma anche il rischio di ottenere file binari più grandi è ormai un ricordo del passato.Not only is EH code now more efficient than using return codes, but also the concern about larger binaries is now a thing of the past.

Miglioramenti incrementali delle buildIncremental build improvements

Lo strumento cppwinrt.exe confronta ora l'output di un file di codice sorgente o di intestazione generato con il contenuto dei file presenti sul disco e scrive il file solo se è stato effettivamente modificato.The cppwinrt.exe tool now compares the output of a generated header/source file against the contents of any existing file on disk, and it only writes out the file if the file has in fact changed. Ciò consente di risparmiare molto tempo nelle operazioni di I/O su disco e assicura che i file non vengano considerati "dirty" dal compilatore C++.This saves considerable time with disk I/O, and it ensures that the files are not considered "dirty" by the C++ compiler. In questo modo, la ricompilazione viene evitata, o almeno ridotta, in molti casi.The result is that recompilation is avoided, or reduced, in many cases.

Generazione completa delle interfacce genericheGeneric interfaces are now all generated

Grazie al lettore di metadati xlang, C++/WinRT genera ora dai metadati tutte le interfacce con parametri o generiche.Due to the xlang metadata reader, C++/WinRT now generates all parameterized, or generic, interfaces from metadata. Le interfacce come Windows::Foundation::Collections::IVector<T> vengono ora generate dai metadati anziché essere scritte manualmente in winrt/base.h.Interfaces such as Windows::Foundation::Collections::IVector<T> are now generated from metadata rather than hand-written in winrt/base.h. Di conseguenza, la dimensione di winrt/base.h viene dimezzata e le ottimizzazioni vengono generate direttamente nel codice (un'operazione piuttosto difficile con l'approccio manuale).The result is that the size of winrt/base.h has been cut in half, and that optimizations are generated right into the code (which was tricky to do with the hand-rolled approach).

Importante

Le interfacce come quelle riportate nell'esempio vengono ora inserite nelle rispettive intestazioni di spazio dei nomi, anziché in winrt/base.h.Interfaces such as the example given now appear in their respective namespace headers, rather than in winrt/base.h. Pertanto, per usare l'interfaccia, dovrai includere l'intestazione di spazio dei nomi appropriata, se non lo hai già fatto.So, if you have not already done so, you'll have to include the appropriate namespace header in order to use the interface.

Ottimizzazioni dei componentiComponent optimizations

Questo aggiornamento introduce il supporto per diverse ottimizzazioni aggiuntive per C++/WinRT che richiedono il consenso esplicito, illustrate nelle sezioni seguenti.This update adds support for several additional opt-in optimizations for C++/WinRT, described in the sections below. Poiché queste ottimizzazioni costituiscono modifiche importanti, per il cui supporto possono essere necessarie alcune piccole modifiche, dovrai attivarle in modo esplicito.Because these optimizations are breaking changes (which you may need to make minor changes to support), you'll need to turn them on explicitly. In Visual Studio imposta la proprietà del progetto Proprietà comuni > C++/WinRT > Ottimizzato su .In Visual Studio, set project property Common Properties > C++/WinRT > Optimized to Yes. Questa operazione ha come risultato l'aggiunta di <CppWinRTOptimized>true</CppWinRTOptimized> al file del progettoThat has the effect of adding <CppWinRTOptimized>true</CppWinRTOptimized> to your project file. e ha lo stesso effetto dell'impostazione dell'opzione -opt[imize] quando viene richiamato cppwinrt.exe dalla riga di comando.And it has the same effect as adding the -opt[imize] switch when invoking cppwinrt.exe from the command line.

Nei nuovi progetti (creati a partire da un modello di progetto), -opt viene usato per impostazione predefinita.A new project (from a project template) will use -opt by default.

Costruzione uniforme e accesso diretto all'implementazioneUniform construction, and direct implementation access

Queste due ottimizzazioni consentono a un componente di accedere direttamente ai rispettivi tipi di implementazione, anche quando usa solo tipi proiettati.These two optimizations allow your component direct access to its own implementation types, even when it's only using the projected types. Non devi usare make, make_self o get_self se vuoi semplicemente usare la superficie di API pubblica.There's no need to use make, make_self, nor get_self if you simply want to use the public API surface. Le chiamate verranno compilate fino alle chiamate dirette nell'implementazione e anche queste potrebbero essere interamente impostate come inline.Your calls will compile down to direct calls into the implementation, and those might even be entirely inlined.

Per altre informazioni ed esempi di codice, vedi Acconsentire esplicitamente alla costruzione uniforme e all'accesso diretto all'implementazione.For more info, and code examples, see Opt in to uniform construction, and direct implementation access.

Factory con cancellazione di tipiType-erased factories

Questa ottimizzazione consente di evitare le dipendenze #include in module.g.cpp in modo che non sia necessario ripetere la compilazione ogni volta che viene modificata una singola classe di implementazione.This optimization avoids the #include dependencies in module.g.cpp so that it need not be recompiled every time any single implementation class happens to change. Questo ha come risultato un miglioramento delle prestazioni di compilazione.The result is improved build performance.

module.g.cpp più intelligente ed efficiente per progetti di grandi dimensioni con più librerieSmarter and more efficient module.g.cpp for large projects with multiple libs

Il file module.g.cpp contiene ora anche due helper componibili aggiuntivi, denominati winrt_can_unload_now e winrt_get_activation_factory.The module.g.cpp file now also contains two additional composable helpers, named winrt_can_unload_now, and winrt_get_activation_factory. Questi helper sono stati ideati per progetti di grandi dimensioni, in cui una DLL è composta da un certo numero di librerie, ciascuna con specifiche classi di runtime.These have been designed for larger projects where a DLL is composed of a number of libs, each with its own runtime classes. In una situazione di questo tipo, è necessario riunire manualmente le funzioni DllGetActivationFactory e DllCanUnloadNow della DLL.In that situation, you need to manually stitch together the DLL's DllGetActivationFactory and DllCanUnloadNow. Questi helper semplificano notevolmente questa operazione, evitando errori di origine non corretta.These helpers make it much easier for you to do that, by avoiding spurious origination errors. Il flag -lib dello strumento cppwinrt.exe può essere usato anche per assegnare a ogni singola libreria uno specifico preambolo (anziché winrt_xxx) in modo che le funzioni di ogni libreria vengano denominate singolarmente e quindi combinate in modo non ambiguo.The cppwinrt.exe tool's -lib flag may also be used to give each individual lib its own preamble (rather than winrt_xxx) so that each lib's functions may be individually named, and thus combined unambiguously.

Supporto per coroutineCoroutine support

Il supporto per coroutine è incluso automaticamente.Coroutine support is included automatically. In precedenza, il supporto si trovava in più posizioni, e questo era considerato come troppo limitante.Previously, the support resided in multiple places, which we felt was too limiting. Di conseguenza, temporaneamente per la versione 2.0, era richiesto un file di intestazione winrt/coroutine.h che ora non è più necessario.And then temporarily for v2.0, a winrt/coroutine.h header file was necessary, but that's no longer needed. Poiché le interfacce asincrone di Windows Runtime vengono generate in modo automatico, anziché essere scritte manualmente, si trovano ora winrt/Windows.Foundation.h.Since the Windows Runtime async interfaces are now generated, rather than hand-written, they now reside in winrt/Windows.Foundation.h. Ciò significa che gli helper di coroutine come resume_foreground, oltre a essere più gestibili e supportabili, non devono più essere aggiunti alla fine di una specifica intestazione di spazio dei nomi.Apart from being more maintainable and supportable, it means that coroutine helpers such as resume_foreground no longer have to be tacked on to the end of a specific namespace header. Possono invece includere più naturalmente le rispettive dipendenze.Instead, they can more naturally include their dependencies. In questo modo, resume_foreground può supportare il ripristino non solo in base a un determinato oggetto Windows::UI::Core::CoreDispatcher, ma anche in base a un determinato oggetto Windows::System::DispatcherQueue.This further allows resume_foreground to support not only resuming on a given Windows::UI::Core::CoreDispatcher, but it can now also support resuming on a given Windows::System::DispatcherQueue. In precedenza, uno solo dei due poteva essere supportato, poiché la definizione poteva risiedere in un solo spazio dei nomi.Previously, only one could be supported; but not both, since the definition could only reside in one namespace.

Ecco un esempio del supporto per DispatcherQueue.Here's an example of the DispatcherQueue support.

...
#include <winrt/Windows.System.h>
using namespace Windows::System;
...
fire_and_forget Async(DispatcherQueueController controller)
{
    bool queued = co_await resume_foreground(controller.DispatcherQueue());
    assert(queued);

    // This is just to simulate queue failure...
    co_await controller.ShutdownQueueAsync();

    queued = co_await resume_foreground(controller.DispatcherQueue());
    assert(!queued);
}

Gli helper di coroutine sono stati ora aggiornati con [[nodiscard]], migliorandone la facilità d'uso.The coroutine helpers are now also decorated with [[nodiscard]], thereby improving their usability. Se dimentichi (o non ti rendi conto) di dover applicare co_await sugli helper per consentirne il funzionamento, grazie a [[nodiscard]] viene ora generato un avviso del compilatore per segnalare tale errore.If you forget to (or don't realize you have to) co_await them for them to work then, due to [[nodiscard]], such mistakes now produce a compiler warning.

Diagnosi facilitata delle allocazioni stack diretteHelp with diagnosing direct (stack) allocations

Poiché i nomi delle classi di implementazione e proiettate coincidono (per impostazione predefinita) e si differenziano solo per lo spazio dei nomi, è possibile confonderle e creare accidentalmente un'implementazione dello stack, invece di usare la famiglia di helper make.Since the projected and implementation class names are (by default) the same, and only differ by namespace, it's possible to mistake the one for the other, and to accidentally create an implementation on the stack, rather than using the make family of helpers. La diagnosi di casi come questo può non essere facile, poiché l'oggetto potrebbe essere eliminato mentre sono ancora presenti riferimenti in sospeso.This can be hard to diagnose in some cases, because the object may be destroyed while outstanding references are still in flight. Questa diagnosi viene ora eseguita tramite un'asserzione, per le compilazioni di debug.An assertion now picks this up, for debug builds. Anche se l'asserzione non rileva l'allocazione dello stack all'interno di una coroutine, è comunque utile per intercettare la maggior parte degli errori di questo tipo.While the assertion doesn't detect stack allocation inside a coroutine, it's nevertheless helpful in catching most such mistakes.

Per altre informazioni, vedi Diagnosi delle allocazioni dirette.For more info, see Diagnosing direct allocations.

Helper di acquisizione e delegati variadic miglioratiImproved capture helpers, and variadic delegates

Questo aggiornamento corregge la limitazione relativa agli helper di acquisizione supportando anche i tipi proiettati.This update fixes the limitation with the capture helpers by supporting projected types as well. Questo problema si verifica di tanto in tanto con le API di interoperabilità di Windows Runtime, quando restituiscono un tipo proiettato.This comes up now and then with the Windows Runtime interop APIs, when they return a projected type.

Questo aggiornamento aggiunge anche il supporto per get_strong e get_weak durante la creazione di un delegato variadic (non di Windows Runtime).This update also adds support for get_strong and get_weak when creating a variadic (non-Windows Runtime) delegate.

Supporto per la distruzione posticipata e uso sicuro di QI durante la distruzioneSupport for deferred destruction and safe QI during destruction

Nel distruttore di un oggetto di una classe di runtime non è insolito chiamare un metodo che avvia temporaneamente il conteggio dei riferimenti.It's not uncommon in the destructor of a runtime class object to call a method that temporarily bumps the reference count. Quando il conteggio dei riferimenti restituisce zero, l'oggetto viene distrutto una seconda volta.When the reference count returns to zero, the object destructs a second time. In un'applicazione XAML può essere necessario eseguire un metodo QueryInterface (QI) in un distruttore per chiamare un'implementazione per la pulizia verso l'alto o il basso nella gerarchia.In a XAML application, you might need to perform a QueryInterface (QI) in a destructor, in order to call some cleanup implementation up or down the hierarchy. Tuttavia, il conteggio dei riferimenti dell'oggetto ha già raggiunto lo zero e quindi QI determina un rimbalzo del conteggio dei riferimenti.But the object's reference count has already reached zero, so that QI constitutes a reference count bounce, too.

Questo aggiornamento permette di evitare che il numero dei riferimenti aumenti di nuovo dopo aver raggiunto lo zero, consentendo comunque a QI di usare eventuali riferimenti temporanei necessari durante la distruzione.This update adds support for debouncing the reference count, ensuring that once it reaches zero it can never be resurrected; while still allowing you to QI for any temporary that you require during destruction. Questa routine è inevitabile in determinati controlli e applicazioni XAML e C++/WinRT consente ora di gestirla correttamente.This procedure is unavoidable in certain XAML applications/controls, and C++/WinRT is now resilient to it.

Puoi posticipare la distruzione fornendo una funzione final_release statica per il tipo di implementazione.You can defer destruction by providing a static final_release function on your implementation type. L'ultimo puntatore rimanente per l'oggetto, sotto forma di std::unique_ptr, viene passato alla funzione final_release.The last remaining pointer to the object, in the form of a std::unique_ptr, is passed to your final_release. Puoi quindi scegliere di spostare la proprietà di tale puntatore in un altro contesto.You can then opt to move ownership of that pointer to some other context. Puoi chiamare senza alcun rischio un metodo QI sul puntatore senza attivare una doppia distruzione.It's safe for you to QI the pointer without triggering a double-destruction. Ma nel punto in cui l'oggetto viene distrutto la differenza del conteggio dei riferimenti deve essere zero.But the net change to the reference count must be zero at the point you destruct the object.

Il valore restituito di final_release può essere void, un oggetto di operazione asincrona come IAsyncAction o winrt::fire_and_forget.The return value of final_release can be void, an asynchronous operation object such as IAsyncAction, or winrt::fire_and_forget.

struct Sample : implements<Sample, IStringable>
{
    hstring ToString()
    {
        return L"Sample";
    }

    ~Sample()
    {
        // Called when the unique_ptr below is reset.
    }

    static void final_release(std::unique_ptr<Sample> self) noexcept
    {
        // Move 'self' as needed to delay destruction.
    }
};

Nell'esempio seguente, dopo il rilascio finale di MainPage, viene eseguita una chiamata a final_release.In the example below, once the MainPage is released (for the final time), final_release is called. Questa funzione rimane cinque secondi in attesa (nel pool di thread) e quindi riprende l'esecuzione usando l'oggetto Dispatcher della pagina (per il cui funzionamento è necessario QI/AddRef/Release).That function spends five seconds waiting (on the thread pool), and then it resumes using the page's Dispatcher (which requires QI/AddRef/Release to work). Pulisce quindi una risorsa su tale thread dell'interfaccia utente.It then cleans up a resource on that UI thread. Infine esegue la cancellazione di unique_ptr, determinando in tal modo la chiamata al distruttore MainPage.And finally it clears the unique_ptr, which causes the MainPage destructor to actually get called. Anche in questo distruttore viene chiamato DataContext e questo richiede l'esecuzione di QI per IFrameworkElement.Even in that destructor, DataContext is called, which requires a QI for IFrameworkElement.

Non è indispensabile implementare final_release come una coroutine,You don't have to implement your final_release as a coroutine. ma questa soluzione può essere utile e consente di spostare la distruzione in un altro thread, come avviene in questo esempio.But that does work, and it makes it very simple to move destruction to a different thread, which is what's happening in this example.

struct MainPage : PageT<MainPage>
{
    MainPage()
    {
    }

    ~MainPage()
    {
        DataContext(nullptr);
    }

    static IAsyncAction final_release(std::unique_ptr<MainPage> self)
    {
        co_await 5s;

        co_await resume_foreground(self->Dispatcher());
        co_await self->resource.CloseAsync();

        // The object is destructed normally at the end of final_release,
        // when the std::unique_ptr<MyClass> destructs. If you want to destruct
        // the object earlier than that, then you can set *self* to `nullptr`.
        self = nullptr;
    }
};

Per altre informazioni, vedi Distruzione posticipata.For more info, see Deferred destruction.

Supporto migliorato per l'ereditarietà delle interfacce singole di tipo COMImproved support for COM-style single interface inheritance

Come per la programmazione di Windows Runtime, C++/WinRT viene usato anche per creare e utilizzare API solo COM.As well as for Windows Runtime programming, C++/WinRT is also used to author and consume COM-only APIs. Questo aggiornamento rende possibile l'implementazione di un server COM in cui è presente una gerarchia di interfacce.This update makes it possible to implement a COM server where there exists an interface hierarchy. Questo non è necessario per Windows Runtime, ma lo è per alcune implementazioni di COM.This isn't required for the Windows Runtime; but it is required for some COM implementations.

Gestione corretta dei parametri outCorrect handling of out params

La gestione dei parametri out può talvolta presentare difficoltà, soprattutto per le matrici di Windows Runtime.It can be tricky to work with out params; particularly Windows Runtime arrays. Con questo aggiornamento, C++/WinRT è molto più affidabile e resiliente agli errori nella gestione di matrici e parametri out, indipendentemente dal fatto che tali parametri risultino da una proiezione del linguaggio o da uno sviluppatore di COM che sta usando l'interfaccia ABI non elaborata e ha commesso l'errore di non inizializzare le variabili in modo coerente.With this update, C++/WinRT is considerably more robust and resilient to mistakes when it comes to out params and arrays; whether those parameters arrive via a language projection, or from a COM developer who's using the raw ABI, and who's making the mistake of not initializing variables consistently. In entrambi i casi, C++/WinRT gestisce in modo corretto questa situazione, passando i tipi proiettati all'interfaccia ABI (ricordando di rilasciare le risorse) e azzerando o cancellando i parametri che arrivano attraverso l'interfaccia ABI.In either case, C++/WinRT now does the right thing when it comes to handing off projected types to the ABI (by remembering to release any resources), and when it comes to zeroing out or clearing out parameters that arrive across the ABI.

Gestione affidabile dei token non validi da parte degli eventiEvents now handle invalid tokens reliably

L'implementazione di winrt::event gestisce ora correttamente il caso in cui il metodo remove viene chiamato con un valore di token non valido, ovvero un valore non presente nella matrice.The winrt::event implementation now gracefully handles the case where its remove method is called with an invalid token value (a value that's not present in the array).

Distruzione delle variabili locali della coroutine prima della restituzione del risultatoCoroutine local variables are now destroyed before the coroutine returns

Il metodo tradizionale di implementazione di un tipo di coroutine può consentire la distruzione delle variabili locali all'interno della coroutine dopo la restituzione del risultato o il completamento della coroutine, anziché prima della sospensione finale.The traditional way of implementing a coroutine type may allow local variables within the coroutine to be destroyed after the coroutine returns/completes (rather than prior to final suspension). La ripresa di qualsiasi oggetto waiter viene ora posticipata fino alla sospensione finale, per evitare questo problema e offrire anche altri vantaggi.The resumption of any waiter is now deferred until final suspension, in order to avoid this problem and to accrue other benefits.

Novità e modifiche in Windows SDK versione 10.0.17763.0 (Windows 10, versione 1809)News, and changes, in Windows SDK version 10.0.17763.0 (Windows 10, version 1809)

La tabella seguente contiene novità e modifiche per C++/WinRT in Windows SDK versione 10.0.17763.0 (Windows 10, versione 1809).The table below contains news and changes for C++/WinRT in the Windows SDK version 10.0.17763.0 (Windows 10, version 1809).

Funzionalità nuova o modificataNew or changed feature Altre informazioniMore info
Modifica importante.Breaking change. Per la compilazione, C++/WinRT non dipende da intestazioni di Windows SDK.For it to compile, C++/WinRT doesn't depend on headers from the Windows SDK. Vedi più avanti Isolamento dai file di intestazione di Windows SDK.See Isolation from Windows SDK header files, below.
Il formato del sistema dei progetti di Visual Studio è stato modificato.The Visual Studio project system format has changed. Vedi più avanti Come impostare una versione più recente di Windows SDK come destinazione per il progetto C++/WinRT.See How to retarget your C++/WinRT project to a later version of the Windows SDK, below.
Sono disponibili nuove funzioni e classi di base che consentono di passare un oggetto raccolta a una funzione di Windows Runtime o implementare proprietà e i tipi di raccolta personalizzati.There are new functions and base classes to help you pass a collection object to a Windows Runtime function, or to implement your own collection properties and collection types. Vedi Gruppi di prodotti con C++/WinRT.See Collections with C++/WinRT.
Con le classi di runtime C++/WinRT può essere usata l'estensione di markup {Binding}.You can use the {Binding} markup extension with your C++/WinRT runtime classes. Per altre informazioni ed esempi di codice, vedi Panoramica del data binding.For more info, and code examples, see Data binding overview.
Il supporto per l'annullamento di una coroutine consente di registrare un callback di annullamento.Support for canceling a coroutine allows you to register a cancellation callback. Per altre informazioni ed esempi di codice, vedi Annullamento di un'operazione asincrona e callback di annullamento.For more info, and code examples, see Canceling an asynchronous operation, and cancellation callbacks.
Quando crei un delegato che punta a una funzione membro, puoi stabilire un riferimento sicuro o debole all'oggetto corrente (anziché usare un puntatore this non elaborato) nel punto in cui il gestore è registrato.When creating a delegate pointing to a member function, you can establish a strong or a weak reference to the current object (instead of a raw this pointer) at the point where the handler is registered. Per altre informazioni ed esempi di codice, vedi la sottosezione Se una funzione membro viene usata come delegato nella sezione Accesso sicuro al puntatore this con un delegato di gestione degli eventi.For more info, and code examples, see the If you use a member function as a delegate sub-section in the section Safely accessing the this pointer with an event-handling delegate.
Sono stati corretti bug rivelati dalla maggiore conformità di Visual Studio allo standard C++.Bugs are fixed that were uncovered by Visual Studio's improved conformance to the C++ standard. La toolchain LLVM and Clang viene inoltre sfruttata in modo più efficace per convalidare la conformità agli standard di C++/WinRT.The LLVM and Clang toolchain is also better leveraged to validate C++/WinRT's standards conformance. Non si verificherà più il problema descritto in Per quale motivo il mio nuovo progetto non viene compilato? Sto usando Visual Studio 2017 (versione 15.8.0 o successiva), e SDK versione 17134You'll no longer encounter the issue described in Why won't my new project compile? I'm using Visual Studio 2017 (version 15.8.0 or higher), and SDK version 17134

Altre modificheOther changes.

  • Modifica importante.Breaking change. winrt::get_abi(winrt::hstring const&) ora restituisce void* invece di HSTRING.winrt::get_abi(winrt::hstring const&) now returns void* instead of HSTRING. Puoi usare static_cast<HSTRING>(get_abi(my_hstring)); per ottenere un HSTRING.You can use static_cast<HSTRING>(get_abi(my_hstring)); to get an HSTRING. Vedi Interoperabilità con HSTRING di ABI.See Interoperating with the ABI's HSTRING.
  • Modifica importante.Breaking change. winrt::put_abi(winrt::hstring&) ora restituisce void** invece di HSTRING*.winrt::put_abi(winrt::hstring&) now returns void** instead of HSTRING*. Puoi usare reinterpret_cast<HSTRING*>(put_abi(my_hstring)); per ottenere un HSTRING*.You can use reinterpret_cast<HSTRING*>(put_abi(my_hstring)); to get an HSTRING*. Vedi Interoperabilità con HSTRING di ABI.See Interoperating with the ABI's HSTRING.
  • Modifica importante.Breaking change. HRESULT viene ora proiettato come winrt::hresult.HRESULT is now projected as winrt::hresult. Se ti serve un HRESULT (per eseguire la verifica di tipi o supportare tratti di tipo), puoi eseguire static_cast su un winrt::hresult.If you need an HRESULT (to do type checking, or to support type traits), then you can static_cast a winrt::hresult. In alternativa, winrt::hresult viene convertito in HRESULT, purché venga incluso unknwn.h prima di qualsiasi intestazione C++/WinRT.Otherwise, winrt::hresult converts to HRESULT, as long as you include unknwn.h before you include any C++/WinRT headers.
  • Modifica importante.Breaking change. GUID viene ora proiettato come winrt::guid.GUID is now projected as winrt::guid. Per le API di cui esegui l'implementazione, devi usare winrt::guid per i parametri GUID.For APIs that you implement, you must use winrt::guid for GUID parameters. In alternativa, winrt::guid viene convertito in GUID, purché venga incluso unknwn.h prima di qualsiasi intestazione C++/WinRT.Otherwise, winrt::guid converts to GUID, as long as you include unknwn.h before you include any C++/WinRT headers. Vedi Interoperabilità con lo struct GUID di ABI.See Interoperating with the ABI's GUID struct.
  • Modifica importante.Breaking change. Il costruttore winrt::handle_type è stato protetto rendendolo esplicito. È ora più difficile scrivere codice non corretto con questo costruttore.The winrt::handle_type constructor has been hardened by making it explicit (it's now harder to write incorrect code with it). Se devi assegnare un valore di handle non elaborato, chiama in alternativa la funzione handle_type::attach.If you need to assign a raw handle value, call the handle_type::attach function instead.
  • Modifica importante.Breaking change. Le firme di WINRT_CanUnloadNow e WINRT_GetActivationFactory sono cambiate.The signatures of WINRT_CanUnloadNow and WINRT_GetActivationFactory have changed. Queste funzioni non devono più essere dichiarate.You mustn't declare these functions at all. In alternativa, includi winrt/base.h (che viene inserito automaticamente se includi file di intestazione di spazi dei nomi Windows C++/WinRT) per aggiungere le dichiarazioni di queste funzioni.Instead, include winrt/base.h (which is automatically included if you include any C++/WinRT Windows namespace header files) to include the declarations of these functions.
  • Per winrt::clock struct, from_FILETIME/to_FILETIME sono deprecati a favore di from_file_time/to_file_time.For the winrt::clock struct, from_FILETIME/to_FILETIME are deprecated in favor of from_file_time/to_file_time.
  • API semplificate che prevedono parametri IBuffer.Simplified APIs that expect IBuffer parameters. Quasi tutte le API preferiscono raccolte o matrici.Most APIs prefer collections, or arrays. Tuttavia, abbiamo sentito la necessità di semplificare la chiamata delle API basate su IBuffer.But we felt that we should make it easier to call APIs that rely on IBuffer. Questo aggiornamento consente di accedere direttamente ai dati sottostanti un'implementazione IBuffer.This update provides direct access to the data behind an IBuffer implementation. Usa la stessa convenzione di denominazione dei dati usata nei contenitori della libreria standard C++.It uses the same data naming convention as the one used by the C++ Standard Library containers. Tale convenzione evita anche conflitti con i nomi di metadati che iniziano convenzionalmente con una lettera maiuscola.That convention also avoids collisions with metadata names that conventionally begin with an uppercase letter.
  • Generazione del codice migliorata. Sono stati introdotti vari miglioramenti per ridurre la dimensione del codice, migliorare l'inlining e ottimizzare la memorizzazione di factory nella cache.Improved code generation: various improvements to reduce code size, improve inlining, and optimize factory caching.
  • Rimozione della ricorsione non necessaria.Removed unnecessary recursion. Quando la riga di comando fa riferimento a una cartella, anziché a uno specifico file .winmd, lo strumento cppwinrt.exe non esegue più la ricerca di file .winmd in modo ricorsivo.When the command-line refers to a folder, rather than to a specific .winmd, the cppwinrt.exe tool no longer searches recursively for .winmd files. Anche lo strumento cppwinrt.exe gestisce ora i duplicati in modo più intelligente ed è più resiliente agli errori degli utenti e agli errori di formato dei file .winmd.The cppwinrt.exe tool also now handles duplicates more intelligently, making it more resilient to user error, and to poorly-formed .winmd files.
  • Puntatori intelligenti con protezione.Hardened smart pointers. In precedenza, i revocatori di evento non riuscivano a eseguire la revoca in caso di assegnazione di un nuovo valore in seguito allo spostamento.Formerly, the event revokers failed to revoke when move-assigned a new value. Ciò ha consentito di individuare un problema, nel modello di struct winrt::com_ptr, a causa del quale le classi di puntatori intelligenti non gestivano in modo affidabile l'autoassegnazione.This helped uncover an issue where smart pointer classes weren't reliably handling self-assignment; rooted in the winrt::com_ptr struct template. winrt::com_ptr è stato corretto e i revocatori di evento predefiniti sono stati modificati in modo da gestire correttamente la semantica di spostamento ed eseguire la revoca al momento dell'assegnazione.winrt::com_ptr has been fixed, and the event revokers fixed to handle move semantics correctly so that they revoke upon assignment.

Importante

Sono state apportate importanti modifiche all'estensione di Visual Studio C++/WinRT (VSIX), sia nella versione 1.0.181002.2 sia nella versione successiva 1.0.190128.4.Important changes were made to the C++/WinRT Visual Studio Extension (VSIX), both in version 1.0.181002.2, and then later in version 1.0.190128.4. Per informazioni dettagliate su queste modifiche e su come influiscono sui progetti esistenti, vedi Supporto di Visual Studio per C++/WinRT e Versioni precedenti dell'estensione VSIX.For details of these changes, and how they affect your existing projects, Visual Studio support for C++/WinRT and Earlier versions of the VSIX extension.

Isolamento dai file di intestazione di Windows SDKIsolation from Windows SDK header files

Questa è potenzialmente una modifica rilevante per il tuo codice.This is potentially a breaking change for your code.

Per la compilazione, C++/WinRT non dipende più da file di intestazione di Windows SDK.For it to compile, C++/WinRT no longer depends on header files from the Windows SDK. I file di intestazione della libreria di runtime C (CRT) e della libreria di modelli standard C++ (STL) non includono intestazioni di Windows SDK.Header files in the C run-time library (CRT) and the C++ Standard Template Library (STL) also don't include any Windows SDK headers. Ciò consente di migliorare la conformità agli standard, evitare dipendenze accidentali e ridurre notevolmente il numero di macro da cui proteggersi.And that improves standards compliance, avoids inadvertent dependencies, and greatly reduces the number of macros that you have to guard against.

Questa indipendenza significa che C++/WinRT è ora più flessibile e conforme agli standard e ha maggiori possibilità di diventare un compilatore e una libreria multipiattaforma.This independence means that C++/WinRT is now more portable and standards compliant, and it furthers the possibility of it becoming a cross-compiler and cross-platform library. Significa inoltre che le intestazioni C++/WinRT non sono soggette a eventuali effettivi negativi delle macro.It also means that the C++/WinRT headers aren't adversely affected macros.

Se in precedenza le intestazioni di Windows venivano incluse nel progetto direttamente da C++/WinRT, ora è compito tuo includerle.If you previously left it to C++/WinRT to include any Windows headers in your project, then you'll now need to include them yourself. In ogni caso, è sempre consigliabile includere in modo esplicito le intestazioni da cui si dipende e non lasciare che sia un'altra libreria a includerle.It is, in any case, always best practice to explicitly include the headers that you depend on, and not leave it to another library to include them for you.

Attualmente le uniche eccezioni all'isolamento dei file di intestazione di SDK Windows sono rappresentate da valori intrinseci e numerici.Currently, the only exceptions to Windows SDK header file isolation are for intrinsics, and numerics. Non vi sono problemi noti relativi a queste ultime dipendenze.There are no known issues with these last remaining dependencies.

Nel tuo progetto puoi riabilitare l'interoperabilità con le intestazioni di Windows SDK, se necessario.In your project, you can re-enable interop with the Windows SDK headers if you need to. Se, ad esempio, vuoi implementare un'interfaccia COM (in IUnknown),You might, for example, want to implement a COM interface (rooted in IUnknown). includi unknwn.h prima di qualsiasi intestazione C++/WinRT.For that example, include unknwn.h before you include any C++/WinRT headers. In questo modo, la libreria di base di C++/WinRT abilita vari hook per il supporto di interfacce COM classiche.Doing so causes the C++/WinRT base library to enable various hooks to support classic COM interfaces. Per un esempio di codice, vedi Creare componenti COM con C++/WinRT.For a code example, see Author COM components with C++/WinRT. In modo analogo, includi esplicitamente eventuali altre intestazioni di Windows SDK che dichiarano tipi e/o funzioni che vuoi chiamare.Similarly, explicitly include any other Windows SDK headers that declare types and/or functions that you want to call.

Come impostare una versione più recente di Windows SDK come destinazione per il progetto C++/WinRTHow to retarget your C++/WinRT project to a later version of the Windows SDK

Il metodo per modificare la destinazione di un progetto che ha minori probabilità di causare problemi del compilatore e del linker è anche quello più impegnativo.The method for retargeting your project that's likely to result in the fewest compiler and linker issue is also the most labor-intensive. Questo metodo comporta la creazione di un nuovo progetto (con la versione di Windows SDK selezionata come destinazione) e quindi la copia dei file dal progetto precedente a quello nuovo.That method involves creating a new project (targeting the Windows SDK version of your choice), and then copying files over to your new project from your old. Vi saranno sezioni dei tuoi file .vcxproj e .vcxproj.filters precedenti che puoi semplicemente sovrascrivere per evitare di aggiungere file in Visual Studio.There will be sections of your old .vcxproj and .vcxproj.filters files that you can just copy over to save you adding files in Visual Studio.

Vi sono tuttavia altri due modi per reimpostare la destinazione di un progetto in Visual Studio.However, there are two other ways to retarget your project in Visual Studio.

  • Passa alla proprietà del progetto Generale > Versione di Windows SDK e seleziona Tutte le configurazioni e Tutte le piattaforme.Go to project property General > Windows SDK Version, and select All Configurations and All Platforms. Imposta Versione di Windows SDK sulla versione che vuoi usare di destinazione.Set Windows SDK Version to the version that you want to target.
  • In Esplora soluzioni fai doppio clic sul nodo del progetto, fare clic su Ridestina progetti, scegli una o più versioni da impostare come destinazione e quindi fai clic su OK.In Solution Explorer, right-click the project node, click Retarget Projects, choose the version(s) you wish to target, and then click OK.

Se vengono restituiti errori del compilatore o del linker dopo l'uso di uno di questi due metodi, puoi provare a pulire la soluzione (scegli Compila > Pulisci soluzione e/o elimina manualmente tutti i file e le cartelle temporanei) prima di provare a ripetere la compilazione.If you encounter any compiler or linker errors after using either of these two methods, then you can try cleaning the solution (Build > Clean Solution and/or manually delete all temporary folders and files) before trying to build again.

Se il compilatore C++ genera l'errore "C2039: 'IUnknown': is not a member of '`global namespace'' " ('IUnknown': non è un membro di "spazio dei nomi globale"), aggiungi #include <unknwn.h> all'inizio del file pch.h, prima di includere eventuali intestazioni C++/WinRT.If the C++ compiler produces "error C2039: 'IUnknown': is not a member of '`global namespace''", then add #include <unknwn.h> to the top of your pch.h file (before you include any C++/WinRT headers).

Può anche essere necessario aggiungere #include <hstring.h> dopo tale stringa.You may also need to add #include <hstring.h> after that.

Se il linker C++ genera l'errore "LNK2019: unresolved external symbol _WINRT_CanUnloadNow@0 referenced in function _VSDesignerCanUnloadNow@0 " (Riferimento al simbolo esterno non risolto _WINRT_CanUnloadNow@0 nella funzione _VSDesignerCanUnloadNow@0), puoi risolverlo aggiungendo #define _VSDESIGNER_DONT_LOAD_AS_DLL al file pch.h.If the C++ linker produces "error LNK2019: unresolved external symbol _WINRT_CanUnloadNow@0 referenced in function _VSDesignerCanUnloadNow@0", then you can resolve that by adding #define _VSDESIGNER_DONT_LOAD_AS_DLL to your pch.h file.