C# SDK

The Connix C# SDK provides a modern, async-first interface for integrating Connix services into your .NET applications.

Requirements

• .NET 6.0 or later (also supports .NET Framework 4.7.2+)
• Visual Studio 2022 or later (recommended)

Installation

Package Manager Console

Install-Package Connix.Sdk

.NET CLI

dotnet add package Connix.Sdk

PackageReference

Add to your .csproj file:

<PackageReference Include="Connix.Sdk" Version="1.0.0" />

Quick Start

using Connix.Sdk;

// Initialize the client
var client = new ConnixClient("your-api-key");

try
{
    // Make a request
    var result = await client.SomeMethodAsync("parameter");
    Console.WriteLine($"Result: {result.Data}");
}
catch (ConnixException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
finally
{
    client.Dispose();
}

Configuration

Configure the SDK with various options:

using Connix.Sdk;

var config = new ConnixClientConfig
{
    Timeout = TimeSpan.FromSeconds(30),
    MaxRetries = 3,
    BaseUrl = "https://api.connix.io"
};

config.DefaultHeaders.Add("Custom-Header", "value");

var client = new ConnixClient("your-api-key", config);

Dependency Injection

The SDK supports .NET’s dependency injection container:

Program.cs (Minimal APIs / .NET 6+)

using Connix.Sdk.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Add Connix services
builder.Services.AddConnix(options =>
{
    options.ApiKey = builder.Configuration["Connix:ApiKey"];
    options.Timeout = TimeSpan.FromSeconds(30);
    options.MaxRetries = 3;
});

var app = builder.Build();

app.MapGet("/data", async (IConnixClient client) =>
{
    var result = await client.GetDataAsync();
    return Results.Ok(result);
});

app.Run();

Startup.cs (.NET 5 and earlier)

using Connix.Sdk.Extensions;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddConnix(Configuration.GetSection("Connix"));
    }
}

appsettings.json

{
  "Connix": {
    "ApiKey": "your-api-key",
    "Timeout": "00:00:30",
    "MaxRetries": 3,
    "BaseUrl": "https://api.connix.io"
  }
}

Error Handling

The SDK provides structured exception handling:

using Connix.Sdk.Exceptions;

try
{
    var result = await client.SomeMethodAsync("parameter");
}
catch (ValidationException ex)
{
    Console.WriteLine($"Validation error: {ex.Message}");
    foreach (var error in ex.ValidationErrors)
    {
        Console.WriteLine($"  - {error.Field}: {error.Message}");
    }
}
catch (NetworkException ex)
{
    Console.WriteLine($"Network error: {ex.Message}");
}
catch (ConnixException ex)
{
    Console.WriteLine($"Connix error: {ex.Message} (Code: {ex.ErrorCode})");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
}

Async/Await Support

All SDK methods are async by default:

// Async methods
var result = await client.SomeMethodAsync("parameter");
var data = await client.GetDataAsync();

// Synchronous overloads (blocking)
var result = client.SomeMethod("parameter");
var data = client.GetData();

// With cancellation token
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
var result = await client.SomeMethodAsync("parameter", cts.Token);

API Reference

ConnixClient

Constructor

public ConnixClient(string apiKey)
public ConnixClient(string apiKey, ConnixClientConfig config)

Methods

public Task<Result> SomeMethodAsync(string param, CancellationToken cancellationToken = default)
public Task<DataResponse> GetDataAsync(CancellationToken cancellationToken = default)
public Result SomeMethod(string param)
public DataResponse GetData()
public void Dispose()

Configuration

ConnixClientConfig

public class ConnixClientConfig
{
    public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(30);
    public int MaxRetries { get; set; } = 3;
    public string BaseUrl { get; set; } = "https://api.connix.io";
    public Dictionary<string, string> DefaultHeaders { get; set; } = new();
}

Result

public class Result
{
    public string Id { get; set; }
    public string Data { get; set; }
    public DateTimeOffset Timestamp { get; set; }
}

ASP.NET Core Integration

Controller Example

using Microsoft.AspNetCore.Mvc;
using Connix.Sdk;

[ApiController]
[Route("api/[controller]")]
public class DataController : ControllerBase
{
    private readonly IConnixClient _connixClient;

    public DataController(IConnixClient connixClient)
    {
        _connixClient = connixClient;
    }

