> ## 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émarrage rapide Win32 > Ajoutez le SDK C PlayFab Services à un projet Visual Studio 2022 et effectuez votre premier appel d'API PlayFab depuis une application de bureau Win32 native. # Démarrage rapide : Win32 Prenez en main le SDK PlayFab Services pour Win32. Suivez ces étapes pour inclure les bibliothèques dans votre projet et essayer l'exemple de code illustrant les fonctionnalités de base de PlayFab. Ce démarrage rapide vous aide à effectuer votre premier appel d'API PlayFab à l'aide du SDK Win32. Avant de continuer, assurez-vous d'avoir suivi les étapes de [Démarrage rapide : Game Manager](/fr-CA/services/playfab/live-service-management/gamemanager/quickstart), qui garantissent que vous disposez d'un compte PlayFab et que vous connaissez le Game Manager PlayFab. ## Prérequis * Un [compte développeur PlayFab](https://developer.playfab.com). * [Visual Studio 2022](https://visualstudio.microsoft.com/) installé. ## Configuration du projet Téléchargez le SDK PlayFab dans votre projet depuis la [page des versions du SDK PlayFab](https://github.com/PlayFab/PlayFabCSdk/releases/latest). Importez PlayFabServicesSDK.Win32.props dans votre projet. Vous pouvez le faire manuellement dans le fichier projet ou en ouvrant la fenêtre Gestionnaire de propriétés dans Visual Studio, en cliquant avec le bouton droit sur le projet, puis en choisissant **Add Existing Property Sheet**. ### Résolution des problèmes Si vous rencontrez des problèmes lors de l'édition des liens du SDK dans votre projet, vous devrez peut-être installer les outils de génération et bibliothèques 17.5 au moyen de Visual Studio Installer. Cliquez sur **Modify** pour VS2022, puis installez ces deux composants. Installer les outils de génération 17.5 ## Initialisation et connexion ### En-têtes Incluez **PFServices.h** pour accéder à toutes les fonctionnalités PlayFab incluses : ```cpp theme={null} #include ``` ### Initialisation L'initialisation de PlayFab nécessite deux appels de fonction : **PFServicesInitialize** et **PFServiceConfigCreateHandle**. Le résultat de cette initialisation est un **PFServiceConfigHandle**. Vous fournissez ce handle à un appel de connexion ultérieur, ce qui dirige l'appel vers le bon titre dans le back-end PlayFab. ```cpp theme={null} HRESULT hr = PFServicesInitialize(nullptr); // Add your own error handling when FAILED(hr) == true PFServiceConfigHandle serviceConfigHandle{ nullptr }; hr = PFServiceConfigCreateHandle( "https://ABCDEF.playfabapi.com", // PlayFab API endpoint - obtained in the Game Manager "ABCDEF", // PlayFab Title id - obtained in the Game Manager &serviceConfigHandle); ``` ### Connexion Une fois que vous disposez d'un **PFServiceConfigHandle**, vous pouvez l'utiliser pour effectuer un appel de connexion de joueur. Dans le SDK, utilisez une méthode **PFAuthenticationReLoginWith\*Async** telle que **PFAuthenticationLoginWithSteamAsync**. Cette fonction vous permet de connecter un joueur à PlayFab à l'aide d'un **SteamTicket**. Après avoir effectué un appel de connexion, vous pouvez vérifier son état avec **XAsyncGetStatus**. L'état commence à **E\_PENDING** et passe à **S\_OK** une fois l'appel terminé avec succès. Si l'appel échoue pour une raison quelconque, l'état reflète cet échec. La gestion des erreurs fonctionne de cette façon pour tous les appels PlayFab Services. En plus d'un résultat **S\_OK**, vous récupérez un **PFEntityHandle**. Vous utilisez ce handle pour effectuer les appels PlayFab suivants en tant que joueur connecté. Il contient tous les éléments nécessaires pour s'authentifier auprès du service PlayFab en tant que ce joueur. ```cpp theme={null} PFAuthenticationLoginWithSteamRequest request{}; request.createAccount = true; request.steamTicket = steamTicket; // A ticket obtained from Steam XAsyncBlock async{}; HRESULT hr = PFAuthenticationLoginWithSteamAsync(serviceConfigHandle, &request, &async); // Add your own error handling when FAILED(hr) == true hr = XAsyncGetStatus(&async, true); // This is doing a blocking wait for completion, but you can use the XAsyncBlock to set a callback instead for async style usage std::vector loginResultBuffer; PFAuthenticationLoginResult const* loginResult; size_t bufferSize; hr = PFAuthenticationLoginWithSteamGetResultSize(&async, &bufferSize); loginResultBuffer.resize(bufferSize); PFEntityHandle entityHandle{ nullptr }; hr = PFAuthenticationLoginWithSteamGetResult(&async, &entityHandle, loginResultBuffer.size(), loginResultBuffer.data(), &loginResult, nullptr); ``` ## Appels de service Une fois le joueur connecté, vous pouvez effectuer des appels vers le back-end PlayFab. Voici un exemple d'appel permettant d'obtenir les fichiers stockés dans PlayFab pour le joueur actuel. ### Obtention de l'EntityKey Pour certains appels à PlayFab, il peut être utile de connaître la **PFEntityKey** du joueur. Une fois que vous disposez d'un **PFEntityToken**, vous pouvez récupérer une **PFEntityKey** avec **PFEntityGetEntityKey**. ```cpp theme={null} PFEntityKey const* pEntityKey{}; std::vector entityKeyBuffer; size_t size{}; HRESULT hr = PFEntityGetEntityKeySize(entityHandle, &size); // Add your own error handling when FAILED(hr) == true entityKeyBuffer.resize(size); hr = PFEntityGetEntityKey(entityHandle, entityKeyBuffer.size(), entityKeyBuffer.data(), &pEntityKey, nullptr); ``` ### Appel de GetFiles Tous les appels PlayFab suivent un modèle similaire : préparer l'objet de requête, effectuer l'appel (à l'aide du **PFEntityHandle** obtenu lors de la connexion), créer un objet pour recevoir la réponse, puis appeler une fonction **GetResult** pour remplir le conteneur nouvellement créé. ```cpp theme={null} XAsyncBlock async{}; PFDataGetFilesRequest requestFiles{}; requestFiles.entity = pEntityKey; HRESULT hr = PFDataGetFilesAsync(entityHandle, &requestFiles, &async); // Add your own error handling when FAILED(hr) == true hr = XAsyncGetStatus(&async, true); // This is doing a blocking wait for completion, but you can use the XAsyncBlock to set a callback instead for async style usage size_t resultSize; hr = PFDataGetFilesGetResultSize(&async, &resultSize); std::vector getFilesResultBuffer(resultSize); PFDataGetFilesResponse* getFilesResponseResult{ nullptr }; hr = PFDataGetFilesGetResult(&async, getFilesResultBuffer.size(), getFilesResultBuffer.data(), &getFilesResponseResult, nullptr); ``` ## Nettoyage Lorsque votre jeu est prêt à s'arrêter ou que vous devez nettoyer PlayFab pour une autre raison, assurez-vous de fermer tous les handles ouverts et à appeler **PFServicesUninitializeAsync**. ```cpp theme={null} PFEntityCloseHandle(entityHandle); entityHandle = nullptr; PFServiceConfigCloseHandle(serviceConfigHandle); serviceConfigHandle = nullptr; XAsyncBlock async{}; HRESULT hr = PFServicesUninitializeAsync(&async); // Add your own error handling when FAILED(hr) == true hr = XAsyncGetStatus(&async, true); // This is doing a blocking wait for completion, but you can use the XAsyncBlock to set a callback instead for async style usage ``` ## Modèle d'API asynchrone Le SDK PlayFab Services suit le [modèle de programmation asynchrone](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/system/overviews/async-programming-model) implémenté dans le GDK. Ce modèle de programmation implique l'utilisation des tâches et des files d'attente de tâches fournies par la [bibliothèque XAsync](/fr-CA/build/core-features/common/async/async-libraries/async-library-xasync). Ce modèle est cohérent avec les autres fonctions et extensions du GDK (comme l'API XBOX Services). Bien qu'il introduise une certaine complexité, il offre également un haut degré de contrôle sur les opérations asynchrones. Cet exemple montre comment effectuer un appel asynchrone à **PFDataGetFilesAsync**. ```cpp theme={null} auto async = std::make_unique(); async->callback = [](XAsyncBlock* async) { std::unique_ptr asyncBlockPtr{ async }; // take ownership of XAsyncBlock size_t resultSize; HRESULT hr = PFDataGetFilesGetResultSize(async, &resultSize); if (SUCCEEDED(hr)) { std::vector getFilesResultBuffer(resultSize); PFDataGetFilesResponse* getFilesResponseResult{ nullptr }; PFDataGetFilesGetResult(async, getFilesResultBuffer.size(), getFilesResultBuffer.data(), &getFilesResponseResult, nullptr); } }; PFDataGetFilesRequest requestFiles{}; requestFiles.entity = m_pEntityKey; HRESULT hr = PFDataGetFilesAsync(m_entityHandle, &requestFiles, async.get()); if (SUCCEEDED(hr)) { async.release(); // at this point, the callback will be called so release the unique ptr } ``` ## Gestion des erreurs Les opérations **XAsync** terminées retournent des codes d'état HTTP. Un code d'état d'erreur se manifeste sous la forme d'un **HRESULT** d'échec, tel que **HTTP\_E\_STATUS\_NOT\_FOUND**, lors de l'appel de **XAsyncGetStatus()** ou de l'une des API **PF\*Get()**. Pour afficher les messages d'erreur détaillés retournés par le service, consultez la section suivante sur le débogage. Ces messages d'erreur détaillés peuvent être utiles pendant le développement pour mieux comprendre comment le service PlayFab réagit aux requêtes du client. ## Débogage Le moyen le plus simple d'afficher les résultats et de déboguer les appels dans le SDK PlayFab Services consiste à activer le [suivi de débogage](/fr-CA/services/playfab/sdks/c/tracing). L'activation du suivi de débogage vous permet à la fois de voir les résultats dans la fenêtre de sortie du débogueur et de rediriger les résultats vers les propres journaux de votre jeu. ## Référence [Documentation de référence de l'API](/fr-CA/services/playfab/api-references/c/pfauthentication/pfauthentication_members) ## Related topics - [Langages pris en charge par PlayFab](/fr-CA/services/playfab/sdks/languages/index.md) - [Cycle de vie du SDK](/fr-CA/services/playfab/sdks/c/lifecycle.md) - [Handles d'entité](/fr-CA/services/playfab/sdks/c/entity-handles.md) - [Démarrage rapide C++ pour Windows](/fr-CA/services/playfab/sdks/playfab-cpp/quickstart-windows.md) - [Démarrage rapide](/fr-CA/services/playfab/economy-monetization/economy-v2/quickstart.md)