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

# SDK C#

> Intégrez le SDK C# de Kameleoon pour exécuter des expériences côté serveur et activer des feature flags sur des serveurs d'applications .NET.

Bienvenue dans la documentation pour développeurs du SDK C# de Kameleoon ! Utilisez notre SDK pour exécuter des expériences sur votre serveur d'application back-end .NET. Il est facile d'intégrer notre SDK dans votre application web, et son utilisation de la mémoire et du réseau est faible.

**Premiers pas** : pour obtenir de l'aide pour démarrer, consultez le [guide du développeur](#guide-du-développeur).

**Méthodes du SDK** : pour la documentation de référence complète des méthodes du SDK C#, consultez la section [référence](#référence).

**Changelog** : dernière version du SDK C# : 4.19.0 [changelog](https://github.com/Kameleoon/client-csharp/blob/master/CHANGELOG.md).

## Guide du développeur

### Premiers pas

Ce guide est conçu pour vous aider à intégrer notre SDK dans vos applications C#.

#### Kit de démarrage

Pour vous aider à démarrer, Kameleoon fournit un kit de démarrage et une application de démonstration pour tester le SDK. Le kit de démarrage inclut une application entièrement configurée avec des exemples montrant comment les méthodes du SDK peuvent être utilisées dans une application. Le kit de démarrage, l'application de démonstration et les instructions détaillées sont disponibles sur [Starter kit for .NET](https://github.com/Kameleoon/dotnet-examples).

#### Installer le client C\#

Vous pouvez utiliser le gestionnaire de paquets NuGet, .NET CLI ou Paket pour installer le client C#.

<Tabs defaultTabIndex={0}>
  <Tab title="NuGet Package Manager">
    ```sh theme={null}
    Install-Package KameleoonClient -Version 4.17.0
    ```
  </Tab>

  <Tab title=".NET CLI">
    ```sh theme={null}
    dotnet add package KameleoonClient --version 4.17.0
    ```
  </Tab>

  <Tab title="Paket CLI">
    ```sh theme={null}
    paket add KameleoonClient --version 4.17.0
    ```
  </Tab>
</Tabs>

#### Configuration supplémentaire

Créez un fichier de configuration `.properties` pour fournir les identifiants et personnaliser le comportement du SDK. Vous pouvez également [télécharger un exemple de configuration](/assets/developer-docs/sdks/web-sdks/client-configs/client-csharp.conf). Enregistrez ce fichier dans le chemin par défaut `/etc/kameleoon/client-csharp.conf`. Si vous placez le fichier à un autre emplacement, vous devrez passer le chemin en argument à `KameleoonClientFactory.Create()`. Avec la version actuelle du SDK C#, voici les clés disponibles :

| Clé                                                                            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Valeur par défaut     |
| ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
| `clientId` / `client_id` (*obligatoire*)                                       | Nécessaire pour l'authentification auprès du service Kameleoon. Pour trouver votre `client_id`, consultez la documentation [API credentials](/user-manual/account-and-team-management/users-and-teams/api-credentials).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                       |
| `clientSecret` / `client_secret` (*obligatoire*)                               | Nécessaire pour l'authentification auprès du service Kameleoon. Pour trouver votre `client_secret`, consultez la documentation [API credentials](/user-manual/account-and-team-management/users-and-teams/api-credentials).                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                       |
| `sessionDurationMinute` / `session_duration_minute` (*optionnel*)              | Désigne l'intervalle de temps prédéfini pendant lequel Kameleoon stocke le visiteur et les données qui lui sont associées en mémoire (RAM). Notez que l'augmentation de la durée de session augmente la quantité de RAM nécessaire pour stocker les données du visiteur.                                                                                                                                                                                                                                                                                                                                                                                                                                | `30` minutes          |
| `refreshIntervalMinute` / `refresh_interval_minute` (*optionnel*)              | Spécifie l'intervalle de rafraîchissement, en minutes, auquel le SDK récupère la configuration des expériences et feature flags actifs. La valeur détermine le temps maximum nécessaire pour propager les modifications, comme l'activation ou la désactivation des feature flags ou le lancement d'expériences, vers vos serveurs de production. De plus, nous proposons un [mode streaming](/developer-docs/feature-experimentation/technical-reference/technical-considerations/#streaming-premium-option) qui utilise des server-sent events (SSE) pour pousser automatiquement les nouvelles configurations vers le SDK et appliquer les nouvelles configurations en temps réel, sans aucun délai. | `60` minutes          |
| `defaultTimeoutMillisecond` / `default_timeout_millisecond` (*optionnel*)      | Spécifie le délai d'expiration, en millisecondes, pour les requêtes réseau du SDK. Définissez la valeur sur 30 secondes ou plus si vous n'avez pas de connexion stable. Certaines méthodes ont un paramètre supplémentaire que vous pouvez utiliser pour remplacer le délai d'expiration par défaut pour cette méthode particulière. Si vous ne spécifiez pas explicitement le délai d'expiration pour une méthode, le SDK utilise cette valeur par défaut.                                                                                                                                                                                                                                             | `10000` millisecondes |
| `trackingIntervalMilliseconds` / `tracking_interval_millisecond` (*optionnel*) | Spécifie l'intervalle des requêtes de suivi en millisecondes. Tous les visiteurs que Kameleoon a évalués pour un feature flag ou dont les données ont été vidées sont inclus dans cette requête de suivi, que le SDK effectue une fois par intervalle. La valeur minimale est `1000` ms, qui est aussi la valeur par défaut, et la valeur maximale est `5000` ms.                                                                                                                                                                                                                                                                                                                                       | `1000` millisecondes  |
| `environment` / `environment` (*optionnel*)                                    | Environnement à partir duquel la configuration du feature flag doit être utilisée. La valeur peut être `production`, `staging`, `development`. Consultez l'article [managing environments](/user-manual/experimentation/feature-experimentation/configure-your-feature-flags/manage-environments) pour plus de détails.                                                                                                                                                                                                                                                                                                                                                                                 | `production`          |
| `topLevelDomain` / `top_level_domain` *(obligatoire en mode hybride)*          | Le domaine de premier niveau actuel pour votre site web. Utilisez le format : `example.com`. N'incluez pas `https://`, `www` ou d'autres sous-domaines. Kameleoon utilise cette information pour définir le cookie correspondant sur le domaine de premier niveau.                                                                                                                                                                                                                                                                                                                                                                                                                                      | `null`                |
| `proxyHost` / `proxy_host` (*optionnel*)                                       | Définit l'hôte proxy pour tous les appels serveur sortants effectués par le SDK.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `null`                |
| `networkDomain` / `network_domain` (*optionnel*)                               | Domaine personnalisé utilisé par les SDK pour les requêtes sortantes, souvent pour le proxy. Doit être un domaine valide (par exemple, example.com ou sub.example.com). Les formats invalides reviennent à la valeur Kameleoon par défaut.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `null`                |

#### Initialiser le client Kameleoon

Après avoir installé le SDK et configuré vos identifiants et le comportement du SDK, créez le client Kameleoon dans le code de votre application. Par exemple :

```csharp theme={null}
using Kameleoon;

string siteCode = "a8st4f59bj";

try {
    // Read from default configuration path: "/etc/kameleoon/client-csharp.conf"
    IKameleoonClient kameleoonClient = KameleoonClientFactory.Create(siteCode);
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}

try {
    IKameleoonClient kameleoonClient = KameleoonClientFactory.Create(siteCode, "custom/file/path/client-csharp.conf");
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}

try {
    KameleoonClientConfig config = new KameleoonClientConfig(
        clientId: "<clientId>", // mandatory
        clientSecret: "<clientId>", // mandatory
        refreshIntervalMinute: 60, // in minutes, optional (60 minutes by default)
        sessionDurationMinute: 30, // in minutes, optional (30 minutes by default)
        defaultTimeoutMillisecond: 10_000, // in milliseconds, optional (10000 ms by default)
        trackingIntervalMilliseconds: 1000, // in milliseconds, optional (1000 ms by default)
        environment: "development", // optional
        topLevelDomain: "example.com", // mandatory if you use hybrid mode (engine or web experiments)
        proxyHost: "proxy.host.com", // optional
        networkDomain: "example.com", // optional
    );
    IKameleoonClient kameleoonClient = KameleoonClientFactory.Create(siteCode, config);
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}
```

Un `IKameleoonClient` est un objet singleton qui connecte votre application à la plateforme Kameleoon. Il inclut toutes les méthodes et fonctionnalités dont vous avez besoin pour exécuter une expérience.

En tant que développeur, vous devez vous assurer que votre application utilise la logique correcte pour les A/B tests avec Kameleoon. Il est préférable d'exclure un visiteur de l'expérience si vous ne l'avez pas encore lancée. Exclure est simple car cela correspond à la logique par défaut des variations.

#### Activer un feature flag

##### Attribuer un identifiant unique à un utilisateur