    [HttpGet]
    public async Task<ActionResult<DataResponse>> GetData()
    {
        try
        {
            var result = await _connixClient.GetDataAsync();
            return Ok(result);
        }
        catch (ConnixException ex)
        {
            return StatusCode(500, new { error = ex.Message });
        }
    }

    [HttpPost("{id}/process")]
    public async Task<ActionResult> ProcessData(string id, [FromBody] ProcessRequest request)
    {
        try
        {
            await _connixClient.ProcessDataAsync(id, request);
            return Ok();
        }
        catch (ValidationException ex)
        {
            return BadRequest(new { errors = ex.ValidationErrors });
        }
        catch (ConnixException ex)
        {
            return StatusCode(500, new { error = ex.Message });
        }
    }
}

Middleware Example

public class ConnixMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IConnixClient _connixClient;

    public ConnixMiddleware(RequestDelegate next, IConnixClient connixClient)
    {
        _next = next;
        _connixClient = connixClient;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Pre-process with Connix
        var result = await _connixClient.ValidateRequestAsync(context.Request.Path);
        if (!result.IsValid)
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Access denied");
            return;
        }

        await _next(context);
    }
}

// Register in Program.cs
app.UseMiddleware<ConnixMiddleware>();

Examples

Console Application

using Connix.Sdk;

class Program
{
    static async Task Main(string[] args)
    {
        using var client = new ConnixClient("your-api-key");

        try
        {
            var response = await client.GetDataAsync();
            foreach (var item in response.Items)
            {
                Console.WriteLine($"Item: {item.Name}");
            }
        }
        catch (ConnixException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

WPF Application

using System.Windows;
using Connix.Sdk;

public partial class MainWindow : Window
{
    private readonly ConnixClient _connixClient;

    public MainWindow()
    {
        InitializeComponent();
        _connixClient = new ConnixClient("your-api-key");
    }

    private async void LoadData_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            LoadingIndicator.Visibility = Visibility.Visible;

            var result = await _connixClient.GetDataAsync();
            DataGrid.ItemsSource = result.Items;
        }
        catch (ConnixException ex)
        {
            MessageBox.Show($"Error loading data: {ex.Message}", "Error",
                           MessageBoxButton.OK, MessageBoxImage.Error);
        }
        finally
        {
            LoadingIndicator.Visibility = Visibility.Collapsed;
        }
    }

    protected override void OnClosed(EventArgs e)
    {
        _connixClient?.Dispose();
        base.OnClosed(e);
    }
}

Background Service

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Connix.Sdk;

public class ConnixBackgroundService : BackgroundService
{
    private readonly IConnixClient _connixClient;
    private readonly ILogger<ConnixBackgroundService> _logger;

    public ConnixBackgroundService(IConnixClient connixClient,
                                  ILogger<ConnixBackgroundService> logger)
    {
        _connixClient = connixClient;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                var result = await _connixClient.ProcessBatchAsync(stoppingToken);
                _logger.LogInformation($"Processed {result.ProcessedCount} items");
            }
            catch (ConnixException ex)
            {
                _logger.LogError(ex, "Error processing batch");
            }

            await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
        }
    }
}

Blazor Component

@page "/data"
@using Connix.Sdk
@inject IConnixClient ConnixClient

<h3>Data Dashboard</h3>

@if (loading)
{
    <p>Loading...</p>
}
else if (error != null)
{
    <div class="alert alert-danger">@error</div>
}
else if (data != null)
{
    <table class="table">
        <thead>
            <tr>
                <th>ID</th>
                <th>Name</th>
                <th>Status</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var item in data.Items)
            {
                <tr>
                    <td>@item.Id</td>
                    <td>@item.Name</td>
                    <td>@item.Status</td>
                </tr>
            }
        </tbody>
    </table>
}

<button class="btn btn-primary" @onclick="LoadData">Refresh</button>

@code {
    private DataResponse? data;
    private string? error;
    private bool loading;

    protected override async Task OnInitializedAsync()
    {
        await LoadData();
    }

    private async Task LoadData()
    {
        loading = true;
        error = null;

        try
        {
            data = await ConnixClient.GetDataAsync();
        }
        catch (ConnixException ex)
        {
            error = ex.Message;
        }
        finally
        {
            loading = false;
        }
    }
}

Support

For support and questions, visit our GitHub repository or contact support.