# Add FeatBit service in Program.cs file in ASP.NET Core

using FeatBit.Sdk.Server.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();

// add FeatBit service
builder.Services.AddFeatBit(options =>
{
    options.EnvSecret = "<replace-with-your-env-secret>";
    options.StreamingUri = new Uri("ws://localhost:5100");
    options.EventUri = new Uri("http://localhost:5100");
    options.StartWaitTime = TimeSpan.FromSeconds(3);
});

var app = builder.Build();
app.Run();

# Inject FeatBit service in Controller

public class HomeController : ControllerBase
{
    private readonly IFbClient _fbClient;

    public HomeController(IFbClient fbClient)
    {
        _fbClient = fbClient;
    }

    [HttpGet]
    public IActionResult Index()
    {
        # Use FeatBit service to evaluate feature flag
        HttpContext.Request.Headers.TryGetValue("X-FeatBit-User-Key", out var userKey);
        HttpContext.Request.Headers.TryGetValue("X-FeatBit-User-Name", out var userName);
        var user = FbUser.Builder(userKey)
                        .Name(userName)
                        .Build();
        if (_fbClient.BoolVariation("welcome-sentence", user, defaultValue: false))
        {
            return Ok("Welcome to our website!");
        }
        return NotFound();
    }
}

### Server Side Rendering ###
# Initialize server-side SDK in Program.cs file in Blazor Server 

builder.Services.AddFeatBit(options =>
{
    options.EnvSecret = "{Environment_Server_Key}";
    options.StreamingUri = new Uri("wss://{EVALUATION_SERVER_URL}");
    options.EventUri = new Uri("https://{EVALUATION_SERVER_URL}");
    options.StartWaitTime = TimeSpan.FromSeconds(3);
});

# Create a FeatureFlag component in Blazor Server

@using FeatBit.Sdk.Server
@using FeatBit.Sdk.Server.Model
@inject IFbClient FeatureFlags

@if (FeatureFlags.FeatureReleased(FlagKey) == true)
{
    @ChildContent
}

@code {
    [Parameter]
    public RenderFragment? ChildContent { get; set; }
    [Parameter]
    public string FlagKey { get; set; }

    protected override async Task OnInitializedAsync()
    {
        await base.OnInitializedAsync();
    }
}

# Use component below to wrap the feature code

@inject IFbClient FeatureFlags

<FeatureFlag FlagKey="welcom-sentence">
    <h5>
    Welcome to our website! 
    We're thrilled to have you here and can't
    wait to share our journey with you.
    </h5>
</FeatureFlag>

### Client Side Rendering ###
# Initialize client-side SDK in MainLayout.razor 
# file in Blazor WebAssembly

protected override async Task OnInitializedAsync()
{
    var options = new FbOptionsBuilder("{Environment_Client_Key}")
                        .Eval(new Uri("https://{EVALUATION_SERVER_URL}"))
                        .PollingInterval(5000)
                        .LoggerFactory(LoggerFactory)
                        .Build();
    FeatureFlagStore = new FbClient(options);
    FeatureFlagStore.FeatureFlagsUpdated += (sender, e) =>
        {
            InvokeAsync(() =>
            {
                RenderMessage = FeatureFlagStore.StringVariation(
                                    "testing-visibility", "Collapsed");
                StateHasChanged(); // Rerender the component
            }).Wait();
        };
}

# Use CascadingParameter to pass the Feature Flag 
# to the child component

[CascadingParameter]
public FbClient FeatureFlagStore { get; set; }

protected override async Task OnInitializedAsync()
{
    FeatureFlagStore.FeatureFlagsUpdated += (sender, e) =>
     {
         InvokeAsync(() =>
         {
             renderMessage = FeatureFlagStore.StringVariation(
                "testing-visibility", "Collapsed");
             StateHasChanged(); // Rerender the component
         }).Wait();
     };
    renderMessage = FeatureFlagStore.StringVariation(
        "testing-visibility", "Collapsed");
    StateHasChanged();
}

# Initialize client-side SDK in App.xaml.cs file in WPF

var options = new FbOptionsBuilder("{Environment_Client_Key}")
                    .Eval(new Uri("{EVALUATION_SERVER_URL}"))
                    .LoggerFactory(consoleLoggerFactory)
                    .PollingInterval(10000)
                    .Build();
services.AddSingleton<IFbClient>(provider => new FbClient(options));

# Login user and identify user in WPF
var user = FbUser.Builder("{user_id}")
                     .Name("{user_name}")
                     .Custom("{user_custom_property_1", "{value_1}")
                     .Custom("{user_custom_property_2", "{value_2}")
                     .Build();
await _fbClient.IdentifyAsync(user);

# Inject FeatBit service in View

private readonly IFbClient _fbClient;
public MainWindow(
    IFbClient fbClient, 
    MainViewModel viewModel)
{
    InitializeComponent();
    _fbClient = fbClient;
    Loaded += MainWindow_Loaded;
    Unloaded += (s, e) =>
    {
        _fbClient.FeatureFlagsUpdated -= FeatureFlagsUpdated;
    };
}

# Monitor feature flag changes
private void FeatureFlagsUpdated(object? sender, FeatureFlagsUpdatedEventArgs e)
{
    Dispatcher.BeginInvoke(new System.Action(() =>
    {
        SetVisibility();
    }));
}

# Use fbClient to evaluate feature flag
private void SetVisibility()
{
    var visibleStatus = _fbClient.StringVariation("testing-visibility", "Collapsed");
    switch (visibleStatus)
    {
        case "Visible":
            TextBox_Thanks.Visibility = Visibility.Visible;
            break;
        case "Collapsed":
            TextBox_Thanks.Visibility = Visibility.Collapsed;
            break;
        default:
            TextBox_Thanks.Visibility = Visibility.Hidden;
            break;
    }

    double numb = _fbClient.DoubleVariation("float-func", 0);
}

# Initialize client-side SDK in .NET MAUI

var consoleLoggerFactory = LoggerFactory.Create(builder =>
    {
        builder.AddConsole();
    });
var options = new FbOptionsBuilder("{Environment_Client_Key}")
                    .Eval(new Uri("{EVALUATION_SERVER_URL}"))
                    .LoggerFactory(consoleLoggerFactory)
                    .PollingInterval(5000)
                    .Build();
builder.Services.AddSingleton<IFbClient>(provider => 
    new FbClient(options, autoSync: true));


# Inject FeatBit service in ViewModel
private readonly IFbClient _fbClient;

public MyFavoritesViewModel(
    ISportsService sportsService,
    IFbClient fbClient)
{
    _sportsService = sportsService;
    _fbClient = fbClient;
}

# Use SDK to evaluate feature flag
MyFavoriteGynasmesVisibility = (_fbClient.StringVariation("testing-visibility", "Collapsed") == "Visible");

# For other usage, it's as same as WPF, WinForm, Blazor, etc.