> ## 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.

# Obtenir les statistiques basées sur les événements

> Exemple de code XSAPI pour lire les statistiques XBOX Live basées sur les événements, notamment des requêtes groupées sur plusieurs utilisateurs et SCID afin de réduire le nombre d'appels de service.

<a id="top" />

Cette rubrique fournit un exemple de code pour obtenir des statistiques basées sur les événements.

Les API proposent différents niveaux de traitement par lots pour obtenir des statistiques basées sur les événements.
La meilleure pratique consiste à effectuer le moins d'appels possible en utilisant l'API de traitement par lots adaptée à vos besoins.

Cette rubrique couvre les points suivants :

* [Obtenir une seule statistique pour un seul utilisateur et un seul SCID](#ID4EM1)
* [Obtenir plusieurs statistiques pour un seul utilisateur et un seul SCID](#ID4EM2)
* [Obtenir plusieurs statistiques pour plusieurs utilisateurs et un seul SCID](#ID4EM3)
* [Obtenir plusieurs statistiques pour plusieurs utilisateurs sur plusieurs SCID](#ID4EM4)

Vous pouvez également [vous abonner aux modifications des statistiques](/fr/services/xbox-services/player-data/stats-leaderboards/event-based/how-to/live-handling-eb-stat-change).

<a id="ID4EM1" />

## Obtenir une seule statistique pour un seul utilisateur et un seul SCID

L'exemple de code suivant montre comment lire une seule statistique utilisateur.

#### API C plate

```cpp theme={null}
auto asyncBlock = std::make_unique<XAsyncBlock>();
asyncBlock->queue = queue;
asyncBlock->callback = [](XAsyncBlock* asyncBlock)
{
    std::unique_ptr<XAsyncBlock> asyncBlockPtr{ asyncBlock }; // Take over ownership of the XAsyncBlock*.
    size_t resultSize;
    HRESULT hr = XblUserStatisticsGetSingleUserStatisticResultSize(asyncBlock, &resultSize);

    if (SUCCEEDED(hr))
    {
        std::vector<char> buffer(resultSize, 0);
        XblUserStatisticsResult* result{};

        hr = XblUserStatisticsGetSingleUserStatisticResult(asyncBlock, resultSize, buffer.data(), &result, nullptr);

        if (SUCCEEDED(hr) && result->serviceConfigStatisticsCount > 0 && result->serviceConfigStatistics->statisticsCount > 0)
        {
            int64_t userStatValue = atoll(result->serviceConfigStatistics[0].statistics[0].value);
            // You can now show or store userStatValue.
        }
    }
};

HRESULT hr = XblUserStatisticsGetSingleUserStatisticAsync(
    xboxLiveContext,
    xboxUserId,
    scid,
    statisticName.c_str(),
    asyncBlock.get()
);
if (SUCCEEDED(hr))
{
    // The call succeeded, so release the std::unique_ptr ownership of XAsyncBlock* because the callback will take over ownership.
    // If the call fails, the std::unique_ptr will keep ownership and delete the XAsyncBlock*.
    asyncBlock.release();
}
```

Pour plus d'informations, consultez les rubriques suivantes :

* [XAsyncBlock](/fr/reference/system/xasync/structs/xasyncblock)
* [XblUserStatisticsGetSingleUserStatisticAsync](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetsingleuserstatisticasync)
* [XblUserStatisticsGetSingleUserStatisticResult](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetsingleuserstatisticresult)
* [XblUserStatisticsGetSingleUserStatisticResultSize](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetsingleuserstatisticresultsize)
* [XblUserStatisticsResult](/fr/reference/live/xsapi-c/user_statistics_c/structs/xbluserstatisticsresult)

[Retour en haut de cette rubrique.](#top)

<a id="ID4EM2" />

## Obtenir plusieurs statistiques pour un seul utilisateur et un seul SCID

L'exemple de code suivant montre comment lire plusieurs statistiques d'un seul utilisateur en un seul appel HTTP.

#### API C plate

```cpp theme={null}
auto asyncBlock = std::make_unique<XAsyncBlock>();
asyncBlock->queue = queue;
asyncBlock->callback = [](XAsyncBlock* asyncBlock)
{
    std::unique_ptr<XAsyncBlock> asyncBlockPtr{ asyncBlock }; // Take over ownership of the XAsyncBlock*.
    size_t resultSize;
    HRESULT hr = XblUserStatisticsGetSingleUserStatisticsResultSize(asyncBlock, &resultSize);

    if (SUCCEEDED(hr))
    {
        std::vector<char> buffer(resultSize, 0);
        XblUserStatisticsResult* results{};

        hr = XblUserStatisticsGetSingleUserStatisticsResult(asyncBlock, resultSize, buffer.data(), &results, nullptr);
        if (SUCCEEDED(hr))
        {
            // You can now use the XblUserStatisticsResult array in results.
        }
    }

};

const char* statisticNames[2] = {};
statisticNames[0] = statisticName1.c_str();
statisticNames[1] = statisticName2.c_str();

HRESULT hr = XblUserStatisticsGetSingleUserStatisticsAsync(
    xboxLiveContext,
    xboxUserId,
    scid,
    statisticNames, 2, 
    asyncBlock.get()
);
if (SUCCEEDED(hr))
{
    // The call succeeded, so release the std::unique_ptr ownership of XAsyncBlock* because the callback will take over ownership.
    // If the call fails, the std::unique_ptr will keep ownership and delete the XAsyncBlock*.
    asyncBlock.release();
}

```

Pour plus d'informations, consultez les rubriques suivantes :

* [XAsyncBlock](/fr/reference/system/xasync/structs/xasyncblock)
* [XblUserStatisticsGetSingleUserStatisticAsync](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetsingleuserstatisticasync)
* [XblUserStatisticsGetSingleUserStatisticResult](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetsingleuserstatisticresult)
* [XblUserStatisticsGetSingleUserStatisticResultSize](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetsingleuserstatisticresultsize)
* [XblUserStatisticsResult](/fr/reference/live/xsapi-c/user_statistics_c/structs/xbluserstatisticsresult)

[Retour en haut de cette rubrique.](#top)

<a id="ID4EM3" />

## Obtenir plusieurs statistiques pour plusieurs utilisateurs et un seul SCID

L'exemple de code suivant montre comment lire plusieurs statistiques de plusieurs utilisateurs en un seul appel HTTP.

#### API C plate

```cpp theme={null}
auto asyncBlock = std::make_unique<XAsyncBlock>();
asyncBlock->queue = queue;
asyncBlock->callback = [](XAsyncBlock* asyncBlock)
{
    std::unique_ptr<XAsyncBlock> asyncBlockPtr{ asyncBlock }; // Take over ownership of the XAsyncBlock*.
    size_t resultSize;
    HRESULT hr = XblUserStatisticsGetMultipleUserStatisticsResultSize(asyncBlock, &resultSize);

    if (SUCCEEDED(hr))
    {
        std::vector<char> buffer(resultSize, 0);
        XblUserStatisticsResult* results{};
        size_t resultsCount = 0;

        hr = XblUserStatisticsGetMultipleUserStatisticsResult(asyncBlock, resultSize, buffer.data(), &results, &resultsCount, nullptr);

        // Process results array to read the user stats data.
        for (size_t iResult = 0; iResult < resultsCount; iResult++)
        {
            LogToFile("%d", results[iResult].xboxUserId);
            for (size_t iScid = 0; iScid < results[iResult].serviceConfigStatisticsCount; iScid++)
            {
                LogToFile("SCID: %s", results[iResult].serviceConfigStatistics[iScid].serviceConfigurationId);
                for (size_t iStat = 0; iStat < results[iResult].serviceConfigStatistics[iScid].statisticsCount; iStat++)
                {
                    LogToFile("Stat %d: name:%s value:%s type:%s", iResult,
                        results[iResult].serviceConfigStatistics[iScid].statistics[iStat].statisticName,
                        results[iResult].serviceConfigStatistics[iScid].statistics[iStat].value,
                        results[iResult].serviceConfigStatistics[iScid].statistics[iStat].statisticType );
                }
            }
        }
    }

};

const char* statisticNames[2] = {};
statisticNames[0] = statisticName1.c_str();
statisticNames[1] = statisticName2.c_str();

uint64_t xuids[2] = {};
xuids[0] = xuid1;
xuids[1] = xuid2;

HRESULT hr = XblUserStatisticsGetMultipleUserStatisticsAsync(
    xboxLiveContext,
    xuids, 2,
    scid,
    statisticNames, 2,
    asyncBlock.get()
);
if (SUCCEEDED(hr))
{
    // The call succeeded, so release the std::unique_ptr ownership of XAsyncBlock* because the callback will take over ownership.
    // If the call fails, the std::unique_ptr will keep ownership and delete the XAsyncBlock*.
    asyncBlock.release();
}
```

Pour plus d'informations, consultez les rubriques suivantes :

* [XAsyncBlock](/fr/reference/system/xasync/structs/xasyncblock)
* [XblUserStatisticsGetMultipleUserStatisticsAsync](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetmultipleuserstatisticsasync)
* [XblUserStatisticsGetMultipleUserStatisticsResult](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetmultipleuserstatisticsresult)
* [XblUserStatisticsGetMultipleUserStatisticsResultSize](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetmultipleuserstatisticsresultsize)
* [XblUserStatisticsResult](/fr/reference/live/xsapi-c/user_statistics_c/structs/xbluserstatisticsresult)

[Retour en haut de cette rubrique.](#top)

<a id="ID4EM4" />

## Obtenir plusieurs statistiques pour plusieurs utilisateurs sur plusieurs SCID

L'exemple de code suivant montre comment utiliser l'API des services XBOX (XSAPI) pour lire plusieurs statistiques d'une même configuration de service pour plusieurs utilisateurs en un seul appel.

#### API C plate

```cpp theme={null}
auto asyncBlock = std::make_unique<XAsyncBlock>();
asyncBlock->queue = queue;
asyncBlock->callback = [](XAsyncBlock* asyncBlock)
{
    std::unique_ptr<XAsyncBlock> asyncBlockPtr{ asyncBlock }; // Take over ownership of the XAsyncBlock*.
    size_t resultSize;
    HRESULT hr = XblUserStatisticsGetMultipleUserStatisticsForMultipleServiceConfigurationsResultSize(asyncBlock, &resultSize);

    if (SUCCEEDED(hr))
    {
        std::vector<char> buffer(resultSize, 0);
        XblUserStatisticsResult* results{};
        size_t resultsCount = 0;

        hr = XblUserStatisticsGetMultipleUserStatisticsForMultipleServiceConfigurationsResult(asyncBlock, resultSize, buffer.data(), &results, &resultsCount, nullptr);

        if (SUCCEEDED(hr))
        {
            for (size_t i = 0; i < resultsCount; i++)
            {
                // Log results.
                std::stringstream stream;
                stream << "XUID: " << results[i].xboxUserId << std::endl;;

                for (size_t j = 0; j < results[i].serviceConfigStatisticsCount; j++)
                {
                    stream << " " << results[i].serviceConfigStatistics[j].serviceConfigurationId << ": " << std::endl;
                    for (size_t k = 0; k < results[i].serviceConfigStatistics[j].statisticsCount; k++)
                    {
                        stream << " " << results[i].serviceConfigStatistics[j].statistics[k].statisticName << "=" << results[i].serviceConfigStatistics[j].statistics[k].value << std::endl;
                    }
                }
            }
        }
    }

};

const char* requestedStatsNames1[2] = {};
requestedStatsNames1[0] = statisticName1.c_str();
requestedStatsNames1[1] = statisticName2.c_str();

XblRequestedStatistics requestedStats[1] = {};
pal::strcpy(requestedStats[0].serviceConfigurationId, sizeof(XblRequestedStatistics::serviceConfigurationId), scid);
requestedStats[0].statistics = requestedStatsNames1;
requestedStats[0].statisticsCount = 2;

uint64_t xuids[2] = {};
xuids[0] = xuid1;
xuids[1] = xuid2;
    
HRESULT hr = XblUserStatisticsGetMultipleUserStatisticsForMultipleServiceConfigurationsAsync(
    xboxLiveContext,
    xuids, 2,
    requestedStats, 1,
    asyncBlock.get()
);
if (SUCCEEDED(hr))
{
    // The call succeeded, so release the std::unique_ptr ownership of XAsyncBlock* because the callback will take over ownership.
    // If the call fails, the std::unique_ptr will keep ownership and delete the XAsyncBlock*.
    asyncBlock.release();
}
```

Pour plus d'informations, consultez les rubriques suivantes :

* [XAsyncBlock](/fr/reference/system/xasync/structs/xasyncblock)
* [XblRequestedStatistics](/fr/reference/live/xsapi-c/user_statistics_c/structs/xblrequestedstatistics)
* [XblUserStatisticsGetMultipleUserStatisticsForMultipleServiceConfigurationsAsync](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetmultipleuserstatisticsformultipleserviceconfigurationsasync)
* [XblUserStatisticsGetMultipleUserStatisticsForMultipleServiceConfigurationsResult](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetmultipleuserstatisticsformultipleserviceconfigurationsresult)
* [XblUserStatisticsGetMultipleUserStatisticsForMultipleServiceConfigurationsResultSize](/fr/reference/live/xsapi-c/user_statistics_c/functions/xbluserstatisticsgetmultipleuserstatisticsformultipleserviceconfigurationsresultsize)
* [XblUserStatisticsResult](/fr/reference/live/xsapi-c/user_statistics_c/structs/xbluserstatisticsresult)

## Voir aussi

[Envoyer un événement](/fr/services/xbox-services/player-data/stats-leaderboards/event-based/events/how-to/live-sending-an-event)
[En-tête user\_statistics\_c](/fr/reference/live/xsapi-c/user_statistics_c/user_statistics_c_members)

[Retour en haut de cette rubrique.](#top)


## Related topics

- [Exemples de code pour les statistiques et classements basés sur les événements](/fr/services/xbox-services/player-data/stats-leaderboards/event-based/how-to/live-statslb-eb-howto-nav.md)
- [Statistiques basées sur les événements et statistiques gérées par le titre](/fr/services/xbox-services/player-data/stats-leaderboards/live-stats-eb-vs-tm.md)
- [Premier aperçu des statistiques basées sur les événements](/fr/services/xbox-services/player-data/stats-leaderboards/event-based/config/live-stats-first-glance.md)
- [Écrire un événement pour alimenter une statistique basée sur les événements](/fr/services/xbox-services/player-data/stats-leaderboards/event-based/how-to/live-sending-eb-stat.md)
- [Vue d'ensemble des statistiques basées sur les événements](/fr/services/xbox-services/player-data/stats-leaderboards/event-based/live-stats-eb-overview.md)