Pour attribuer un identifiant unique à un utilisateur, vous pouvez utiliser la méthode [`GetVisitorCode()`](#getvisitorcode). Si un **visitor code** n'existe pas (à partir du cookie des en-têtes de la requête), la méthode génère un identifiant unique aléatoire ou utilise un `defaultVisitorCode` que vous auriez généré. L'identifiant est ensuite défini dans un cookie des en-têtes de la réponse.

Si vous utilisez Kameleoon en [mode hybride](/developer-docs/feature-experimentation/get-started/hybrid-experimentation), appeler la méthode `GetVisitorCode()` garantit que l'identifiant unique (**visitor code**) est partagé entre le fichier d'application `engine.js` (anciennement nommé `kameleoon.js`) et le SDK.

##### Récupérer une configuration de flag

Pour implémenter un feature flag dans votre code, vous devez d'abord créer le feature flag dans votre compte Kameleoon.

Pour déterminer le statut ou la variation d'un feature flag pour un utilisateur spécifique, vous devez utiliser la méthode [`GetVariation()`](#getvariation) ou [`IsFeatureActive()`](#isfeatureactive) afin de récupérer la configuration basée sur le `featureKey`.

La méthode `GetVariation()` gère à la fois les feature flags simples avec des états ON/OFF et les flags plus complexes avec plusieurs variations. La méthode récupère la variation appropriée pour l'utilisateur en vérifiant les règles du feature, en attribuant la variation et en la renvoyant en fonction du `featureKey` et du `visitorCode`.

La méthode `IsFeatureActive()` peut être utilisée si vous souhaitez récupérer la configuration d'un feature flag simple qui n'a qu'un état ON ou OFF, par opposition à des feature flags plus complexes avec plusieurs variations ou options de ciblage.

Si votre feature flag a des variables associées (comme des comportements spécifiques liés à chaque variation), `GetVariation()` vous permet également d'accéder à l'objet [`Variation`](#variation), qui fournit des détails sur la variation attribuée et son expérience associée. Cette méthode vérifie si l'utilisateur est ciblé, trouve la variation attribuée au visiteur et l'enregistre dans le stockage. Lorsque `track=true`, le SDK enverra l'événement d'exposition à l'expérience spécifiée lors de la prochaine requête de suivi, qui est déclenchée automatiquement en fonction du [`tracking_interval_millisecond`](#configuration-supplémentaire) du SDK. Par défaut, cet intervalle est défini sur 1000 millisecondes (1 seconde).

La méthode `GetVariation()` vous permet de contrôler si le suivi est effectué. Si `track=false`, aucun événement d'exposition ne sera envoyé par le SDK. Cela est utile si vous préférez ne pas suivre les données via le SDK et vous fier au suivi côté client géré par le moteur Kameleoon, par exemple. De plus, définir `track=false` est utile lorsque vous utilisez la méthode `GetVariations()`, où vous pourriez uniquement avoir besoin des variations pour tous les flags sans déclencher d'événements de suivi. Si vous voulez en savoir plus sur le fonctionnement du suivi, consultez [cet article](/developer-docs/feature-experimentation/technical-reference/faq-global#when-does-the-sdk-send-a-tracking-request-for-analytics).

##### Ajouter des points de données pour cibler un utilisateur ou filtrer / segmenter les visites dans les rapports

Pour cibler un utilisateur, assurez-vous d'avoir ajouté des points de données pertinents à son profil avant de récupérer la variation du feature ou de vérifier si le flag est actif. Utilisez la méthode [`AddData()`](#adddata) pour ajouter ces points de données au profil de l'utilisateur.

Pour récupérer les points de données collectés sur d'autres appareils ou pour accéder aux données utilisateur passées (collectées côté client lors de l'utilisation de Kameleoon en mode hybride), utilisez la méthode [`GetRemoteVisitorData()`](#getremotevisitordata). Cette méthode récupère de manière asynchrone les données depuis les serveurs. Il est important d'appeler `GetRemoteVisitorData()` *avant* de récupérer la variation ou de vérifier si le feature flag est actif, car ces données peuvent être nécessaires pour attribuer un utilisateur à une variation donnée.

Pour en savoir plus sur les conditions de ciblage disponibles, consultez l'[article détaillé sur le sujet](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation).

De plus, les points de données que vous ajoutez au profil du visiteur seront disponibles lors de l'analyse de vos expériences, vous permettant de filtrer et de segmenter vos résultats par des facteurs tels que l'appareil et le navigateur. Le mode hybride de Kameleoon collecte automatiquement une variété de points de données côté client, ce qui facilite la segmentation de vos résultats en fonction de ces points de données pré-collectés. Consultez la liste complète [ici](/fr/user-manual/experiment-analytics/analyze-results/results-page/results-page-settings#ventiler-l’audience).

Si vous devez suivre des points de données supplémentaires au-delà de ce qui est collecté automatiquement, vous pouvez utiliser la [fonctionnalité Custom Data](#customdata) de Kameleoon. Custom Data vous permet de capturer et d'analyser des informations spécifiques pertinentes pour vos expériences. N'oubliez pas d'appeler la méthode [`Flush()`](#flush) pour envoyer les données collectées aux serveurs Kameleoon pour analyse.

<Note>
  Pour garantir l'exactitude de vos résultats, il est recommandé de filtrer les bots en utilisant le type de données [`UserAgent`](#useragent).
</Note>

##### Suivre les conversions d'objectif

Lorsqu'un utilisateur effectue une action souhaitée (telle qu'un achat), elle est enregistrée comme une conversion. Pour suivre les conversions, utilisez la méthode [`TrackConversion()`](#trackconversion) et fournissez les paramètres requis `visitorCode` et `goalId`.

La requête de suivi de conversion sera envoyée avec la prochaine requête de suivi planifiée, que le SDK envoie à intervalles réguliers (définis par [`tracking_interval_millisecond`](#configuration-supplémentaire)). Si vous préférez envoyer la requête immédiatement, utilisez la méthode [`Flush()`](#flush) avec le paramètre `instant=true`.

##### Envoyer des événements aux solutions d'analyse

Pour suivre les conversions et envoyer des événements d'exposition à votre solution d'analyse client, vous devez d'abord implémenter Kameleoon en [mode hybride](/developer-docs/feature-experimentation/get-started/hybrid-experimentation/). Ensuite, utilisez la méthode [`GetEngineTrackingCode()`](#getenginetrackingcode).

La méthode `GetEngineTrackingCode()` récupère le code de suivi unique requis pour envoyer des événements d'exposition à votre solution d'analyse. L'utilisation de cette méthode vous permet d'enregistrer des événements et de les envoyer vers la plateforme d'analyse de votre choix.

### Expérimentation cross-device

Pour prendre en charge les visiteurs qui accèdent à une application depuis plusieurs appareils, Kameleoon permet la synchronisation des données visiteur précédemment collectées sur chacun des appareils du visiteur et la réconciliation de leur historique de visite entre les appareils grâce à l'expérimentation cross-device. Des études de cas et des informations détaillées sur la façon dont Kameleoon gère les données entre les appareils sont disponibles dans l'[article sur l'expérimentation cross-device](/developer-docs/cross-device-experimentation).

#### Synchroniser les custom data entre appareils

Bien que la synchronisation de mappage personnalisé soit utilisée pour aligner les données visiteur entre les appareils, ce n'est pas toujours nécessaire. Vous trouverez ci-dessous deux scénarios dans lesquels la synchronisation de mappage personnalisé n'est pas requise :

**Même ID utilisateur entre appareils**
Si le même ID utilisateur est utilisé de manière cohérente sur tous les appareils, la synchronisation est gérée automatiquement sans synchronisation de mappage personnalisé. Il suffit d'appeler la méthode `GetRemoteVisitorData()` lorsque vous souhaitez synchroniser les données collectées entre plusieurs appareils.

**Instances multi-serveurs avec des IDs cohérents**
Dans les configurations complexes impliquant plusieurs serveurs (par exemple, des instances de serveur distribuées), où le même ID utilisateur est disponible sur les serveurs, la synchronisation entre serveurs (avec `GetRemoteVisitorData()`) est suffisante sans synchronisation de mappage personnalisé supplémentaire.

Les clients qui ont besoin de données supplémentaires peuvent se référer à la description de la méthode [`GetRemoteVisitorData()`](#getremotevisitordata) pour plus d'instructions. Dans le code ci-dessous, on suppose que le même identifiant unique (dans ce cas, le `visitorCode`, qui peut également être appelé `userId`) est utilisé de manière cohérente entre les deux appareils pour une récupération précise des données.

<Note>
  Si vous souhaitez synchroniser les données collectées en temps réel, vous devez choisir la portée **Visitor** pour vos custom data.
</Note>

```csharp title="Device A" theme={null}
// In this example Custom data with index `90` was set to "Visitor" scope on Kameleoon Platform.
const int VisitorScopeCustomDataIndex = 90;

kameleoonClient.AddData(visitorCode, new CustomData(VisitorScopeCustomDataIndex, "your data"));
kameleoonClient.Flush(visitorCode);
```

```csharp title="Device B" theme={null}
// Before working with the data, call the `GetRemoteVisitorData` method.
await kameleoonClient.GetRemoteVisitorData(visitorCode);

// After calling the method, the SDK on Device B will have access to CustomData of Visitor scope as defined on Device A.
// So, "your data" will be available for targeting and tracking the visitor.
```

#### Utiliser les custom data pour la fusion de sessions

L'[expérimentation cross-device](/developer-docs/cross-device-experimentation) permet de combiner l'historique d'un visiteur entre chacun de ses appareils (réconciliation d'historique). La réconciliation d'historique permet de fusionner différentes sessions visiteur en une seule. Pour réconcilier l'historique de visite, utilisez [`CustomData`](#customdata) pour fournir un identifiant unique pour le visiteur. Pour plus d'informations, consultez la [documentation dédiée](/developer-docs/cross-device-experimentation/#activating-cross-device-history-reconciliation).

Une fois la réconciliation cross-device activée, appeler [`GetRemoteVisitorData()`](#getremotevisitordata) avec le paramètre `userId` récupère toutes les données connues pour un utilisateur donné.

Les sessions avec le même identifiant verront toujours la même variation dans une expérience. Dans la vue Visitor des pages de résultats de votre expérience, ces sessions apparaîtront comme un seul visiteur.

La configuration du SDK garantit que les sessions associées voient toujours la même variation de l'expérience. Cependant, il existe certaines limitations concernant l'allocation de variation cross-device. Ces limitations sont décrites [ici](/developer-docs/cross-device-experimentation#critical-points-and-practical-insights).

Suivez le guide [activating cross-device history reconciliation](#expérimentation-cross-device) pour configurer vos custom data sur la plateforme Kameleoon.

Ensuite, vous pouvez utiliser le SDK normalement. Les méthodes suivantes peuvent être utiles dans le contexte de la fusion de sessions :

* `GetRemoteVisitorData()` avec `UniqueIdentifier(true)` ajouté - pour récupérer les données de tous les visiteurs liés.
* [`TrackConversion()`](#trackconversion) ou [`Flush()`](#flush) avec `UniqueIdentifier(true)` ajouté - pour suivre certaines données pour un visiteur spécifique qui est associé à un autre visiteur.

<Tip>
  Comme la custom data que vous utilisez comme identifiant doit être définie sur **Visitor scope**, vous devez utiliser la [synchronisation de custom data cross-device](/developer-docs/cross-device-experimentation) pour récupérer l'identifiant avec la méthode [`GetRemoteVisitorData()`](#getremotevisitordata) sur chaque appareil.
</Tip>

Voici un exemple d'utilisation de custom data pour la fusion de sessions.

```csharp theme={null}
// In this example, `91` represents the index of the Custom Data
// configured as a unique identifier in Kameleoon.
const int MappingIndex = 91;
const string FeatureKey = "ff123";

// 1. Before the visitor is authenticated

// Retrieve the variation for an unauthenticated visitor.
// Assume `anonymousVisitorCode` is the randomly generated ID for that visitor.
Variation anonymousVariation = kameleoonClient.GetVariation(anonymousVisitorCode, FeatureKey);

// 2. After the visitor is authenticated

// Assume `userId` is the visitor code of the authenticated visitor.
kameleoonClient.AddData(anonymousVisitorCode, new CustomData(MappingIndex, userId));
kameleoonClient.Flush(anonymousVisitorCode, instant=true);

// Indicate that `userId` is a unique identifier.
kameleoonClient.AddData(userId, new UniqueIdentifier(true));

// 3. After the visitor has been authenticated

// Retrieve the variation for the `userId`, which will match the anonymous visitor code's variation.
Variation userVariation = kameleoonClient.GetVariation(userId, FeatureKey);
bool isSameVariation = userVariation.Key == anonymousVariation.Key; // true

// The `userId` and `anonymousVisitorCode` are now linked and tracked as a single visitor.
kameleoonClient.TrackConversion(userId, 123, 10.0);

// Additionally, the linked visitors will share all fetched remote visitor data.
await kameleoonClient.GetRemoteVisitorData(userId);
```

Dans cet exemple, l'application a une page de connexion. Comme l'ID utilisateur est inconnu au moment de la connexion, un identifiant de visiteur anonyme généré par la méthode [`GetVisitorCode()`](#getvisitorcode) est utilisé. Une fois l'utilisateur connecté, le visiteur anonyme est associé à l'ID utilisateur et utilisé comme identifiant unique pour le visiteur.

### Utiliser une clé de bucketing personnalisée

Par défaut, Kameleoon utilise un ID visiteur unique et anonyme (`visitorCode`) pour attribuer les utilisateurs aux variations de feature flag. Cet ID est généralement généré et stocké sur l'appareil de l'utilisateur (dans un cookie de navigateur pour les SDKs côté client et côté serveur — dans un stockage persistant pour les SDKs mobiles). Cependant, dans certains scénarios, vous pouvez avoir besoin de vous assurer que tous les utilisateurs d'une même organisation voient la même variante d'un feature flag.

L'option **Custom Bucketing Key** vous permet de remplacer ce comportement par défaut en fournissant votre propre identifiant personnalisé pour le bucketing. Cette substitution garantit que la logique d'attribution de Kameleoon utilise votre clé spécifiée au lieu du `visitorCode` par défaut.

#### Cas d'utilisation

L'utilisation d'une clé de bucketing personnalisée est essentielle pour maintenir la cohérence et la précision de vos attributions de feature flag, en particulier dans ces situations :

* **Expériences au niveau du compte ou organisationnel :** pour les produits B2B ou les scénarios où vous voulez attribuer tous les utilisateurs d'une même organisation à la même variation, vous pouvez utiliser un identifiant comme un `accountId`. Les clés de bucketing personnalisées sont cruciales pour les A/B tests des fonctionnalités qui impactent toute une équipe ou entreprise.

En implémentant une clé de bucketing personnalisée, vous garantissez une plus grande cohérence et précision dans vos expériences, conduisant à des résultats plus fiables et à une meilleure expérience utilisateur.

#### Détails techniques

Lorsque vous configurez une clé de bucketing personnalisée pour un feature flag, vous fournissez à Kameleoon un identifiant spécifique provenant des données de votre application :

```csharp theme={null}
kameleoonClient.AddData(visitorCode, new CustomData(index, "newVisitorCode"));
```

* **Fournir la clé personnalisée :** vous fournissez votre identifiant personnalisé au SDK Kameleoon à l'aide de la méthode [`AddData()`](#adddata). Dans cette méthode, vous passerez votre clé de bucketing personnalisée choisie en tant qu'objet [`CustomData`](#customdata). Ici, `newVisitorCode` fait référence à l'identifiant que vous souhaitez utiliser pour votre bucketing (par exemple, le nouveau `userId` ou `accountId`).

<Warning>
  Pour que la clé de bucketing personnalisée fonctionne correctement, elle doit également être définie et configurée pour le feature flag lors du processus de création ou de modification du flag. Sans cette configuration correspondante, le bucketing du SDK n'appliquera pas votre clé personnalisée. Pour des instructions détaillées sur la façon de configurer cela dans Kameleoon, consultez cet [article](/user-manual/experimentation/feature-experimentation/create-and-manage-flags/create-a-feature-flag#Advanced_Flag_Settings).
</Warning>

* **Logique de bucketing :** une fois qu'une clé de bucketing personnalisée est fournie via la méthode `AddData()`, tous les calculs de hachage pour attribuer les utilisateurs aux variations utiliseront ce `newVisitorCode` (votre clé personnalisée) au lieu du `visitorCode` par défaut. L'utilisation du `newVisitorCode` signifie que la décision de bucketing est liée à votre identifiant personnalisé, garantissant des attributions cohérentes dans différents contextes où cet identifiant est présent.
* **Suivi des données et analyse :** il est crucial de noter que bien que le `newVisitorCode` (votre clé personnalisée) soit utilisé pour les décisions de bucketing, **toutes les données ultérieures (événements de suivi et conversions, par exemple) sont envoyées et associées au `visitorCode` *original*.** Cette séparation garantit que vos analyses reflètent avec précision les parcours utilisateur individuels et les interactions dans le contexte plus large de votre expérience, même lorsque le bucketing est effectué à un niveau supérieur (comme un compte) ou sur plusieurs appareils/sessions. Vos données visiteur originales restent intactes pour des rapports complets.

#### Exigences techniques

Pour utiliser efficacement une clé de bucketing personnalisée :

* La clé doit être une `string`.
* Elle doit être unique pour l'entité que vous souhaitez bucketer (par exemple, si vous utilisez un `userId`, l'ID de chaque utilisateur doit être unique).
* La clé doit être disponible pour le SDK au moment exact où la décision du feature flag est évaluée pour cet utilisateur ou cette requête.

### Conditions de ciblage

Les SDKs Kameleoon prennent en charge une variété de conditions de ciblage prédéfinies que vous pouvez utiliser pour cibler les utilisateurs dans vos campagnes. Pour la liste des conditions prises en charge par ce SDK, consultez [use visit history to target users](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation).

Vous pouvez également utiliser vos propres [données externes pour cibler les utilisateurs](/developer-docs/apis/data-api-rest/tutorials/storing-and-retrieving-external-data-to-target-users).

### Journalisation

Le SDK génère des logs pour refléter divers processus internes et problèmes.

#### Niveaux de log

Le SDK prend en charge la configuration de la limitation de la journalisation par niveau de log.

```csharp theme={null}
// The `None` log level does not allow logging.
Kameleoon.Logging.KameleoonLogger.LogLevel = Kameleoon.Logging.LogLevel.None;

// The `Error` log level only allows logging issues that may affect the SDK's primary behavior.
Kameleoon.Logging.KameleoonLogger.LogLevel = Kameleoon.Logging.LogLevel.Error;

// The `Warning` log level allows logging issues which may require additional attention.
// It extends the `Error` log level.
// The `Warning` log level is a default log level.
Kameleoon.Logging.KameleoonLogger.LogLevel = Kameleoon.Logging.LogLevel.Warning;

// The `Info` log level allows logging general information on the SDK's internal processes.
// It extends the `Warning` log level.
Kameleoon.Logging.KameleoonLogger.LogLevel = Kameleoon.Logging.LogLevel.Info;

// The `DEBUG` level logs additional details about the SDK’s internal processes and extends the `INFO` level
// with more granular. diagnostic output.
// This information is not intended for end-user interpretation but can be sent to our support team
// to assist with internal troubleshooting.
Kameleoon.Logging.KameleoonLogger.LogLevel = Kameleoon.Logging.LogLevel.Debug;
```

#### Gestion personnalisée des logs

Le SDK écrit ses logs dans la sortie console par défaut. Ce comportement peut être remplacé.

<Note>
  La limitation de la journalisation par niveau de log est effectuée séparément de la logique de gestion des logs.
</Note>

```csharp theme={null}
class CustomLogger : Kameleoon.Logging.ILogger
{
    private readonly Microsoft.Extensions.Logging.ILogger inner;

    public CustomLogger(Microsoft.Extensions.Logging.ILogger inner)
    {
        this.inner = inner;
    }

    // `Log` method accepts logs from the SDK
    public void Log(Kameleoon.Logging.LogLevel level, string message)
    {
        // Custom log handling logic here. For example:
        switch (level)
        {
            case Kameleoon.Logging.LogLevel.Error:
                Microsoft.Extensions.Logging.LoggerExtensions.LogError(inner, message);
                break;
            case Kameleoon.Logging.LogLevel.Warning:
                Microsoft.Extensions.Logging.LoggerExtensions.LogWarning(inner, message);
                break;
            case Kameleoon.Logging.LogLevel.Info:
                Microsoft.Extensions.Logging.LoggerExtensions.LogInformation(inner, message);
                break;
            case Kameleoon.Logging.LogLevel.Debug:
                Microsoft.Extensions.Logging.LoggerExtensions.LogDebug(inner, message);
                break;
        }
    }
}

// Log level filtering is applied separately from log handling logic.
// The custom logger will only accept logs that meet or exceed the specified log level.
// Ensure the log level is set correctly.
Kameleoon.Logging.KameleoonLogger.LogLevel = Kameleoon.Logging.LogLevel.Debug; // Optional; defaults to `LogLevel.Warning`.
Kameleoon.Logging.KameleoonLogger.Logger = new CustomLogger();
```

## Référence

Voici la documentation de référence complète du SDK C#.

### Initialisation

#### Create()

Pour commencer à utiliser le SDK, vous devez l'initialiser. Votre application interagit avec le SDK via la classe `KameleoonClient` qui se trouve dans `Kameleoon.IKameleoonClient`. Vous pouvez créer cet objet en utilisant la méthode statique **Kameleoon.KameleoonClientFactory** `Create()`.

```csharp theme={null}
using Kameleoon;

string siteCode = "a8st4f59bj";

try {
    // Read from default configuration path: "/etc/kameleoon/client-csharp.conf"
    IKameleoonClient kameleoonClient = KameleoonClientFactory.Create(siteCode);
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}

try {
    IKameleoonClient kameleoonClient = KameleoonClientFactory.Create(siteCode, "custom/file/path/client-csharp.conf");
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}

try {
    KameleoonClientConfig config = new KameleoonClientConfig(
        clientId: "<clientId>", // mandatory
        clientSecret: "<clientId>", // mandatory
        refreshIntervalMinute: 60, // in minutes, optional (60 minutes by default)
        sessionDurationMinute: 30, // in minutes, optional (30 minutes by default)
        defaultTimeoutMillisecond: 10_000, // in milliseconds, optional (10000 ms by default)
        trackingIntervalMilliseconds: 1000, // in milliseconds, optional (1000 ms by default)
        environment: "development", // optional
        topLevelDomain: "example.com", // mandatory if you use hybrid mode (engine or web experiments)
        proxyHost: "proxy.host.com" // optional
        networkDomain: "example.com", // optional
    );
    IKameleoonClient kameleoonClient = KameleoonClientFactory.Create(siteCode, config);
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}
```

##### Arguments

| Nom                                 | Type                    | Description                                                                                                                 | Par défaut                          |
| ----------------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------- | ----------------------------------- |
| siteCode (*obligatoire*)            | `string`                | Il s'agit d'une [clé unique](/user-manual/faq#how-do-i-find-my-sitecode) du projet Kameleoon que vous utilisez avec le SDK. |                                     |
| configurationFilePath (*optionnel*) | `string`                | Chemin vers le fichier de configuration du SDK.                                                                             | `/etc/kameleoon/client-csharp.conf` |
| kameleoonConfig (*optionnel*)       | `KameleoonClientConfig` | Objet de configuration du SDK que vous pouvez passer au lieu d'utiliser un fichier de configuration.                        | `null`                              |

##### Valeur de retour

| Type               | Description                                                                                                   |
| ------------------ | ------------------------------------------------------------------------------------------------------------- |
| `IKameleoonClient` | Une instance de la classe **KameleoonClient**, qui sera utilisée pour gérer vos expériences et feature flags. |

##### Exceptions levées

| Type                                          | Description                                                                                                                                     |
| --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `KameleoonException.ConfigCredentialsInvalid` | Exception indiquant que les identifiants demandés n'ont pas été fournis dans le fichier de configuration ou en tant qu'arguments de la méthode. |
| `KameleoonException.SiteCodeIsEmpty`          | Exception indiquant que le site code spécifié est une chaîne vide, ce qui est une valeur invalide.                                              |

#### WaitInit()

`WaitInit()` attend l'initialisation du client Kameleoon. Cette méthode vous permet de vérifier que le client a été initialisé avec succès avant de procéder à d'autres opérations.

```csharp theme={null}
using static Kameleoon;

try {
    await kameleoonClient.WaitInit();
} catch (Exception exception) {
    //  indicates that client could not be initialized due to the thrown exception.
}
```

##### Valeur de retour

| Type | Description                                                              |
| ---- | ------------------------------------------------------------------------ |
| Task | La tâche se terminera lorsque le client aura été initialisé avec succès. |

##### Exceptions levées

| Type      | Description                                                                                             |
| --------- | ------------------------------------------------------------------------------------------------------- |
| Exception | Exception indiquant que le client n'est pas initialisé correctement et ne peut pas encore être utilisé. |

### Feature flags et variations

#### IsFeatureActive()

* 📨 *Envoie des données de suivi à Kameleoon (selon le paramètre `track`)*

<Note>
  Cette méthode était précédemment appelée `ActivateFeature`, qui a été supprimée dans la version `4.0.0` du SDK.
</Note>

Pour activer un feature toggle, appelez la méthode `IsFeatureActive`.

Cette méthode nécessite un **visitorCode** et un **featureKey** (ou **featureID**) pour vérifier si un utilisateur peut accéder à une fonctionnalité spécifique.

Si l'utilisateur n'a jamais été lié à cette fonctionnalité, le SDK décidera aléatoirement de l'activer, renvoyant **true** (l'utilisateur peut accéder à la fonctionnalité) ou **false** (l'utilisateur ne le peut pas). Si l'utilisateur avec le **visitorCode** donné est déjà lié à cette fonctionnalité, le système renverra la valeur précédente du **featureFlag**.

Assurez-vous d'inclure une gestion appropriée des erreurs dans votre code, comme indiqué dans l'exemple, pour capturer toute erreur potentielle.

Si vous spécifiez un `visitorCode`, la méthode `IsFeatureActive()` l'utilise comme identifiant unique du visiteur, ce qui est utile pour l'[expérimentation cross-device](/developer-docs/cross-device-experimentation). Lorsque vous spécifiez un `visitorCode` et définissez le paramètre `isUniqueIdentifier` sur `true`, le SDK lie les données vidées au visiteur associé à l'identifiant spécifié.

<Note>
  Le paramètre `isUniqueIdentifier` est obsolète. Veuillez utiliser [`UniqueIdentifier`](#uniqueidentifier) à la place.

  Le `isUniqueIdentifier` peut être utile dans des situations particulières ; par exemple, si vous ne pouvez pas accéder au `visitorCode` anonyme attribué à un visiteur, mais que vous pouvez utiliser un ID interne lié à ce visiteur via la fusion de sessions.
</Note>

<Note>
  Kameleoon utilise le suivi pour compter les sessions et les visiteurs lorsque vous appelez certaines méthodes, telles que `IsFeatureActive()`, `GetVariation()` ou `GetVariations()`.

  Utilisez la valeur par défaut `true` pour le paramètre `track` lorsque vous exposez des visiteurs à une variation et que vous devez les compter. Définissez le paramètre `track` sur `false` uniquement si vous appelez ces méthodes avant d'exposer les visiteurs.

  Par exemple, si vous appelez `GetVariations()` pour récupérer toutes les variations avant d'exposer les visiteurs, définissez le paramètre `track` sur `false`. Ce paramètre empêche Kameleoon de compter prématurément une session. Vous pouvez ensuite déclencher le suivi plus tard lorsque vous exposez explicitement le visiteur.

  Kameleoon envoie les données de suivi toutes les secondes par défaut. Vous pouvez configurer cet intervalle jusqu'à cinq secondes en utilisant l'option de configuration de l'intervalle de suivi. Kameleoon regroupe les événements de suivi en une seule session tant que l'intervalle entre les événements est inférieur à 30 minutes. Si plus de 30 minutes s'écoulent entre les événements de suivi, Kameleoon compte les événements comme des sessions distinctes. Une visite apparaît dans vos rapports 30 minutes après le dernier événement enregistré dans la session.
</Note>

```csharp theme={null}
string visitorCode = kameleoonClient.GetVisitorCode(Request, Response, "example.com");
string featureKey = "new_checkout";
bool hasNewCheckout = false;

try {
  hasNewCheckout = kameleoonClient.IsFeatureActive(visitorCode, featureKey);
  // disabling tracking
  hasNewCheckout = kameleoonClient.IsFeatureActive(visitorCode, featureKey, track: false);
}
catch (KameleoonException.FeatureNotFound e) {
  // Feature toggle not yet activated on Kameleoon's side - we consider the feature inactive.
  hasNewCheckout = false;
}
catch (Exception e) {
  // This is a generic Exception handler which will handle all exceptions.
  Console.WriteLine("Exception occured");
}
if (hasNewCheckout)
{
  // Implement new checkout code here.
}
```

<Warning>
  La méthode `IsFeatureActive()` évalue la variante servie, pas l'état du flag maître. Si vous excluez des règles, la méthode utilise l'état par défaut **Then, for everyone else serve**. Si vous sélectionnez **Off** pour cet état par défaut, la méthode renvoie toujours `false` même lorsque le feature flag maître est **On**.
</Warning>

##### Arguments

| Nom                           | Type   | Description                                                                                                                                                      |
| ----------------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitorCode                   | string | Identifiant unique de l'utilisateur. Ce champ est obligatoire.                                                                                                   |
| featureKey                    | string | Clé de la fonctionnalité que vous souhaitez exposer à un utilisateur. Ce champ est obligatoire.                                                                  |
| isUniqueIdentifier (Déprécié) | bool   | Paramètre optionnel pour spécifier si le visitorCode est un identifiant unique. S'il n'est pas fourni, la valeur par défaut est `false`. Le champ est optionnel. |
| track                         | bool   | Paramètre optionnel pour activer ou désactiver le suivi de l'évaluation de la fonctionnalité (`true` par défaut).                                                |

##### Valeur de retour

| Type | Description                                                            |
| ---- | ---------------------------------------------------------------------- |
| bool | Valeur de la fonctionnalité enregistrée pour un **visitorCode** donné. |

##### Exceptions levées

| Type                                  | Description                                                                                                                                                                                                                                                                                                |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.VisitorCodeInvalid | Exception indiquant que le visitor code spécifié n'est pas valide. (Il est soit vide, soit plus long que 255 caractères).                                                                                                                                                                                  |
| KameleoonException.FeatureNotFound    | Exception indiquant que l'ID de fonctionnalité demandé n'a pas été trouvé dans la configuration interne du SDK. Cela est généralement normal et signifie que le feature flag n'a pas encore été activé côté Kameleoon (mais le code implémentant la fonctionnalité est déjà déployé côté application web). |

#### GetVariation()

* 📨 *Envoie des données de suivi à Kameleoon (selon le paramètre `track`)*

Récupère la [`Variation`](#variation) attribuée à un visiteur donné pour un feature flag spécifique.

Cette méthode prend `visitorCode` et `featureKey` comme arguments obligatoires. L'argument `track` est optionnel et vaut `true` par défaut.

Elle renvoie la `Variation` attribuée au visiteur. Si le visiteur n'est associé à aucune règle de feature flag, la méthode renvoie la `Variation` par défaut pour le feature flag donné.

Assurez-vous que la gestion appropriée des erreurs est implémentée dans votre code pour gérer les exceptions potentielles.

<Note>
  La variation par défaut fait référence à la variation attribuée à un visiteur lorsqu'il ne correspond à aucune règle de delivery prédéfinie pour un feature flag. En d'autres termes, c'est la variation de repli appliquée à tous les utilisateurs qui ne sont pas ciblés par des règles spécifiques. Elle est représentée comme la variation dans la section "Then, for everyone else..." dans une interface de gestion.
</Note>

```csharp theme={null}
const string featureKey = "new_checkout";
Variation variation;

try
{
  variation = kameleoonClient.GetVariation(visitorCode, featureKey);
  // disabling tracking
  variation = kameleoonClient.GetVariation(visitorCode, featureKey, false);
} catch (KameleoonException.FeatureNotFound e)
{
  // The error has occurred; the feature flag isn't found in the current configuration.
} catch (KameleoonException.FeatureEnvironmentDisabled e)
{
  // The feature flag is disabled for the environment.
} catch (KameleoonException.VisitorCodeInvalid e)
{
  // The visitor code you passed to the method is invalid and can't be accepted by SDK.
}

// Fetch a variable value for the assigned variation.
string title = variation.Variables["title"].Value;

switch (variation.Key)
{
  case "on":
    // Main variation key is selected for visitorCode.
    break;
  case "alternative_variation":
    // Alternative variation key
    break;
  default:
    // Default variation key
    break;
}
```

##### Arguments

| Nom                         | Type     | Description                                                                                   | Par défaut |
| --------------------------- | -------- | --------------------------------------------------------------------------------------------- | ---------- |
| visitorCode (*obligatoire*) | `string` | Identifiant unique du visiteur.                                                               |            |
| featureKey (*obligatoire*)  | `string` | Clé de la fonctionnalité que vous souhaitez exposer à un visiteur.                            |            |
| track (*optionnel*)         | `bool`   | Paramètre optionnel pour activer ou désactiver le suivi de l'évaluation de la fonctionnalité. | `true`     |

##### Valeur de retour

| Type        | Description                                                                                  |
| ----------- | -------------------------------------------------------------------------------------------- |
| `Variation` | Une [`Variation`](#variation) attribuée à un visiteur donné pour un feature flag spécifique. |

##### Exceptions levées

| Type                         | Description                                                                                                                                                                                                                                                                                  |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid`         | Exception indiquant que le visitor code fourni n'est pas valide. Il est soit vide, soit plus long que 255 caractères.                                                                                                                                                                        |
| `FeatureNotFound`            | Exception indiquant que la clé de feature demandée n'a pas été trouvée dans la configuration interne du SDK. Cela signifie généralement que le feature flag n'est pas activé dans l'application Kameleoon (mais le code implémentant la fonctionnalité est déjà déployé dans l'application). |
| `FeatureEnvironmentDisabled` | Exception indiquant que le feature flag est désactivé pour l'environnement actuel du visiteur (par exemple, production, staging ou development).                                                                                                                                             |

#### GetVariations()

* 📨 *Envoie des données de suivi à Kameleoon (selon le paramètre `track`)*

Récupère une map d'objets [`Variation`](#variation) attribués à un visiteur donné pour tous les feature flags.

Cette méthode itère sur tous les feature flags disponibles et renvoie la `Variation` attribuée pour chaque flag associé au visiteur spécifié. Elle prend `visitorCode` comme argument obligatoire, tandis que `onlyActive` et `track` sont optionnels.

* Si `onlyActive` est défini sur `true`, la méthode `GetVariations()` renverra les variations des feature flags à condition que l'utilisateur ne soit pas bucketé avec la variation `off`.
* Le paramètre `track` contrôle si la méthode suivra ou non les attributions de variation. Par défaut, il est défini sur `true`. S'il est défini sur `false`, le suivi sera désactivé.

La map renvoyée se compose des clés de feature flag comme clés et de leur `Variation` correspondante comme valeurs. Si aucune variation n'est attribuée pour un feature flag, la méthode renvoie la `Variation` par défaut pour ce flag.

Une gestion appropriée des erreurs doit être implémentée pour gérer les exceptions potentielles.

<Note>
  La variation par défaut fait référence à la variation attribuée à un visiteur lorsqu'il ne correspond à aucune règle de delivery prédéfinie pour un feature flag. En d'autres termes, c'est la variation de repli appliquée à tous les utilisateurs qui ne sont pas ciblés par des règles spécifiques. Elle est représentée comme la variation dans la section "Then, for everyone else..." dans une interface de gestion.
</Note>

```csharp theme={null}
IReadOnlyDictionary<string, Types.Variation> variations;
try
{
    variations = kameleoonClient.GetVariations(visitorCode);
    // only active variations
    variations = kameleoonClient.GetVariations(visitorCode, true);
    // disable tracking
    variations = kameleoonClient.GetVariations(visitorCode, track: false);
}
catch (VisitorCodeInvalid e)
{
    //  Handle exception
}
```

##### Arguments

| Nom                         | Type     | Description                                                                                                               | Par défaut |
| --------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------- | ---------- |
| visitorCode (*obligatoire*) | `string` | Identifiant unique du visiteur.                                                                                           |            |
| onlyActive (*optionnel*)    | `bool`   | Paramètre optionnel indiquant s'il faut renvoyer les variations pour les feature flags actifs (`true`) ou tous (`false`). | `false`    |
| track (*optionnel*)         | `bool`   | Paramètre optionnel pour activer ou désactiver le suivi de l'évaluation de la fonctionnalité.                             | `true`     |

##### Valeur de retour

| Type                                     | Description                                                                                                                                  |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `IReadOnlyDictionary<string, Variation>` | Map qui contient les objets [`Variation`](#variation) attribués des feature flags en utilisant les clés des fonctionnalités correspondantes. |

##### Exceptions levées

| Type                 | Description                                                                                                           |
| -------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception indiquant que le visitor code fourni n'est pas valide. Il est soit vide, soit plus long que 255 caractères. |

#### GetFeatureList()

<Note>
  Cette méthode était précédemment nommée `ObtainFeatureList()`, qui a été supprimée dans la version `4.0.0` du SDK.
</Note>

Renvoie une liste des clés de feature flag actuellement disponibles pour le SDK.

```csharp theme={null}
const featureFlagIds = kameleoonClient.GetFeatureList()
```

##### Valeur de retour

| Type           | Description                    |
| -------------- | ------------------------------ |
| `List<string>` | Liste des clés de feature flag |

#### SetForcedVariation()

La méthode vous permet d'attribuer par programme une [`Variation`](#variation) spécifique à un utilisateur, en contournant le processus d'évaluation standard. Cela est particulièrement précieux pour les expériences contrôlées où la logique d'évaluation habituelle n'est pas requise ou doit être ignorée. Cela peut également être utile dans des scénarios tels que le débogage ou les tests personnalisés.

Lorsqu'une variation **forcée** est définie, elle remplace la logique d'évaluation en temps réel de Kameleoon. Les processus comme la segmentation, les conditions de ciblage et les calculs algorithmiques sont ignorés. Pour préserver la segmentation et les conditions de ciblage pendant une expérience, définissez `forceTargeting=false` à la place.

<Info>
  Les variations **simulées** ont toujours la priorité dans l'ordre d'exécution. Si un calcul de variation **simulée** est déclenché, il sera entièrement traité et complété en premier.
</Info>

Une variation forcée est traitée de la même manière qu'une variation évaluée. Elle est suivie dans les analyses et stockée dans le contexte utilisateur comme toute variation évaluée standard, garantissant la cohérence dans les rapports.

La méthode peut lever des exceptions dans certaines conditions (par exemple, paramètres invalides, contexte utilisateur ou problèmes internes). Une gestion appropriée des exceptions est essentielle pour garantir la stabilité et la résilience de votre application.

<Warning>
  Il est important de distinguer les variations **forcées** des variations **[simulées](#getvisitorcode)** :

  * **Variations forcées** : sont spécifiques à une expérience individuelle.
  * **Variations simulées** : affectent le résultat global du **feature flag**.
</Warning>

```csharp theme={null}
const int experimentId = 9516;
try
{
    // Forcing the variation "on" in the experiment 9516 for the visitor
    kameleoonClient.SetForcedVariation(visitorCode, experimentId, "on");

    // Forcing the variation "on" while preserving segmentation and targeting conditions during the experiment
    kameleoonClient.SetForcedVariation(visitorCode, experimentId, "on", false);

    // Resetting the forced variation for the experiment 9516 for the visitor
    kameleoonClient.SetForcedVariation(visitorCode, experimentId, null);
}
catch (KameleoonException ex)
{
    // Handling the exception
}
```

##### Arguments

| Nom                          | Type     | Description                                                                                                                                                                      | Par défaut |
| ---------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
| visitorCode (*obligatoire*)  | `string` | Identifiant unique du visiteur.                                                                                                                                                  |            |
| experimentId (*obligatoire*) | `int`    | **Experiment Id** qui sera ciblé et sélectionné pendant le processus d'évaluation.                                                                                               |            |
| variationKey (*obligatoire*) | `string` | **Variation Key** correspondant à une `Variation` qui doit être forcée comme valeur renvoyée pour l'expérience. Si la valeur est `null`, la variation forcée sera réinitialisée. |            |
| forceTargeting (*optionnel*) | `bool`   | Indique si le ciblage pour l'expérience doit être forcé et ignoré (`true`) ou appliqué comme dans le processus d'évaluation standard (`false`).                                  | `true`     |

##### Exceptions levées

| Type                        | Description                                                                                                                                                                                                                                         |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid`        | Exception indiquant que le visitor code fourni n'est pas valide. Il est soit vide, soit plus long que 255 caractères.                                                                                                                               |
| `FeatureExperimentNotFound` | Exception indiquant que l'experiment id demandé n'a pas été trouvé dans la configuration interne du SDK. Cela est généralement normal et signifie que l'expérience correspondante à la règle n'a pas encore été activée côté Kameleoon.             |
| `FeatureVariationNotFound`  | Exception indiquant que la variation key (id) demandée n'a pas été trouvée dans la configuration interne du SDK. Cela est généralement normal et signifie que l'expérience correspondante à la variation n'a pas encore été activée côté Kameleoon. |

<Info>
  Dans la plupart des cas, seule l'erreur de base, `KameleoonException`, doit être gérée, comme démontré dans l'exemple. Cependant, si différents types d'erreurs nécessitent une réponse, gérez chacune séparément en fonction des exigences spécifiques. De plus, pour une fiabilité accrue, les erreurs générales du langage peuvent être gérées en incluant `Exception`.
</Info>

#### EvaluateAudiences()

* 📨 *Envoie des données de suivi à Kameleoon*

Cette méthode évalue les visiteurs par rapport à tous les segments Audiences Explorer disponibles et suit ceux qui correspondent.

`EvaluateAudiences()` doit être appelée **après que toutes les données visiteur pertinentes ont été définies ou mises à jour**, et **juste avant** d'obtenir une variation de feature ou de vérifier un feature flag. Cette approche garantit que le visiteur est évalué par rapport aux données les plus actuelles disponibles, permettant une attribution précise d'audience basée sur tous les critères.

Après avoir appelé cette méthode, vous pouvez effectuer une analyse détaillée des performances des segments dans Audiences Explorer.

```csharp theme={null}
try
{
    kameleoonClient.EvaluateAudiences(visitorCode);
}
catch (KameleoonException ex)
{
    // Handling the exception
}
```

##### Arguments

| Nom                         | Type     | Description                     |
| --------------------------- | -------- | ------------------------------- |
| visitorCode (*obligatoire*) | `string` | Identifiant unique du visiteur. |

##### Exceptions levées

| Type                 | Description                                                                                                           |
| -------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception indiquant que le visitor code fourni n'est pas valide. Il est soit vide, soit plus long que 255 caractères. |

<Info>
  Dans la plupart des cas, seule l'erreur de base, `KameleoonException`, doit être gérée, comme démontré dans l'exemple. Cependant, si différents types d'erreurs nécessitent une réponse, gérez chacune séparément en fonction des exigences spécifiques. De plus, pour une fiabilité accrue, les erreurs générales du langage peuvent être gérées en incluant `Exception`.
</Info>

#### GetDataFile()

<GetDataFile sec="tip_qa" c={Context} />

<GetDataFile sec="description" c={Context} />

```csharp theme={null}
DataFile dataFile = kameleoonClient.GetDataFile();
```

##### Valeur de retour

<GetDataFile sec="return_value" c={Context} />

### Données visiteur

#### GetVisitorCode()

<Note>
  Cette méthode était précédemment appelée `ObtainVisitorCode`, qui a été supprimée dans la version `4.0.0` du SDK.
</Note>

Pour obtenir le **visitorCode** Kameleoon pour le visiteur actuel, utilisez la méthode `GetVisitorCode()`. Cette méthode est cruciale dans les environnements où les systèmes front-end et back-end doivent identifier les utilisateurs de manière cohérente. Voici comment cela fonctionne :

1. Vérifiez la présence d'un cookie **kameleoonVisitorCode** ou d'un paramètre de requête dans la requête HTTP actuelle. Si vous en trouvez un, utilisez-le comme identifiant du visiteur et passez à l'étape suivante.

2. Si vous ne trouvez pas de cookie ou de paramètre, créez aléatoirement un nouvel identifiant ou utilisez l'argument **defaultVisitorCode** s'il est fourni. Cela vous permet d'utiliser vos identifiants comme visitor codes, ce qui facilite la connexion des visiteurs Kameleoon à vos propres utilisateurs sans nécessiter de recherches supplémentaires.

3. Définissez le cookie côté serveur **kameleoonVisitorCode** à l'aide de la valeur de l'identifiant. La méthode renvoie cette valeur d'identifiant.

<Warning>
  Si vous fournissez votre propre `visitorCode`, assurez-vous qu'il est unique ! Notez également que la longueur de `visitorCode` est limitée à **255** caractères. L'utilisation d'un identifiant avec trop de caractères entraînera une exception.
</Warning>

<Info>
  La méthode `GetVisitorCode()` vous permet de définir des variations **simulées** pour un visiteur. Lorsque les cookies (d'une **requête** ou d'un **document**) contiennent la clé `kameleoonSimulationFFData`, le processus d'évaluation standard est contourné. À la place, la méthode renvoie directement une [`Variation`](#variation) basée sur les données fournies.

  Vous pouvez appliquer les simulations de deux manières :

  * **Automatiquement (recommandé) :** si vous utilisez Kameleoon Web Experimentation ou le SDK en [mode hybride](/developer-docs/feature-experimentation/get-started/hybrid-experimentation#linking-feature-experiments-with-front-end-tracking-code), le cookie est créé automatiquement lors de la simulation de l'affichage d'une variante à l'aide du [Simulation Panel](/user-manual/experimentation/feature-experimentation/using-the-rollout-planner/validation-and-rollback/using-simulation-mode).
  * **Manuellement :** définissez manuellement le cookie `kameleoonSimulationFFData`.

  Il est important de distinguer les variations **simulées** des variations **[forcées](#setforcedvariation)** :

  * **Variations simulées** : affectent le résultat global du **feature flag**.
  * **Variations forcées** : sont spécifiques à une expérience individuelle.

  ⚙️ **Configuration manuelle**

  Veuillez vous assurer que le cookie `kameleoonSimulationFFData` suit ce format :

  * `kameleoonSimulationFFData={"featureKey":{"expId":10,"varId":20}}` : simule la variation avec `varId` de l'expérience `expId` pour le `featureKey` donné.
  * `kameleoonSimulationFFData={"featureKey":{"expId":0}}` : simule la variation par défaut (définie dans la section **Then, for everyone else in Production, serve**) pour le `featureKey` donné.

  ⚠️ Pour garantir le bon fonctionnement, la valeur du cookie doit être encodée comme un composant URI en utilisant une méthode telle que [`encodeURIComponent`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent).
</Info>

```csharp theme={null}
try
{
    string visitorCode = kameleoonClient.GetVisitorCode(Request, Response);

    string visitorCode = kameleoonClient.GetVisitorCode(Request, Response, defaultVisitorCode);
}
catch (VisitorCodeInvalid e)
{
    //  Handle exception
}
```

##### Arguments

| Nom                | Type                                                             | Description                                                                                                                                                                                                    |
| ------------------ | ---------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Request            | Microsoft.AspNetCore.Http.HttpRequest / System.Web.HttpRequest   | L'objet Request actuel doit être passé en premier paramètre. Ce champ est obligatoire.                                                                                                                         |
| Response           | Microsoft.AspNetCore.Http.HttpResponse / System.Web.HttpResponse | L'objet Response actuel doit être passé en deuxième paramètre. Ce champ est obligatoire.                                                                                                                       |
| defaultVisitorCode | string                                                           | Ce paramètre sera utilisé comme **visitorCode** si aucun cookie **kameleoonVisitorCode** existant n'est trouvé sur la requête. Ce champ est optionnel, et par défaut un **visitorCode** aléatoire sera généré. |

##### Valeur de retour

| Type   | Description                                                                                                                     |
| ------ | ------------------------------------------------------------------------------------------------------------------------------- |
| string | Un **visitorCode** qui sera associé à cet utilisateur particulier et qui doit être utilisé avec la plupart des méthodes du SDK. |

##### Exceptions levées

| Type                                  | Description                                                                                                            |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.VisitorCodeInvalid | Exception indiquant que le visitor code fourni n'est pas valide (il est soit vide, soit plus long que 255 caractères). |

#### AddData()

La méthode `AddData()` ajoute des [données de ciblage](#types-de-données) au stockage afin que d'autres méthodes puissent utiliser ces données pour décider de cibler ou non le visiteur actuel.

La méthode `AddData()` ne renvoie aucune valeur et n'interagit pas seule avec les serveurs back-end de Kameleoon. Au lieu de cela, toutes les données déclarées sont enregistrées pour une transmission future à l'aide de la méthode [`Flush()`](#flush). Cette approche réduit le nombre d'appels serveur effectués, car les données sont généralement regroupées en un seul appel serveur déclenché par `Flush()`.

La méthode [`TrackConversion()`](#trackconversion) envoie également toutes les données précédemment associées, tout comme `Flush()`. Il en va de même pour les méthodes [`GetVariation()`](#getvariation) et [`GetVariations()`](#getvariations) si une règle d'expérimentation est déclenchée.

<Tip>
  Chaque visiteur ne peut avoir qu'une seule instance de données associées pour la plupart des types de données. Cependant, [`CustomData`](#customdata) est une exception. Les visiteurs peuvent avoir une instance de `CustomData` associée par index.
</Tip>

```csharp theme={null}
// Add a single data item (tracked by default)
kameleoonClient.AddData(new Browser(Browser.Browsers.CHROME));

// Add multiple data items (tracked by default)
kameleoonClient.AddData(
    visitorCode,
    new PageView("https://url.com", "title", new int[] {3}),
    new UserAgent("UserAgent")
);

// Add multiple data items stored locally for targeting only (not sent to the Kameleoon Data API)
kameleoonClient.AddData(
    visitorCode,
    false,
    new PageView("https://url.com", "title", new int[] {3}),
    new UserAgent("UserAgent")
);
```

##### Arguments

| Nom                         | Type             | Description                                                                                                                                                                                                                                 | Valeur par défaut |
| --------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- |
| visitorCode (*obligatoire*) | `string`         | Identifiant unique du visiteur.                                                                                                                                                                                                             |                   |
| track (*optionnel*)         | `bool`           | Spécifie si les données ajoutées sont éligibles au suivi. Lorsqu'il est défini sur `false`, les données sont stockées localement et utilisées uniquement pour l'évaluation du ciblage ; elles ne sont pas envoyées à la Kameleoon Data API. | `true`            |
| data (*obligatoire*)        | `params IData[]` | Collection de types de données Kameleoon.                                                                                                                                                                                                   |                   |

##### Exceptions

| Type                 | Description                                                                                                           |
| -------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception indiquant que le visitor code fourni n'est pas valide. Il est soit vide, soit plus long que 255 caractères. |

#### Flush()

* 📨 *Envoie des données de suivi à Kameleoon*

La méthode `Flush()` collecte les données Kameleoon liées au visiteur. Elle envoie ensuite une requête de suivi avec toutes les données précédemment ajoutées via la méthode `AddData`, qui n'ont pas encore été envoyées via l'une de [ces méthodes](/developer-docs/feature-experimentation/technical-reference/faq-global#when-does-the-sdk-send-a-tracking-request-for-analytics). `Flush()` est non bloquant car l'appel serveur est effectué de manière asynchrone.

`Flush()` vous permet de contrôler quand les données associées à un `visitorCode` donné sont envoyées à nos serveurs. Par exemple, si vous appelez `AddData()` une douzaine de fois, il serait inefficace d'envoyer des données au serveur après chaque appel à `AddData()`, donc tout ce que vous avez à faire est d'appeler `Flush()` une fois à la fin.

Si vous spécifiez un `visitorCode`, la méthode `Flush()` l'utilise comme identifiant unique du visiteur, ce qui est utile pour l'[expérimentation cross-device](/developer-docs/cross-device-experimentation). Lorsque vous spécifiez un `visitorCode` et définissez le paramètre `isUniqueIdentifier` sur `true`, le SDK lie les données vidées au visiteur associé à l'identifiant spécifié.

<Note>
  Le paramètre `isUniqueIdentifier` est obsolète. Veuillez utiliser [`UniqueIdentifier`](#uniqueidentifier) à la place.

  Le `isUniqueIdentifier` peut être utile dans des situations particulières ; par exemple, si vous ne pouvez pas accéder au `visitorCode` anonyme attribué à un visiteur, mais que vous pouvez utiliser un ID interne lié à ce visiteur via la fusion de sessions.
</Note>

```csharp theme={null}
string visitorCode = kameleoonClient.GetVisitorCode(Request, Response, "example.com");

kameleoonClient.AddData(new Browser(Browser.Browsers.CHROME));
kameleoonClient.AddData(
    visitorCode,
    new PageView("https://url.com", "title", new int[] {3}),
    new Conversion(32, 10f, false)
);

kameleoonClient.Flush(visitorCode); // Interval tracking (most performant tracking method)

kameleoonClient.Flush(true, visitorCode); // Instant tracking

// if you operate with unique ID
kameleoonClient.AddData(visitorCode, new UniqueIdentifier(true));
kameleoonClient.Flush(visitorCode);
```

##### Arguments

| Nom                           | Type   | Description                                                                                                                                                                                                                                                                               |
| ----------------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| instant                       | bool   | Drapeau booléen indiquant si les données doivent être envoyées instantanément (`true`) ou selon l'intervalle de suivi planifié (`false`). Ce champ est optionnel.                                                                                                                         |
| visitorCode                   | string | Identifiant unique de l'utilisateur. Ce champ est obligatoire.                                                                                                                                                                                                                            |
| isUniqueIdentifier (Déprécié) | bool   | Paramètre optionnel pour spécifier si le visitorCode est un identifiant unique. Le `visitorCode` doit être fourni et non `null` pour appliquer `isUniqueIdentifier` à un visiteur, sinon il sera ignoré. S'il n'est pas fourni, la valeur par défaut est `false`. Le champ est optionnel. |

#### GetRemoteData()

<Note>
  Cette méthode était précédemment nommée `RetrieveDataFromRemoteSource`, qui a été supprimée dans la version `4.0.0` du SDK.
</Note>

`GetRemoteData()` est une méthode qui vous permet de récupérer des données pour un **siteCode** spécifique (défini dans `KameleoonClientFactory.create()`) depuis un serveur Kameleoon distant à l'aide d'une **clé** que vous fournissez. Notre Data API stocke ces données sur nos serveurs, qui sont conçus pour gérer efficacement de grandes quantités de données. Gardez à l'esprit que comme cette méthode implique un appel serveur, elle fonctionne de manière asynchrone.

```csharp theme={null}
var testValue = await kameleoonClient.GetRemoteData("test"); // default timeout
testValue = await kameleoonClient.GetRemoteData("test", 1000);
try {
  testValue = await kameleoonClient.GetRemoteData("test");
} catch (Exception e)  {
  // Timeout or Json Parsing Exception
}
```

##### Arguments

| Nom     | Type   | Description                                                                                                                                                                                                      |
| ------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| key     | string | La clé à laquelle les données que vous essayez d'obtenir sont associées. Ce champ est obligatoire.                                                                                                               |
| timeout | int?   | Délai d'expiration (en millisecondes). Ce paramètre spécifie la durée maximale d'attente d'un résultat. Ce champ est optionnel, s'il n'est pas fourni, il utilisera la valeur par défaut de 10000 millisecondes. |

##### Valeur de retour

| Type    | Description                                                                  |
| ------- | ---------------------------------------------------------------------------- |
| JObject | Données associées à la récupération des données pour une **clé** spécifique. |

##### Exceptions levées

| Type      | Description                                                                                                                              |
| --------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| Exception | Exception indiquant que la requête a expiré ou que les données récupérées ne peuvent pas être analysées avec la méthode `JObject.Parse`. |

#### GetRemoteVisitorData()

`GetRemoteVisitorData()` est une méthode qui récupère les données de visite Kameleoon pour un utilisateur spécifique à l'aide de son `VisitorCode`. Elle fonctionne en arrière-plan et stocke ces données pour que d'autres méthodes puissent prendre des décisions de ciblage.

Ces données sont importantes pour plusieurs raisons :

* Elles vous aident à utiliser les informations collectées à partir de différents appareils.
* Elles vous permettent d'accéder à l'historique d'un utilisateur, comme les pages précédemment visitées lors de visites antérieures.
* Elles vous permettent d'utiliser des données disponibles uniquement côté client, comme les variables datalayer et les objectifs qui ne suivent les conversions que sur le front-end.

Lisez [cet article](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation) pour une meilleure compréhension des cas d'utilisation possibles.

<Warning>
  Par défaut, `GetRemoteVisitorData()` récupère automatiquement les dernières custom data stockées avec `Scope=Visitor` et les attache au visiteur sans avoir besoin d'appeler la méthode `AddData()`. C'est particulièrement utile pour [synchroniser les custom data entre plusieurs appareils](/developer-docs/sdks/web-sdks/nodejs-sdk#synchronizing-custom-data-across-devices).
</Warning>

<Note>
  Le paramètre `isUniqueIdentifier` est obsolète. Veuillez utiliser [`UniqueIdentifier`](#uniqueidentifier) à la place.

  Le `isUniqueIdentifier` peut être utile dans des situations particulières ; par exemple, si vous ne pouvez pas accéder au `visitorCode` anonyme attribué à un visiteur, mais que vous pouvez utiliser un ID interne lié à ce visiteur via la fusion de sessions.
</Note>

```csharp theme={null}
string visitorCode = "visitorCode";
// Visitor data will be fetched and automatically added for `visitorCode`
Task<IReadOnlyCollection<IData>> visitorData = kameleoonClient.GetRemoteVisitorData(visitorCode);

// If you only want to fetch data and add it yourself manually, set addData == `false`.
Task<IReadOnlyCollection<IData>> visitorData = kameleoonClient.GetRemoteVisitorData(visitorCode, false);

// If you want to fetch custom list of data types
var filter = new RemoteVisitorDataFilter(25, customData: false, conversions: true, experiments: true);
var visitorData = kameleoonClient.getRemoteVisitorData(visitorCode, filter: filter);

try {
  IReadOnlyCollection<IData> visitorData = await kameleoonClient.GetRemoteVisitorData(visitorCode);
  // Your custom code
} catch (Exception e) {
  // Catch exception
}
```

##### Arguments

| Nom                           | Type                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                   |
| ----------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitorCode                   | string                                    | Le visitor code pour lequel vous souhaitez récupérer les données attribuées. Ce champ est obligatoire.                                                                                                                                                                                                                                                                                                        |
| addData                       | bool                                      | Booléen indiquant si la méthode doit automatiquement ajouter les données récupérées pour un visiteur. Ce champ est optionnel.                                                                                                                                                                                                                                                                                 |
| timeout                       | int?                                      | Délai d'expiration (en millisecondes). Ce paramètre spécifie la durée maximale d'attente d'un résultat. Ce champ est optionnel. S'il n'est pas fourni, la valeur par défaut est 10000 millisecondes.                                                                                                                                                                                                          |
| filter                        | `Kameleoon.Types.RemoteVisitorDataFilter` | Filtre pour spécifier quelles données doivent être récupérées des visites, par défaut seules les `CustomData` sont récupérées de la visite actuelle et de la dernière visite précédente (`new RemoteVisitorDataFilter(previousVisitAmount: 1, currentVisit: true, customData: true)` ou `RemoteVisitorDataFilter.Default`). Les autres paramètres de filtre sont définis sur `false`. Ce champ est optionnel. |
| isUniqueIdentifier (Déprécié) | bool                                      | Paramètre optionnel pour spécifier si le visitorCode est un identifiant unique. S'il n'est pas fourni, la valeur par défaut est `false`. Le champ est optionnel.                                                                                                                                                                                                                                              |

##### Valeur de retour

| Type                               | Description                              |
| ---------------------------------- | ---------------------------------------- |
| `Task<IReadOnlyCollection<IData>>` | Collection associée à un visiteur donné. |

##### Exceptions levées

| Type                 | Description                                                                |
| -------------------- | -------------------------------------------------------------------------- |
| HttpRequestException | Exception indiquant que la requête a échoué pour une raison quelconque.    |
| Exception            | Exception indiquant que la requête a expiré ou toute autre raison d'échec. |

##### Utiliser les paramètres dans GetRemoteVisitorData()

La méthode `GetRemoteVisitorData()` offre une flexibilité en vous permettant de définir divers paramètres lors de la récupération de données sur les visiteurs. Que vous cibliez en fonction des objectifs, des expériences ou des variations, la même approche s'applique à tous les types de données.

Par exemple, supposons que vous souhaitiez récupérer des données sur les visiteurs qui ont complété un objectif "Order transaction". Vous pouvez spécifier des paramètres dans la méthode `GetRemoteVisitorData()` pour affiner votre ciblage. Par exemple, si vous souhaitez cibler uniquement les utilisateurs qui ont converti sur l'objectif lors de leurs cinq dernières visites, vous pouvez définir le paramètre `PreviousVisitAmount` sur 5 et `Conversions` sur true.

La flexibilité illustrée dans cet exemple n'est pas limitée aux données d'objectif. Vous pouvez utiliser des paramètres dans la méthode `GetRemoteVisitorData()` pour récupérer des données sur une variété de comportements visiteur.

<Note>
  Voici la liste des options `Kameleoon.Types.RemoteVisitorDataFilter` disponibles :

  | Nom                               | Type   | Description                                                                                                                                                                                                 | Par défaut |
  | --------------------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
  | previousVisitAmount (*optionnel*) | `int`  | Nombre de visites précédentes pour récupérer les données. Nombre entre `1` et `25`                                                                                                                          | `1`        |
  | currentVisit (*optionnel*)        | `bool` | Si true, les données de la visite actuelle seront récupérées                                                                                                                                                | `true`     |
  | customData (*optionnel*)          | `bool` | Si true, les custom data seront récupérées.                                                                                                                                                                 | `true`     |
  | pageViews (*optionnel*)           | `bool` | Si true, les données de page seront récupérées.                                                                                                                                                             | `false`    |
  | geolocation (*optionnel*)         | `bool` | Si true, les données de géolocalisation seront récupérées.                                                                                                                                                  | `false`    |
  | device (*optionnel*)              | `bool` | Si true, les données d'appareil seront récupérées.                                                                                                                                                          | `false`    |
  | browser (*optionnel*)             | `bool` | Si true, les données de navigateur seront récupérées.                                                                                                                                                       | `false`    |
  | operatingSystem (*optionnel*)     | `bool` | Si true, les données de système d'exploitation seront récupérées.                                                                                                                                           | `false`    |
  | conversions (*optionnel*)         | `bool` | Si true, les données de conversion seront récupérées.                                                                                                                                                       | `false`    |
  | experiments (*optionnel*)         | `bool` | Si true, les données d'expérience seront récupérées.                                                                                                                                                        | `false`    |
  | kcs (*optionnel*)                 | `bool` | Si true, le Kameleoon Conversion Score (KCS) sera récupéré. Nécessite le [module complémentaire AI Predictive Targeting](/user-manual/ai-predictive-targeting/target-users-based-on-likelihood-to-convert). | `false`    |
  | visitorCode (*optionnel*)         | `bool` | Si true, le `visitorCode` de la visite la plus récente doit être récupéré et appliqué au visiteur actuel. Requis pour l'[expérimentation cross-device](/developer-docs/cross-device-experimentation).       | `true`     |
  | cbs (*optionnel*)                 | `bool` | Si true, les données de score Contextual Bandit seront récupérées.                                                                                                                                          | `false`    |
</Note>

#### GetVisitorWarehouseAudience()

Cette méthode récupère toutes les données d'audience associées au visiteur dans votre data warehouse en utilisant les `visitorCode` et `warehouseKey` spécifiés. Le `warehouseKey` est généralement votre ID utilisateur interne. Le paramètre `customDataIndex` correspond à la custom data Kameleoon que Kameleoon utilise pour cibler vos visiteurs. Vous pouvez consulter la [documentation sur le ciblage warehouse](/user-manual/integrations/data-warehouses/bigquery/use-bigquery-as-a-source-audience-targeting) pour plus de détails. La méthode renvoie un objet `CustomData`, confirmant que les données ont été ajoutées au visiteur et sont disponibles à des fins de ciblage.

```csharp theme={null}
Task<CustomData> warehouseAudienceDataTask = kameleoonClient.
  GetVisitorWarehouseAudience(visitorCode, customDataIndex); // default timeout
Task<CustomData> warehouseAudienceDataTask = kameleoonClient.
  GetVisitorWarehouseAudience(visitorCode, customDataIndex, timeout: 1000);

// If you need to specify warehouse key
Task<CustomData> warehouseAudienceDataTask = kameleoonClient.
  GetVisitorWarehouseAudience(visitorCode, customDataIndex, warehouseKeyValue); // default timeout
Task<CustomData> warehouseAudienceDataTask = kameleoonClient.
  GetVisitorWarehouseAudience(visitorCode, customDataIndex, warehouseKeyValue, 1000);

try
{
  CustomData warehouseAudienceData = await warehouseAudienceDataTask;
  // Your custom code
}
catch (Exception e)
{
  // Catch exception
}
```

##### Arguments

| Nom             | Type   | Description                                                                                                                                                                                          |
| --------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitorCode     | string | Une chaîne d'identification unique du visiteur, ne peut pas dépasser 255 caractères de longueur.                                                                                                     |
| customDataIndex | int    | Un entier représentant l'index de la custom data que vous souhaitez utiliser pour cibler vos BigQuery Audiences.                                                                                     |
| warehouseKey    | string | Une clé unique pour identifier les données du warehouse (généralement, votre ID utilisateur interne). Ce champ est optionnel.                                                                        |
| timeout         | int?   | Délai d'expiration (en millisecondes). Ce paramètre spécifie la durée maximale d'attente d'un résultat. Ce champ est optionnel. S'il n'est pas fourni, la valeur par défaut est 10000 millisecondes. |

##### Valeur de retour

| Type               | Description                                                                        |
| ------------------ | ---------------------------------------------------------------------------------- |
| `Task<CustomData>` | Une instance `CustomData` confirmant que les données ont été ajoutées au visiteur. |

##### Exceptions levées

| Type                                  | Description                                                                                                            |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.VisitorCodeInvalid | Exception indiquant que le visitor code fourni n'est pas valide (il est soit vide, soit plus long que 255 caractères). |
| HttpRequestException                  | Exception indiquant que la requête a échoué pour une raison quelconque.                                                |
| Exception                             | Exception indiquant que la requête a expiré ou toute autre raison d'échec.                                             |

#### SetLegalConsent()

Vous devez utiliser cette méthode pour spécifier si le visiteur a donné son consentement légal pour utiliser des données personnelles. Définir le paramètre `legalConsent` sur `false` limite les types de données que vous pouvez inclure dans les requêtes de suivi. Cette méthode vous aide à respecter les exigences légales et réglementaires tout en gérant de manière responsable les données visiteur. Vous pouvez trouver plus d'informations sur les données personnelles dans la [politique de gestion du consentement](/user-manual/project-management/consent-management-policy).

```csharp theme={null}
string visitorCode = kameleoonClient.GetVisitorCode(httpRequest, httpResponse);
kameleoonClient.SetLegalConsent(visitorCode, true, httpResponse);
```

##### Arguments

| Nom          | Type                                                            | Description                                                                                                                                                                                                                                     |
| ------------ | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitorCode  | string                                                          | L'identifiant unique de l'utilisateur. Ce champ est obligatoire.                                                                                                                                                                                |
| legalConsent | bool                                                            | Valeur booléenne représentant le statut du consentement légal. `true` indique que le visiteur a donné son consentement légal, `false` indique que le visiteur n'a jamais fourni, ou a retiré, son consentement légal. Ce champ est obligatoire. |
| response     | Microsoft.AspNetCore.Http.HttpResponse / System.Web.HttpRequest | La réponse HTTP où les valeurs des cookies seront ajustées en fonction du statut du consentement légal. Ce champ est optionnel.                                                                                                                 |

##### Exceptions levées

| Type                                  | Description                                                                                                           |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.VisitorCodeInvalid | Exception indiquant que le visitor code fourni n'est pas valide. Il est soit vide, soit plus long que 255 caractères. |

##### Comportement de révocation du consentement

Lorsque vous appelez `setLegalConsent()` avec `consent=false`, le SDK ne supprime pas le cookie `kameleoonVisitorCode`. Au lieu de cela, il cesse d'étendre la date d'expiration du cookie, permettant au cookie de persister jusqu'à son expiration naturelle.

Si vos exigences de conformité demandent la suppression immédiate du fichier cookie lors de l'opt-out, vous devez le supprimer manuellement à l'aide des méthodes natives de gestion des cookies de votre framework. Le SDK ne supprimera pas le fichier automatiquement.

### Objectifs et analyses tierces

#### TrackConversion()

* 📨 *Envoie des données de suivi à Kameleoon*

Utilisez cette méthode pour suivre une conversion pour un [objectif](/user-manual//assets/goals/create-a-goal) et un utilisateur spécifiques. Cette méthode nécessite `visitorCode` et `goalId`. De plus, cette méthode accepte également les arguments optionnels `revenue`, `negative` et `metadata`. Le `visitorCode` est généralement identique à celui qui a été utilisé lors du déclenchement de l'expérience.

La méthode `TrackConversion()` ne renvoie aucune valeur. Cette méthode est non bloquante car l'appel serveur est effectué de manière asynchrone.

<Note>
  Le paramètre `isUniqueIdentifier` est obsolète. Veuillez utiliser [`UniqueIdentifier`](#uniqueidentifier) à la place.

  Le `isUniqueIdentifier` peut également être utile dans d'autres scénarios particuliers, par exemple lorsque vous ne pouvez pas accéder au `visitorCode` anonyme qui a été initialement attribué au visiteur, mais que vous avez accès à un ID interne qui est connecté au visiteur anonyme via les capacités de fusion de sessions.
</Note>

```csharp theme={null}
using Kameleoon;

string visitorCode = kameleoonClient.GetVisitorCode(Request, Response, "example.com");
int goalId = 83023;

kameleoonClient.TrackConversion(visitorCode, goalId);

// Add metadata
var cd = new CustomData(1, "metadata");
kameleoonClient.TrackConversion(visitorCode, goalId, metadata: cd)
```

##### Arguments

| Nom                             | Type                  | Description                                                                                                                                                                                                                                                                                                                                                    | Par défaut          |
| ------------------------------- | --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
| visitorCode (*obligatoire*)     | `string`              | Identifiant unique du visiteur.                                                                                                                                                                                                                                                                                                                                |                     |
| goalId (*obligatoire*)          | `int`                 | ID de l'objectif.                                                                                                                                                                                                                                                                                                                                              |                     |
| revenue (*optionnel*)           | `float?`              | Revenu de la conversion.                                                                                                                                                                                                                                                                                                                                       | `0`                 |
| negative (*optionnel*)          | `bool`                | Définit si le revenu est positif ou négatif.                                                                                                                                                                                                                                                                                                                   | `false`             |
| metadata (*optionnel*)          | `params CustomData[]` | Permet de définir des valeurs spécifiques pour les custom data qui ont été définies comme metadata pour l'objectif dans l'application Kameleoon. Exemple : `[CustomData{id: 5, value: "Payment Type"}, CustomData{id: 6, value: "Delivery Method"}]`. Dans cet exemple, `5` et `9` sont les index des custom data (5 = "Payment Type", 9 = "Delivery Method"). | `new CustomData[0]` |
| isUniqueIdentifier *(déprécié)* | `bool`                | Paramètre optionnel pour spécifier si le visitorCode est un identifiant unique.                                                                                                                                                                                                                                                                                | `false`             |

<Note>
  Les valeurs metadata sont accessibles via les [exports de données brutes](/user-manual/experiment-analytics/analyze-results/results-page/results-page-actions#Export) et [la page de résultats](/user-manual/experiment-analytics/analyze-results/data-and-metrics/goal-metadata).

  Si le paramètre `metadata` est fourni, Kameleoon utilisera ces valeurs spécifiées pour la conversion actuelle au lieu de ce qui a été précédemment collecté avec la méthode [`AddData()`](#adddata). Si le paramètre est omis, Kameleoon utilisera les dernières valeurs suivies pour ces [`CustomData`](#customdata) avant la conversion et au cours de la même visite.

  Kameleoon ne prendra en compte que les valeurs metadata explicitement passées en paramètres à la méthode `TrackConversion()`.

  Dans l'exemple ci-dessous, Kameleoon associera la conversion uniquement à la valeur de custom data explicitement fournie en paramètre (ici : index 5 avec la valeur 'Amex Credit Card').

  ```csharp theme={null}
  kameleoonClient.AddData(visitorCode, new CustomData(5, "Credit Card"), new CustomData(9, "Express Delivery"));
  kameleoonClient.TrackConversion(visitorCode, 10, metadata: new CustomData(5, "Amex Credit Card"));
  ```
</Note>

##### Exceptions

| Type                 | Description                                                                                                           |
| -------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception indiquant que le visitor code fourni n'est pas valide. Il est soit vide, soit plus long que 255 caractères. |

#### GetEngineTrackingCode()

Kameleoon s'intègre à plusieurs solutions d'analyse, notamment Mixpanel, Google Analytics 4 et Segment. Pour suivre correctement les expériences côté serveur, appelez la méthode `GetEngineTrackingCode()` après que le visiteur a déclenché une expérience. Le SDK renvoie des commandes de queue JavaScript pour les expériences que le visiteur a déclenchées au cours des cinq dernières secondes. Lorsque vous insérez ce code dans la page, Engine.js traite les commandes et envoie les événements d'exposition via l'intégration d'analyse active.

Reportez-vous à l'[expérimentation hybride](/developer-docs/feature-experimentation/get-started/hybrid-experimentation) pour plus d'informations sur l'implémentation de cette méthode.

```csharp theme={null}
string engineTrackingCode = kameleoonClient.GetEngineTrackingCode(visitorCode);
```

<Note>
  * Pour utiliser cette fonctionnalité, implémentez à la fois le SDK C# et le [Engine.js](/developer-docs/web-experimentation/implementation-and-deployment/standard-implementation) de Kameleoon. Comme Engine.js n'est utilisé que pour le suivi dans ce flux, vous pouvez installer le tag asynchrone avant la balise `</body>` de fermeture.
  * Si vous souhaitez uniquement suivre les expériences dans Kameleoon et n'avez pas besoin d'envoyer des événements d'exposition à des outils d'analyse tiers, utilisez le [SDK JavaScript / TypeScript](/developer-docs/sdks/web-sdks/js-sdk). Cette option fonctionne bien pour les [plateformes serverless edge compute](/developer-docs/feature-experimentation/implementation-and-deployment/serverless-edge-compute-starter-kits). Le SDK JavaScript / TypeScript suit automatiquement les variations lorsque vous appelez [`getVisitorCode`](/developer-docs/sdks/web-sdks/js-sdk#getvisitorcode), tant que vous ajoutez les attributions d'expérience correspondantes à `window.kameleoonQueue`.
  * Vous pouvez insérer le code de suivi renvoyé directement dans une balise HTML `<script>`.

  ```html theme={null}
  <html lang="en">
    <body>
      <script>
        const engineTrackingCode = `
          window.kameleoonQueue = window.kameleoonQueue || [];
          window.kameleoonQueue.push(['Experiments.assignVariation', 123456, 7890, true]);
          window.kameleoonQueue.push(['Experiments.trigger', 123456, true]);
          window.kameleoonQueue.push(['Experiments.assignVariation', 234567, 8901, true]);
          window.kameleoonQueue.push(['Experiments.trigger', 234567, true]);
        `;
        const script = document.createElement('script');

        script.textContent = engineTrackingCode;
        document.body.appendChild(script);
      </script>

    </body>
  </html>
  ```

  Dans cet exemple, `123456` et `234567` sont des IDs d'expérience, et `7890` et `8901` sont des IDs de variation. Dans votre implémentation, le SDK génère ces valeurs dans le code de suivi renvoyé.
</Note>

##### Arguments

| Nom                         | Type     | Description                     |
| --------------------------- | -------- | ------------------------------- |
| visitorCode (*obligatoire*) | `string` | Identifiant unique du visiteur. |

##### Valeur de retour

| Type     | Description                             |
| -------- | --------------------------------------- |
| `string` | Code JavaScript à insérer dans la page. |

### Événements

#### UpdateConfigurationHandler()

La méthode `UpdateConfigurationHandler()` vous permet de gérer l'événement lorsque la configuration a mis à jour les données. Elle prend un paramètre d'entrée, **handler**. Le handler qui sera appelé lorsque la configuration est mise à jour à l'aide d'un événement de configuration en temps réel.

```csharp theme={null}
kameleoonClient.UpdateConfigurationHandler(async delegate () {
  // Configuration was updated
});
```

##### Arguments

| Nom     | Type     | Description                                                                                                                 |
| ------- | -------- | --------------------------------------------------------------------------------------------------------------------------- |
| handler | `Action` | Le handler qui sera appelé lorsque la configuration est mise à jour à l'aide d'un événement de configuration en temps réel. |

### Types de données

Les données disponibles dans le SDK ne sont pas disponibles pour le ciblage et le reporting dans l'application Kameleoon tant qu'elles ne sont pas ajoutées ; par exemple, en utilisant la méthode `addData()`.
Consultez [use visit history to target users](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation) pour plus d'informations.

<Note>
  Si vous êtes en mode hybride, vous pouvez appeler `GetRemoteVisitorData()` pour remplir automatiquement toutes les données précédemment collectées par Kameleoon.
</Note>

Les types de données suivants sont disponibles dans `Kameleoon.Data.IData`.

#### Browser

L'ensemble de données `Browser` stocké ici peut être utilisé pour filtrer les rapports d'expérience et de personnalisation par toute valeur qui lui est associée.

| Nom                     | Type               | Description                                                                                                  |
| ----------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------ |
| browser (*obligatoire*) | `Browser.Browsers` | Liste des navigateurs : `CHROME`, `INTERNET_EXPLORER`, `FIREFOX`, `SAFARI`, `OPERA`, `OTHER`.                |
| version (*optionnel*)   | `float?`           | Version du navigateur, le nombre à virgule flottante représente la version majeure et mineure du navigateur. |

```csharp theme={null}
kameleoonClient.AddData(visitorCode, new Browser(Browser.Browsers.CHROME));

kameleoonClient.AddData(visitorCode, new Browser(Browser.Browsers.SAFARI, 16));
```

#### PageView

| Nom       | Type   | Description                                             |
| --------- | ------ | ------------------------------------------------------- |
| url       | string | URL de la page consultée. Ce champ est obligatoire.     |
| title     | string | Titre de la page consultée. Ce champ est obligatoire.   |
| referrers | int\[] | Référents des pages consultées. Ce champ est optionnel. |

<Note>
  L'index (ID) du référent est disponible dans notre Back-Office sur la page de configuration des canaux d'acquisition. Attention : cet index commence à 0, donc le premier [canal d'acquisition](/user-manual/assets/advanced-targeting-tools/create-an-acquisition-channel) que vous créez pour un site donné aurait l'ID 0, et non 1.
</Note>

```csharp theme={null}
kameleoonClient.AddData(
  visitorCode,
  new PageView("https://url.com", "title", new int[] {3})
);
```

#### Conversion

L'ensemble de données `Conversion` stocké ici peut être utilisé pour filtrer les rapports d'expérience et de personnalisation par tout objectif qui lui est associé.

<Tip>
  * Chaque visiteur peut avoir plusieurs objets `Conversion`.
  * Vous pouvez trouver le `goalId` dans l'application Kameleoon.
</Tip>

| Nom                    | Type                  | Description                                  | Par défaut          |
| ---------------------- | --------------------- | -------------------------------------------- | ------------------- |
| goalId (*obligatoire*) | `int`                 | ID de l'objectif.                            |                     |
| revenue (*optionnel*)  | `float`               | Revenu de la conversion                      | `0`                 |
| negative (*optionnel*) | `bool`                | Définit si le revenu est positif ou négatif. | `false`             |
| metadata (*optionnel*) | `params CustomData[]` | Metadata de la conversion.                   | `new CustomData[0]` |

```csharp theme={null}
kameleoonClient.AddData(visitorCode, new Conversion(32, 10f));

kameleoonClient.AddData(visitorCode, new Conversion(33, negative: true));

kameleoonClient.AddData(
    visitorCode,
    new Conversion(34, 5f, metadata: new CustomData(3, "metadata1", "md2"), new CustomData(5, "md3"))
);
```

#### CustomData

`CustomData` permet d'associer facilement tout type de données à chaque visiteur. Il peut ensuite être utilisé comme condition de ciblage dans les [segments](/user-manual/assets/segments/create-a-segment/) ou comme filtre/segmentation dans les rapports d'expérience.
Pour en savoir plus sur les custom data, veuillez consulter cet [article](/developer-docs/custom-data).

| Nom                        | Type              | Description                                                                                                                                                                                                                 | Par défaut |
| -------------------------- | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
| index/name (*obligatoire*) | `int`/`string`    | Index ou nom de la custom data. **Soit `index`, soit `name` doit être fourni** pour identifier les données.                                                                                                                 |            |
| values (*obligatoire*)     | `params string[]` | Valeurs de la custom data à stocker.                                                                                                                                                                                        |            |
| overwrite (*optionnel*)    | `bool`            | Drapeau pour contrôler explicitement comment les valeurs sont stockées et comment elles apparaissent dans les rapports. [Voir plus](/developer-docs/custom-data#default-logic-when-overwrite-parameter-is-false-or-omitted) | `true`     |

<Note>
  * Chaque visiteur n'est autorisé qu'à une seule `CustomData` pour chaque `index` unique. Ajouter une autre `CustomData` avec le même `index` remplacera celle existante.

  * L'index de la custom data peut être trouvé dans le [Custom Data dashboard](/user-manual/assets/custom-data/manage-custom-data) sous la colonne "INDEX".

  * Pour empêcher le SDK d'envoyer des données avec l'index sélectionné aux serveurs Kameleoon pour des raisons de confidentialité, activez l'option : **Use this data only locally for targeting purposes** lors de la création de la custom data.

  * Ajouter une instance `CustomData` créée avec un nom alors que la configuration de l'instance SDK n'est pas à jour ou que le nom n'est pas enregistré entraînera l'ignorance des données.
</Note>

```csharp theme={null}
kameleoonClient.AddData(visitorCode, new CustomData(1, "value"));

// With several values
kameleoonClient.AddData(visitorCode, new CustomData(1, "value1", "value2"));

// To set the 'overwrite' flag to false
kameleoonClient.AddData(visitorCode, new CustomData(1, false, "value"));

// To use a name instead of the index
kameleoonClient.AddData(visitorCode, new CustomData("my-custom-data", "value"));
```

#### Device

| Nom    | Type        | Description                                                                         |
| ------ | ----------- | ----------------------------------------------------------------------------------- |
| device | Device.Type | Liste des appareils : **PHONE**, **TABLET**, **DESKTOP**. Ce champ est obligatoire. |

```csharp theme={null}
kameleoonClient.AddData(visitorCode, new Device(Device.Type.DESKTOP));
```

#### UserAgent

Les expériences côté serveur sont plus susceptibles d'être affectées par le trafic des bots que les expériences côté client. Kameleoon utilise la liste IAB/ABC International Spiders and Bots pour traiter ce problème et reconnaître les bots et spiders connus. Kameleoon utilise également le champ `UserAgent` pour filtrer les bots et autres trafics indésirables qui pourraient fausser vos métriques de conversion. Pour plus de détails, consultez notre article d'aide sur le [filtrage des bots](/user-manual/faq#how-does-kameleoon-filter-bot-traffic-from-my-results).

Si vous utilisez des bots internes, nous vous suggérons de passer la valeur **curl/8.0** du userAgent pour les exclure de nos analyses.

| Nom   | Type   | Description                                                                                  |
| ----- | ------ | -------------------------------------------------------------------------------------------- |
| Value | string | La valeur `UserAgent` qui sera envoyée avec les requêtes de suivi. Ce champ est obligatoire. |

```csharp theme={null}
kameleoonClient.AddData(visitorCode, new UserAgent("Your User Agent"));
```

#### UniqueIdentifier

Si vous n'ajoutez pas `UniqueIdentifier` pour un visiteur, `visitorCode` est utilisé comme identifiant unique du visiteur, ce qui est utile pour l'[expérimentation cross-device](/developer-docs/cross-device-experimentation). Lorsque vous ajoutez `UniqueIdentifier` pour un visiteur, le SDK lie les données vidées au visiteur associé à l'identifiant spécifié.

Le `isUniqueIdentifier` peut être utile dans des situations particulières ; par exemple, si vous ne pouvez pas accéder au `visitorCode` anonyme attribué à un visiteur, mais que vous pouvez utiliser un ID interne lié à ce visiteur via la fusion de sessions.

| Nom   | Type   | Description                                                                                     |
| ----- | ------ | ----------------------------------------------------------------------------------------------- |
| value | `bool` | Paramètre pour spécifier si le visitorCode est un identifiant unique. Ce champ est obligatoire. |

```csharp theme={null}
kameleoonClient.AddData(visitorCode, new UniqueIdentifier(true));
```

#### OperatingSystem

`OperatingSystem` contient des informations sur le système d'exploitation de l'appareil du visiteur.

<Note>
  Chaque visiteur ne peut avoir qu'un seul `OperatingSystem`. Ajouter un deuxième `OperatingSystem` remplace le premier.
</Note>

| Nom  | Type                   | Description                                                                                                                   |
| ---- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| type | `OperatingSystem.Type` | Liste des systèmes d'exploitation : `WINDOWS`, `MAC`, `IOS`, `LINUX`, `ANDROID` et `WINDOWS_PHONE`. Ce champ est obligatoire. |

```csharp theme={null}
kameleoonClient.addData(visitorCode, new OperatingSystem(OperatingSystem.Type.WINDOWS));
```

#### Cookie

`Cookie` contient des informations sur le cookie stocké sur l'appareil du visiteur.

| Nom     | Type                                  | Description                                                                                 |
| ------- | ------------------------------------- | ------------------------------------------------------------------------------------------- |
| cookies | `IReadOnlyDictionary<string, string>` | Une map d'objet string composée de clés et de valeurs de cookies. Ce champ est obligatoire. |

<Note>
  Chaque visiteur ne peut avoir qu'un seul `Cookie`. Ajouter un deuxième `Cookie` remplace le premier.
</Note>

```csharp theme={null}
Cookie cookie = new Cookie (new Dictionary<string, string>() {
    { "k1", "v1" },
    { "k2", "v2" },
});
kameleoonClient.addData(visitorCode, cookie);
```

#### Geolocation

`Geolocation` contient les détails de géolocalisation du visiteur.

| Nom                      | Type                  | Description                                                                                                               |
| ------------------------ | --------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| country (*obligatoire*)  | `string`              | Le pays du visiteur.                                                                                                      |
| region (*optionnel*)     | <nobr>`string`</nobr> | La région du visiteur.                                                                                                    |
| city (*optionnel*)       | <nobr>`string`</nobr> | La ville du visiteur.                                                                                                     |
| postalCode (*optionnel*) | <nobr>`string`</nobr> | Le code postal du visiteur.                                                                                               |
| latitude (*optionnel*)   | `float`               | La coordonnée de latitude représentant la position du visiteur. Le nombre de coordonnées représente des degrés décimaux.  |
| longitude (*optionnel*)  | `float`               | La coordonnée de longitude représentant la position du visiteur. Le nombre de coordonnées représente des degrés décimaux. |

<Tip>
  * Chaque visiteur ne peut avoir qu'une seule `Geolocation`. Ajouter une deuxième `Geolocation` remplace la première.
</Tip>

```csharp theme={null}
kameleoonClient.addData(visitorCode, new Geolocation("France", "Île-de-France", "Paris"));
```

#### ApplicationVersion

`ApplicationVersion` représente le numéro de version sémantique de votre application.

<Tip>
  Un **visiteur** ne peut avoir qu'une seule `ApplicationVersion`. Ajouter une deuxième instance remplacera la première.
</Tip>

| Nom                   | Type     | Description                                                                                                                                                    |
| --------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| version (*optionnel*) | `string` | La version de l'application mobile. Ce champ doit suivre le versionnement sémantique. Les formats acceptés sont `major`, `major.minor` ou `major.minor.patch`. |

```csharp theme={null}
client.AddData(visitorCode, new ApplicationVersion("10")) // major

client.AddData(visitorCode, new ApplicationVersion("10.20")) // major.minor

client.AddData(visitorCode, new ApplicationVersion("10.20.30")) // major.minor.patch
```

### Types renvoyés

#### DataFile

Le `DataFile` contient les détails de configuration du SDK.

Il peut être étendu avec des informations supplémentaires si les clients en ont besoin. Si vous avez besoin de plus de détails, veuillez contacter votre Customer Success Manager.

| Nom          | Type                                       | Description                                                                                        |
| ------------ | ------------------------------------------ | -------------------------------------------------------------------------------------------------- |
| FeatureFlags | `IReadOnlyDictionary<string, FeatureFlag>` | Une map d'objets [`FeatureFlag`](#featureflag), indexée par les clés de feature flag.              |
| DateModified | `long`                                     | L'horodatage (en millisecondes) indiquant quand le `DataFile` a été modifié pour la dernière fois. |

```csharp theme={null}
// Retrieves the map of feature flags from the DataFile.
// The map is keyed by feature flag identifiers, with each value being a FeatureFlag object.
IReadOnlyDictionary<string, FeatureFlag> featureFlags = dataFile.FeatureFlags;

// Retrieves the last modification timestamp of the DataFile.
// The value is a long representing milliseconds since the Unix epoch.
long dateModified = dataFile.DateModified;
```

#### Variation

`Variation` contient des informations sur la variation attribuée au visiteur (ou la variation par défaut si aucune attribution spécifique n'existe).

| Nom          | Type                                    | Description                                                                                                                                                                  |
| ------------ | --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Key          | `string`                                | La clé unique identifiant la variation.                                                                                                                                      |
| Id           | `int`                                   | L'ID de la variation attribuée (ou `Variation.UndefinedId` s'il s'agit de la variation par défaut).                                                                          |
| ExperimentId | `int`                                   | L'ID de l'expérience associée à la variation (ou `Variation.UndefinedId` si par défaut).                                                                                     |
| Variables    | `IReadOnlyDictionary<string, Variable>` | Un dictionnaire contenant les variables de la variation attribuée, indexées par les noms de variables. Cela peut être une collection vide si aucune variable n'est associée. |

<Note>
  * L'objet `Variation` fournit des détails sur la variation attribuée et son expérience associée, tandis que l'objet [`Variable`](#variable) contient des détails spécifiques sur chaque variable d'une variation.
  * Assurez-vous que votre code gère le cas où `Id` ou `ExperimentId` peuvent être `Variation.UndefinedId`, indiquant une variation par défaut.
  * Le dictionnaire `Variables` peut être vide si aucune variable n'est associée à la variation.
</Note>

```csharp theme={null}
// Retrieving the variation key
string variationKey = variation.Key;

// Retrieving the variation id
int variationId = variation.Id;

// Retrieving the experiment id
int experimentId = variation.ExperimentId;

// Retrieving the variables map
var variables = variation.Variables;
```

#### Variable

`Variable` contient des informations sur une variable associée à la variation attribuée.

| Nom   | Type     | Description                                                                                                                              |
| ----- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| Key   | `string` | La clé unique identifiant la variable.                                                                                                   |
| Type  | `string` | Le type de la variable. Valeurs possibles : **BOOLEAN**, **NUMBER**, **STRING**, **JSON**, **JS**, **CSS**.                              |
| Value | `object` | La valeur de la variable, qui peut être des types suivants : **bool**, **int**, **double**, **string**, **Newtonsoft.Json.Linq.JToken**. |

```csharp theme={null}
// Retrieving the variables map
var variables = variation.Variables;

// Variable type can be retrieved for further processing
string type = variables["isDiscount"].Type;

// Retrieving the variable value by key
bool isDiscount = (bool)variables["isDiscount"].Value;

// Variable value can be of different types
string title = (string)variables["title"].Value;
```

### Méthodes obsolètes

<Warning>
  Ces méthodes sont obsolètes et seront supprimées dans la version `5.0.0` du SDK.
</Warning>

#### GetFeatureVariationKey()

* 📨 *Envoie des données de suivi à Kameleoon*

Pour obtenir la clé de variation d'un feature, appelez `GetFeatureVariationKey()`.

<Note>
  Utilisez [`GetVariation()`](#getvariation) à la place.
</Note>

Cette méthode nécessite un **visitorCode** et un **featureKey** (ou **featureID**) pour vérifier si un utilisateur peut accéder à une fonctionnalité spécifique.

Si l'utilisateur n'a jamais été lié à cette fonctionnalité, le SDK décidera aléatoirement de l'activer, renvoyant **true** (il peut accéder à la fonctionnalité) ou **false** (il ne le peut pas). Si l'utilisateur avec le **visitorCode** donné est déjà lié à cette fonctionnalité, le système renverra la valeur précédente du **featureFlag**.

Assurez-vous d'inclure une gestion appropriée des erreurs dans votre code, comme indiqué dans l'exemple, pour capturer toute erreur potentielle.

Si vous spécifiez un `visitorCode`, la méthode `GetFeatureVariationKey()` l'utilise comme identifiant unique du visiteur, ce qui est utile pour l'[expérimentation cross-device](/developer-docs/cross-device-experimentation). Lorsque vous spécifiez un `visitorCode` et définissez le paramètre `isUniqueIdentifier` sur `true`, le SDK lie les données vidées au visiteur associé à l'identifiant spécifié.

<Note>
  Le paramètre `isUniqueIdentifier` est obsolète. Veuillez utiliser [`UniqueIdentifier`](#uniqueidentifier) à la place.

  Le `isUniqueIdentifier` peut être utile dans des situations particulières ; par exemple, si vous ne pouvez pas accéder au `visitorCode` anonyme attribué à un visiteur, mais que vous pouvez utiliser un ID interne lié à ce visiteur via la fusion de sessions.
</Note>

```csharp theme={null}
string visitorCode = kameleoonClient.GetVisitorCode(Request, Response, "example.com");
string featureKey = "new_checkout";
string variationKey = "";

try {
  variationKey = kameleoonClient.GetFeatureVariationKey(visitorCode, featureKey);
} catch (KameleoonException.FeatureNotFound e) {
  // The feature is not yet activated on Kameleoon's side.
} catch (KameleoonException.FeatureEnvironmentDisabled e) {
  // The feature flag is disabled for the environment.
}

switch (variationKey) {
  case "on":
    // Main variation key is selected for visitorCode.
    break;
  case "alternative_variation":
    // Alternative variation key
    break;
  default:
    // Default variation key
    break;
}
```

##### Arguments

| Nom                           | Type   | Description                                                                                                                                                      |
| ----------------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitorCode                   | string | Identifiant unique de l'utilisateur. Ce champ est obligatoire.                                                                                                   |
| featureKey                    | string | Clé de la fonctionnalité que vous souhaitez exposer à un utilisateur. Ce champ est obligatoire.                                                                  |
| isUniqueIdentifier (Déprécié) | bool   | Paramètre optionnel pour spécifier si le visitorCode est un identifiant unique. S'il n'est pas fourni, la valeur par défaut est `false`. Le champ est optionnel. |

##### Valeur de retour

| Type   | Description                                                                 |
| ------ | --------------------------------------------------------------------------- |
| string | Clé de variation du feature flag enregistrée pour un **visitorCode** donné. |

##### Exceptions levées

| Type                                          | Description                                                                                                                                                                                                                                                                                             |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.FeatureNotFound            | Exception indiquant que la clé de feature demandée n'a pas été trouvée dans la configuration interne du SDK. Cela est généralement normal et signifie que le feature flag n'a pas encore été activé côté Kameleoon (mais le code implémentant la fonctionnalité est déjà déployé côté application web). |
| KameleoonException.FeatureEnvironmentDisabled | Exception indiquant que le feature flag est désactivé pour l'environnement actuel du visiteur (par exemple, production, staging ou development).                                                                                                                                                        |

#### GetActiveFeatureListForVisitor()

<Note>
  * Utilisez [`GetActiveFeatures`](#getactivefeatures) à la place.
  * Cette méthode était précédemment appelée `ObtainFeatureListForVisitorCode()`, qui a été supprimée dans la version `4.0.0` du SDK.
</Note>

Cette méthode prend un seul paramètre `visitorCode`. Renvoie uniquement les feature flags actifs pour le visiteur spécifié.

```csharp theme={null}
var featureListIds = kameleoonClient.GetActiveFeatureListForVisitor(visitorCode)
```

##### Arguments

| Nom         | Type   | Description                                                    |
| ----------- | ------ | -------------------------------------------------------------- |
| visitorCode | string | Identifiant unique de l'utilisateur. Ce champ est obligatoire. |

##### Valeur de retour

| Type           | Description                                                                        |
| -------------- | ---------------------------------------------------------------------------------- |
| `List<string>` | Liste des IDs de feature flag actifs disponibles pour un `visitorCode` spécifique. |

#### GetFeatureVariable()

* 📨 *Envoie des données de suivi à Kameleoon*

<Note>
  Utilisez [`GetVariation()`](#getvariation) à la place.
</Note>

Pour obtenir la variable d'une clé de variation associée à un utilisateur, appelez la méthode `GetFeatureVariable()` de notre SDK.

Cette méthode nécessite un **visitorCode** et un **featureKey** (ou **featureID**) pour vérifier si un utilisateur peut accéder à une fonctionnalité spécifique.

Si l'utilisateur n'a jamais été lié à cette fonctionnalité, le SDK décidera aléatoirement de l'activer, renvoyant **true** (il peut accéder à la fonctionnalité) ou **false** (il ne le peut pas). Si l'utilisateur avec le **visitorCode** donné est déjà lié à cette fonctionnalité, le système renverra la valeur précédente du **featureFlag**.

Assurez-vous d'inclure une gestion appropriée des erreurs dans votre code, comme indiqué dans l'exemple, pour capturer toute erreur potentielle.

Si vous spécifiez un `visitorCode`, la méthode `GetFeatureVariable()` l'utilise comme identifiant unique du visiteur, ce qui est utile pour l'[expérimentation cross-device](/developer-docs/cross-device-experimentation). Lorsque vous spécifiez un `visitorCode` et définissez le paramètre `isUniqueIdentifier` sur `true`, le SDK lie les données vidées au visiteur associé à l'identifiant spécifié.

<Note>
  Le paramètre `isUniqueIdentifier` est obsolète. Veuillez utiliser [`UniqueIdentifier`](#uniqueidentifier) à la place.

  Le `isUniqueIdentifier` peut être utile dans des situations particulières ; par exemple, si vous ne pouvez pas accéder au `visitorCode` anonyme attribué à un visiteur, mais que vous pouvez utiliser un ID interne lié à ce visiteur via la fusion de sessions.
</Note>

```csharp theme={null}
var visitorCode = kameleoonClient.GetVisitorCode(req, res, "example.com");
const string featureKey = "feature_key";
const string variableKey = "var"

try {
  var variableValue = kameleoonClient.GetFeatureVariable(visitorCode, featureKey, variableKey);
  // Your custom code, depending on variableValue
} catch (KameleoonException.FeatureNotFound e) {
  // The feature is not yet activated in the Kameleoon app
} catch (KameleoonException.FeatureEnvironmentDisabled e) {
  // The feature flag is disabled for the environment
} catch (KameleoonException.FeatureVariableNotFound e) {
  // Requested variable not defined in the Kameleoon app
}
```

##### Arguments

| Nom                           | Type   | Description                                                                                                                                                      |
| ----------------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitorCode                   | string | Identifiant unique de l'utilisateur. Ce champ est obligatoire.                                                                                                   |
| featureKey                    | string | Clé de la fonctionnalité que vous souhaitez exposer à un utilisateur. Ce champ est obligatoire.                                                                  |
| variableKey                   | string | Clé de la variable dont vous souhaitez obtenir une valeur. Ce champ est obligatoire.                                                                             |
| isUniqueIdentifier (Déprécié) | bool   | Paramètre optionnel pour spécifier si le visitorCode est un identifiant unique. S'il n'est pas fourni, la valeur par défaut est `false`. Le champ est optionnel. |

##### Valeur de retour

| Type   | Description                                                                                                                                                     |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| object | Valeur de la variable de variation enregistrée pour un **visitorCode** donné pour ce feature flag. Types possibles : bool, int, double, string, JObject, JArray |

##### Exceptions levées

| Type                                          | Description                                                                                                                                                                                                                                                                                             |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.FeatureNotFound            | Exception indiquant que la clé de feature demandée n'a pas été trouvée dans la configuration interne du SDK. Cela est généralement normal et signifie que le feature flag n'a pas encore été activé côté Kameleoon (mais le code implémentant la fonctionnalité est déjà déployé côté application web). |
| KameleoonException.FeatureEnvironmentDisabled | Exception indiquant que le feature flag est désactivé pour l'environnement actuel du visiteur (par exemple, production, staging ou development).                                                                                                                                                        |
| KameleoonException.FeatureVariableNotFound    | Exception indiquant que la variable demandée n'a pas été trouvée. Vérifiez que la clé de la variable dans l'application Kameleoon correspond à celle de votre code.                                                                                                                                     |
| KameleoonException.VisitorCodeInvalid         | Exception indiquant que le visitor code spécifié n'est pas valide. (Il est soit vide, soit plus long que 255 caractères).                                                                                                                                                                               |

#### GetActiveFeatures()

<Note>
  Utilisez [`GetVariations()`](#getvariations) à la place.
</Note>

La méthode `GetActiveFeatures` récupère des informations sur les feature flags actifs disponibles pour le visitor code spécifié.

<Note>
  Les propriétés `Kameleoon.Types.Variation.Id` et `Kameleoon.Types.Variation.ExperimentId` des variations renvoyées sont optionnelles. Si elles ne sont pas spécifiées, la valeur par défaut est `Kameleoon.Types.Variation.UndefinedId`.
</Note>

```csharp theme={null}
IReadOnlyDictionary<string, Kameleoon.Types.Variation> activeFeatures = GetActiveFeatures(visitorCode);
```

##### Arguments

| Nom         | Type   | Description                                                                                                             |
| ----------- | ------ | ----------------------------------------------------------------------------------------------------------------------- |
| visitorCode | string | Identifiant unique du visiteur pour lequel vous souhaitez récupérer les feature flags actifs. Ce champ est obligatoire. |

##### Valeur de retour

| Type                                                     | Description                                                                                                                                     |
| -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `IReadOnlyDictionary<string, Kameleoon.Types.Variation>` | Un dictionnaire qui contient les variations attribuées des fonctionnalités actives en utilisant les IDs des fonctionnalités actives comme clés. |

##### Exceptions levées

| Type                                  | Description                                                                                                           |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.VisitorCodeInvalid | Exception indiquant que le visitor code fourni n'est pas valide. Il est soit vide, soit plus long que 255 caractères. |

#### GetFeatureVariationVariables()

<Note>
  * Utilisez [`GetVariation()`](#getvariation) à la place.
  * Cette méthode était précédemment appelée `GetFeatureAllVariables()`, qui a été supprimée dans la version `4.0.0` du SDK.
</Note>

Appelez cette méthode pour récupérer toutes les variables de feature d'une fonctionnalité. Vous pouvez modifier les variables de feature dans l'application Kameleoon.

Cette méthode prend deux paramètres d'entrée : `featureKey` et `variationKey`. Elle renvoie les données du type `Dictionary<string, object>`, comme défini dans l'interface web. Elle lèvera une exception (`KameleoonException.FeatureNotFound`) si la fonctionnalité demandée n'a pas été trouvée dans la configuration interne du SDK.

```csharp theme={null}
string featureKey = "myFeature";

try {
  var allVariables = kameleoonClient.GetFeatureVariationVariables(featureKey, variationKey);
} catch (KameleoonException.FeatureNotFound e) {
  // The feature is not yet activated in the Kameleoon app.
} catch (KameleoonException.FeatureEnvironmentDisabled e) {
  // The feature flag is disabled for the environment.
} catch (KameleoonException.FeatureVariationNotFound e) {
  // The variation is not activated in the Kameleoon app (the associated experiment is not online).
} catch (Exception e) {
  // This is a generic Exception handler which will handle all exceptions.
  Console.WriteLine("Exception occurred");
}
```

##### Arguments

| Nom          | Type     | Description                                                                         |
| ------------ | -------- | ----------------------------------------------------------------------------------- |
| featureKey   | `string` | Clé identifiant la fonctionnalité que vous devez obtenir. Ce champ est obligatoire. |
| variationKey | `string` | Clé de la variation que vous souhaitez obtenir. Ce champ est obligatoire.           |

##### Valeur de retour

| Type                         | Description                                                                                                                                              |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Dictionary<string, object>` | Données associées à ce feature flag. Les valeurs peuvent être un nombre, une chaîne, un booléen ou un objet (selon le type défini dans l'interface web). |

##### Exceptions levées

| Type                                          | Description                                                                                                                                                                                                                          |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| KameleoonException.FeatureNotFound            | Exception indiquant que la fonctionnalité demandée n'a pas été trouvée dans la configuration interne du SDK. Cela est généralement normal et signifie que le feature flag n'a pas encore été activé côté Kameleoon.                  |
| KameleoonException.FeatureEnvironmentDisabled | Exception indiquant que le feature flag est désactivé pour l'environnement actuel du visiteur (par exemple, production, staging ou development).                                                                                     |
| KameleoonException.FeatureVariationNotFound   | Exception indiquant que l'ID de variation demandé n'a pas été trouvé dans la configuration interne du SDK. Cela signifie généralement que l'expérience correspondante à la variation n'est pas activée dans l'application Kameleoon. |