> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Déboguer des projets PC sur des appareils Windows distants dans Visual Studio

> Attachez le débogueur Visual Studio 2022 à des builds de jeux PC exécutées sur une machine Windows distante à l'aide de l'extension GDK de la Marketplace pour le déploiement et le débogage.

<Info>L'application XBOX PC Toolbox est en préversion. Téléchargez-la depuis le [Microsoft Store](https://aka.ms/toolboxinstaller) sur Windows.</Info>

[XBOX PC Remote Tools](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/pc-dev/overviews/remote-gamedev-tools) permet d'attacher le débogueur Visual Studio 2022 à un jeu exécuté sur un appareil Windows distant. Tout le trafic de débogage entre le PC de développement et l'appareil Windows distant est chiffré. La possibilité d'attacher le débogueur est fournie par une [extension Visual Studio 2022](https://marketplace.visualstudio.com/items?itemName=XboxGDK.Microsoft-Xbox-PC-Remote-Debugger), disponible dans la Marketplace publique de Visual Studio.

Avant le débogage, votre PC de développement et votre appareil Windows distant doivent être provisionnés et appairés en suivant les étapes décrites dans le [guide de démarrage rapide](/fr/tools/tools-pc/xbox-pc-remote-tools/quickstart).

Après l'appairage et le provisionnement, téléchargez l'extension XBOX PC Remote Debugger à l'aide du [Gestionnaire d'extensions de Visual Studio](https://learn.microsoft.com/visualstudio/ide/finding-and-using-visual-studio-extensions?view=visualstudio).
Après l'appairage et le provisionnement, téléchargez l'extension XBOX PC Remote Debugger à l'aide du [Gestionnaire d'extensions de Visual Studio](https://aka.ms/XboxPCRemoteDebugger).

<img src="https://mintcdn.com/microsoft-4404708b/5IpvKlT-jmAaVkeY/images/gdk/tools/xbox_pc_remote_debugger_extension.png?fit=max&auto=format&n=5IpvKlT-jmAaVkeY&q=85&s=b5beb1a3b79d24e2963ece62f6bbfe6d" alt="L'extension XBOX PC Remote Debugger dans la Marketplace de Visual Studio" width="1152" height="386" data-path="images/gdk/tools/xbox_pc_remote_debugger_extension.png" />

## Activer le déploiement et le débogage avec F5 dans le projet de votre jeu

L'extension XBOX PC Remote Debugger pour Visual Studio prend en charge l'intégration complète de « F5 » pour le déploiement et le débogage de projets C++ sur des appareils Windows distants. Appuyer sur <kbd>F5</kbd> génère le projet, le déploie éventuellement sur l'appareil distant, lance le jeu à l'état suspendu, attache XBOX PC Remote Debugger, puis reprend l'exécution du jeu sous le débogueur.

Après avoir installé l'[extension Visual Studio XBOX PC Remote Debugger](https://marketplace.visualstudio.com/items?itemName=XboxGDK.Microsoft-Xbox-PC-Remote-Debugger), vérifiez les points suivants avant d'utiliser le déploiement et le débogage à distance avec F5 :

1. Votre PC de développement et votre appareil Windows distant doivent être provisionnés et appairés en suivant les étapes décrites dans le [guide de démarrage rapide](/fr/tools/tools-pc/xbox-pc-remote-tools/quickstart).

2. Le moniteur de débogage Microsoft Visual Studio (`MSVSMON.EXE`) doit être installé sur l'appareil distant. `MSVSMON.EXE` est installé automatiquement par l'[application XBOX PC Toolbox](/fr/tools/tools-pc/xboxpctoolbox/xboxpctoolbox). Vous pouvez également l'installer à l'aide de WinGet depuis une invite administrateur sur l'appareil distant :

```
   winget install Microsoft.VisualStudio.2022.OnecoreMsvsmon
```

3. [`wdEndpoint.exe`](/fr/tools/tools-pc/commandlinetools/gr-wdEndpoint) doit être en cours d'exécution sur l'appareil distant. `wdEndpoint.exe` est installé et démarré automatiquement par l'[application XBOX PC Toolbox](/fr/tools/tools-pc/xboxpctoolbox/xboxpctoolbox). Vous pouvez également l'installer à l'aide de Winget depuis une invite de commandes sur l'appareil distant :

```
   winget install Microsoft.Gaming.RemoteIterationEndpoint 
```

Démarrez `wdEndpoint.exe` manuellement après l'avoir installé via WinGet.

### Ajout de la prise en charge du débogage à distance avec F5 à un projet MSBuild

Pour activer l'intégration de F5 pour un projet qui utilise MSBuild, ajoutez le code XML suivant à votre fichier `.vcxproj`. Placez-le après le dernier élément `</ItemDefinitionGroup>` et avant les sections `<ItemGroup>` des fichiers sources :

```xml theme={null}
<ItemGroup>
  <ProjectCapability Include="Gaming.Xbox.PC.Remote" />
</ItemGroup>
<Import Condition="'$(XboxPCRemotePath)'!='' AND Exists('$(XboxPCRemotePath)XboxPCcppDebugger.props')"
  Project="$(XboxPCRemotePath)XboxPCcppDebugger.props" />
<ItemGroup>
  <PropertyPageSchema Condition="'$(XboxPCRemotePath)'!=''" Include="$(XboxPCRemotePath)XboxPCcppDebugger.xml" />
</ItemGroup>
```

<Note>La dernière version des [modèles Microsoft GDK](https://aka.ms/gdktemplates) vous invite à inclure cette intégration lors de la création de nouveaux projets.</Note>

<img src="https://mintcdn.com/microsoft-4404708b/5IpvKlT-jmAaVkeY/images/gdk/tools/xbox_pc_remote_debugger_template_prompt.png?fit=max&auto=format&n=5IpvKlT-jmAaVkeY&q=85&s=a620c5d24191e498dba4589f65921d57" alt="L'invite permettant d'activer le débogage à distance dans un nouveau projet" width="879" height="567" data-path="images/gdk/tools/xbox_pc_remote_debugger_template_prompt.png" />

Pour activer le déploiement, accédez à **Projet > Propriétés > Gestionnaire de configurations** et cochez l'option **Déployer** pour la configuration souhaitée.

<img src="https://mintcdn.com/microsoft-4404708b/5IpvKlT-jmAaVkeY/images/gdk/tools/xbox_pc_remote_debugger_deploy_checkbox.png?fit=max&auto=format&n=5IpvKlT-jmAaVkeY&q=85&s=ba9f7ae896391e1f7e9415b60f472c40" alt="Activation du déploiement pour une configuration" width="696" height="435" data-path="images/gdk/tools/xbox_pc_remote_debugger_deploy_checkbox.png" />

Avant d'appuyer sur **F5**, définissez le débogueur sur **XBOX PC Remote Debugger** à l'aide de la barre d'outils de débogage ou de la page de propriétés du projet. Plusieurs propriétés sont disponibles pour configurer le déploiement et le débogage.

<img src="https://mintcdn.com/microsoft-4404708b/5IpvKlT-jmAaVkeY/images/gdk/tools/xbox_pc_remote_debugger_property_page.png?fit=max&auto=format&n=5IpvKlT-jmAaVkeY&q=85&s=12b098d60639fc9733dd2c9bf4e3ee50" alt="Les propriétés de XBOX PC Remote Debugger" width="792" height="544" data-path="images/gdk/tools/xbox_pc_remote_debugger_property_page.png" />

* `Remote Command Arguments`. Liste des arguments de commande à passer au jeu.

* `Deployment Directory`. Répertoire du PC de développement à déployer sur l'appareil Windows distant. La valeur par défaut est `$(Outdir)`.

* `Remote Folder`. Dossier dans lequel le jeu est déployé sur l'appareil Windows distant. Ce dossier est relatif à la *Common Root*. Pour plus d'informations sur la *Common Root*, consultez la rubrique [`wdEndpoint.exe`](/fr/tools/tools-pc/commandlinetools/gr-wdEndpoint).

* `Remote EndPoint Name`. L'appareil distant par défaut est la machine de développement elle-même, comme pour le débogage à distance Windows standard. Remplacez la valeur de `Remote EndPoint Name` par le nom de l'appareil sur lequel `wdEndpoint.exe` est en cours d'exécution.

* `File filter for deployment`. Permet de spécifier l'ensemble des fichiers à exclure du déploiement. Par exemple, il est courant d'exclure les fichiers `.pdb` du déploiement. Fournissez une liste de modèles de fichiers à exclure, séparés par des points-virgules, par exemple : `*.pdb;*.ipdb;*.iobj;*.obj;*.pch;*`.

Une fois la case **Déployer** cochée pour votre **Configuration**, **XBOX PC Remote Debugger** choisi comme type de débogueur et les propriétés renseignées, appuyer sur **F5** génère votre jeu, le déploie sur l'appareil Windows distant et le démarre sous le débogueur.

<Note>Vous devrez peut-être configurer vos chemins de symboles pour que Visual Studio trouve les symboles de votre jeu. Pour ce faire, utilisez les paramètres **Débogage** de la boîte de dialogue **Options**, accessible depuis le menu **Outils**.</Note>

#### Valeurs par défaut par projet du débogueur distant F5

Les valeurs par défaut des paramètres de XBOX PC Remote Debugger sont définies par le fichier `XboxPCcppDebugger.props`, et toutes les modifications apportées aux paramètres dans la boîte de dialogue Propriétés du projet de Visual Studio sont enregistrées « par utilisateur » sur la machine locale.

Pour que votre vcxproj fournisse une autre valeur par défaut, afin d'éviter que chaque utilisateur ait à la définir sur sa machine, ajoutez-la au code MSBuild comme suit :

```xml theme={null}
<ItemGroup>
  <ProjectCapability Include="Gaming.Xbox.PC.Remote" />
</ItemGroup>
<Import Condition="'$(XboxPCRemotePath)'!='' AND Exists('$(XboxPCRemotePath)XboxPCcppDebugger.props')"
  Project="$(XboxPCRemotePath)XboxPCcppDebugger.props" />
<PropertyGroup>
  <RemoteGameshareFolder>MyGameTitle</RemoteGameshareFolder>
</PropertyGroup>
<ItemGroup>
  <PropertyPageSchema Condition="'$(XboxPCRemotePath)'!=''" Include="$(XboxPCRemotePath)XboxPCcppDebugger.xml" />
</ItemGroup>
```

### Déploiement du runtime Visual C++ (CRT)

Pour qu'un programme s'exécute sur la machine distante, il a besoin des fichiers du runtime Visual C++. Pour le CRT commercial, vous pouvez installer le package Visual C++ REDIST sur la machine distante. Pour le CRT de débogage, ces fichiers doivent être déployés avec le titre.

Une solution simple dans MSBuild consiste à ajouter une propriété à la section Global de votre projet :

```xml theme={null}
<CopyCppRuntimeToOutputDir>true</CopyCppRuntimeToOutputDir>
```

Cela copie le CRT Visual C++ dans `OutDir`. La version Debug est utilisée si `UseDebugLibraries` est défini sur true ; sinon, la version Retail est utilisée.

### Ajout de la prise en charge du débogage à distance avec F5 à un projet CMake

Pour un projet de type Ouvrir un dossier (comme un projet CMake), la prise en charge du débogage à distance avec F5 est configurée dans `launch.vs.json` plutôt que dans un fichier `.vcxproj`.

1. Installez la prise en charge de XBOX PC Remote Debugger et assurez-vous que votre appareil Windows distant est provisionné et exécute `wdEndpoint.exe`.

2. Ouvrez le dossier de votre projet CMake dans Visual Studio.

3. Dans l'**Explorateur de solutions**, cliquez avec le bouton droit sur **CMakeLists.txt** et sélectionnez **Ajouter une configuration de débogage...**.

4. Sélectionnez **XBOX PC Remote Debugger Folder**.

<img src="https://mintcdn.com/microsoft-4404708b/5IpvKlT-jmAaVkeY/images/gdk/tools/xbox_pc_remote_debugger_cmake_debug_configuration.png?fit=max&auto=format&n=5IpvKlT-jmAaVkeY&q=85&s=f4f1ad1f89fb057f614d8f163a37d99d" alt="Ajout d'une configuration de débogage à un projet CMake" width="869" height="569" data-path="images/gdk/tools/xbox_pc_remote_debugger_cmake_debug_configuration.png" />

Visual Studio crée un fichier `.vs\launch.vs.json` avec une configuration de lancement `Xbox PC Remote Debugger`.

Une configuration type se présente comme suit :

```json theme={null}
   {
     "version": "0.2.1",
     "defaults": {},
     "configurations": [
       {
         "type": "default",
         "name": "MyGame.exe",
         "project": "CMakeLists.txt",
         "projectTarget": "MyGame.exe",
         "deployDirectory": "${workspaceRoot}\\out\\build\\x64-Release\\bin",
         "deployExcludeFilter": "*.pdb;*.ipdb;*.iobj;*.obj;*.pch;*.ilk;*.exp;*.lib;*.winmd;*.appxrecipe;*.log;*.tlog;*unsuccessfulbuild;*.lastbuildstate;*.copycomplete",
         "remoteGameshareFolder": "MyGame",
         "remoteMachineName": "MyROGAlly",
         "targetName": "MyGame.exe",
         "args": [],
         "deployType": "GamingXboxPCRemoteDeploy"
       }
     ]
   }
```

5. Mettez à jour la configuration générée avec des valeurs pour les propriétés suivantes :

   * `deployDirectory`. Dossier de sortie local qui contient les fichiers à déployer.

   * `remoteGameshareFolder`. Dossier à créer ou à utiliser sur l'appareil distant.

   * `remoteMachineName`. Nom de l'appareil distant sur lequel `wdEndpoint.exe` est en cours d'exécution.

   * `targetName`. Exécutable du jeu à lancer après le déploiement.

6. Mettez éventuellement à jour ces propriétés selon vos besoins :

   * `deployExcludeFilter`. Liste de modèles de fichiers, séparés par des points-virgules, à exclure du déploiement.

   * `args`. Arguments de ligne de commande à passer au jeu lors de son démarrage.

   * `disableDeploy`. Définissez cette propriété lorsque vous voulez ignorer le déploiement et uniquement lancer le jeu ou attacher le débogueur.

7. Générez votre jeu localement, puis sélectionnez **CMakeLists.txt** dans la barre d'outils du débogueur et appuyez sur **F5** pour déployer le jeu sur l'appareil distant et le démarrer sous le débogueur.

<img src="https://mintcdn.com/microsoft-4404708b/5IpvKlT-jmAaVkeY/images/gdk/tools/xbox_pc_remote_debugger_cmake_debug_toolbar.png?fit=max&auto=format&n=5IpvKlT-jmAaVkeY&q=85&s=c0a5c9d225c7a0c1433e18e3bc8fa646" alt="Sélectionner CMakeLists.txt dans la barre d'outils du débogueur" width="684" height="92" data-path="images/gdk/tools/xbox_pc_remote_debugger_cmake_debug_toolbar.png" />

## Attacher le débogueur Visual Studio à des jeux exécutés sur des appareils Windows distants

Pour attacher le débogueur à un jeu déjà en cours d'exécution sur un appareil distant, sélectionnez **Attacher au processus...** dans le menu **Déboguer** de Visual Studio. Sélectionnez **XBOX PC Remote Device** dans la liste déroulante **Type de connexion** et saisissez l'adresse IP ou le nom d'hôte de votre appareil distant dans la zone de texte **Cible de la connexion**. La liste des processus en cours d'exécution sur votre appareil distant s'affiche. Sélectionnez le jeu à déboguer, puis le bouton **Attacher**.

<img src="https://mintcdn.com/microsoft-4404708b/5IpvKlT-jmAaVkeY/images/gdk/tools/xbox_pc_remote_debugger_attach.png?fit=max&auto=format&n=5IpvKlT-jmAaVkeY&q=85&s=9af2fa1ec8dcaf6e5709e9a074ce951e" alt="Boîte de dialogue Attacher au processus avec le transport approprié sélectionné" width="936" height="692" data-path="images/gdk/tools/xbox_pc_remote_debugger_attach.png" />

## Voir aussi

[XBOX PC Remote Tools](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/pc-dev/overviews/remote-gamedev-tools)


## Related topics

- [Visual Studio (sommaire)](/fr/tools/tools-pc/visualstudio/gr-visualstudio-toc.md)
- [Débogage de projets PC avec Visual Studio](/fr/tools/tools-pc/visualstudio/gr-vs-debugging-with-visualstudio.md)
- [Visualstudio](/fr/tools/tools-pc/visualstudio/index.md)
- [Déboguer des projets XBOX à l'aide de Visual Studio](/fr/tools/tools-console/visualstudio/debugging-with-visualstudio.md)
- [XBOX PC Remote Tools](/fr/tools/tools-pc/xbox-pc-remote-tools/index.md)