C# SDK

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
}

using Kameleoon;
using Kameleoon.Types;

try
{
    Variation variation = kameleoonClient.GetVariation(visitorCode, "new_checkout");
}
catch (KameleoonException.FeatureNotFound e)
{
    // The feature flag isn't in the SDK configuration: fall back to your default behavior.
}
catch (KameleoonException.FeatureEnvironmentDisabled e)
{
    // The feature flag is disabled for the current environment.
}
catch (KameleoonException e)
{
    // Any other SDK error.
    logger.LogWarning("Kameleoon error: {Message}", e.Message);
}

// Asynchronous methods report errors through the returned Task.
try
{
    await kameleoonClient.WaitInit();
}
catch (KameleoonException.Initialization e)
{
    // The SDK couldn't initialize; `e.InnerException` holds the cause.
}

// 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);

kameleoonClient.AddData(visitorCode, new CustomData(index, "newVisitorCode"));

// 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;

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();

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
}

try {
    // Waits up to the default timeout of the client configuration
    await kameleoonClient.WaitInit();

    // Waits no longer than the specified timeout
    await kameleoonClient.WaitInit(1000);
} catch (KameleoonException.Initialization exception) {
    // Indicates that the client could not be initialized due to the thrown exception.
}

bool ready = kameleoonClient.IsReady;

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 occurred");
}
if (hasNewCheckout)
{
  // Implement new checkout code here.
}

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;
}

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
}

const featureFlagIds = kameleoonClient.GetFeatureList()

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
}

try
{
    kameleoonClient.EvaluateAudiences(visitorCode);
}
catch (KameleoonException ex)
{
    // Handling the exception
}

DataFile dataFile = kameleoonClient.GetDataFile();

try
{
    string visitorCode = kameleoonClient.GetVisitorCode(Request, Response);

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

// 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")
);

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);

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
}

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
}

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
}

string visitorCode = kameleoonClient.GetVisitorCode(httpRequest, httpResponse);
kameleoonClient.SetLegalConsent(visitorCode, true, httpResponse);

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)

string engineTrackingCode = kameleoonClient.GetEngineTrackingCode(visitorCode);

kameleoonClient.AddData(visitorCode, new Browser(Browser.Browsers.CHROME));

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

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

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"))
);

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"));

kameleoonClient.AddData(visitorCode, new Device(Device.Type.DESKTOP));

kameleoonClient.AddData(visitorCode, new UserAgent("Your User Agent"));

kameleoonClient.AddData(visitorCode, new UniqueIdentifier(true));

kameleoonClient.addData(visitorCode, new OperatingSystem(OperatingSystem.Type.WINDOWS));

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

kameleoonClient.addData(visitorCode, new Geolocation("France", "Île-de-France", "Paris"));

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

// 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;

// 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;

// 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;

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;
}

var featureListIds = kameleoonClient.GetActiveFeatureListForVisitor(visitorCode)

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
}

IReadOnlyDictionary<string, Kameleoon.Types.Variation> activeFeatures = GetActiveFeatures(visitorCode);

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");
}