When to Use

You know the exact process ID to connect to
You need fine-grained control over the connection
You’re building higher-level connection abstractions
You need health monitoring capabilities

Basic Usage

var args = new ErikssonBeamConnectionAttemptArgs
{
    LicenseKey = Environment.GetEnvironmentVariable("ERIKSSON_LICENSE_KEY"),
    ProcessID = 12345,  // Known process ID
    IdleTimeoutMs = 30000,
    MaxAttempts = 10,
    WaitTimeBetweenAttemptsMs = 1000
};

var client = await ErikssonBeamClient.AttemptConnection(args);

try
{
    var design = await client.PullBeamDesignerAsync();
    // Work with design...
}
finally
{
    client.Dispose();
}

Configuration Options

ErikssonBeamConnectionAttemptArgs

Property	Type	Default	Description
`LicenseKey`	string	`""`	Required. API authorization key
`ProcessID`	int	`-1`	Required. Target process ID
`IdleTimeoutMs`	int	`30000`	Connection timeout (ms)
`MaxAttempts`	int	`10`	Connection retry attempts
`WaitTimeBetweenAttemptsMs`	int	`1000`	Delay between retries (ms)

ErikssonBeamClientArgs (Advanced)

For advanced scenarios with health monitoring:

Property	Type	Default	Description
`LicenseKey`	string	`""`	API authorization key
`ProcessID`	int	`-1`	Target process ID
`IdleTimeoutMs`	int	`30000`	Connection timeout (ms)
`EnableHealthMonitoring`	bool	`true`	Enable process health checks
`HealthCheckIntervalMs`	int	`5000`	Interval between health checks
`ChannelConfig`	ChannelConfig	Default	Message queue configuration
`ProcessReference`	Process	null	Process object for health monitoring
`RecoveryConfig`	ProcessRecoveryConfig	null	Auto-recovery configuration

Connection Properties

var client = await ErikssonBeamClient.AttemptConnection(args);

// Check connection status
bool connected = client.IsConnected;
bool waiting = client.IsWaitingForConnection;

// Get target process ID
int processId = client.TargetProcess;

// Check unread message count
long pending = client.UnreadMessages;

Health Monitoring

When enabled, the client monitors the Eriksson Beam process health:

var args = new ErikssonBeamClientArgs
{
    LicenseKey = licenseKey,
    ProcessID = processId,
    EnableHealthMonitoring = true,
    HealthCheckIntervalMs = 5000
};

var client = new ErikssonBeamClient(args);

// Check current health
ProcessHealth health = client.CurrentHealth;
Console.WriteLine($"Status: {health.Status}");
Console.WriteLine($"Details: {health.Details}");

// Subscribe to health changes
client.HealthChanged += (sender, e) =>
{
    Console.WriteLine($"Health changed: {e.OldHealth.Status} -> {e.NewHealth.Status}");

    if (e.NewHealth.Status == ProcessHealthStatus.Crashed)
    {
        Console.WriteLine("Eriksson Beam has crashed!");
    }
};

ProcessHealthStatus Values

Status	Description
`Healthy`	Process running, connection active
`Degraded`	Minor issues detected
`Unhealthy`	Connection lost or unresponsive
`Crashed`	Process has exited
`Unknown`	Cannot determine status

Graceful Shutdown

For long-running applications, use graceful shutdown:

// Graceful shutdown with 10 second timeout
bool wasGraceful = await client.ShutdownAsync(timeoutMs: 10000);

if (wasGraceful)
{
    Console.WriteLine("Eriksson Beam closed cleanly");
}
else
{
    Console.WriteLine("Eriksson Beam was force-killed");
}

Error Handling

try
{
    var client = await ErikssonBeamClient.AttemptConnection(args);
}
catch (ArgumentException ex)
{
    // Invalid ProcessID (must be positive)
    Console.WriteLine($"Invalid configuration: {ex.Message}");
}
catch (ErikssonBeamNotRunningException ex)
{
    // Process not found or connection failed
    Console.WriteLine($"Connection failed: {ex.Message}");
}
catch (TimeoutException ex)
{
    // Connection attempts exhausted
    Console.WriteLine($"Timed out: {ex.Message}");
}

Disposal

The client implements IDisposable. Always dispose properly:

// Option 1: using statement (recommended)
using var client = await ErikssonBeamClient.AttemptConnection(args);

// Option 2: try-finally
var client = await ErikssonBeamClient.AttemptConnection(args);
try
{
    // Work with client...
}
finally
{
    client.Dispose();
}

Important: Disposing the client:

Closes the connection
Does not close Eriksson Beam
Stops health monitoring

Logging

Enable diagnostic logging with an ILogger:

using Microsoft.Extensions.Logging;

var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddConsole().SetMinimumLevel(LogLevel.Debug);
});
var logger = loggerFactory.CreateLogger<ErikssonBeamClient>();

var client = await ErikssonBeamClient.AttemptConnection(args, logger);

Complete Example

using System;
using System.Threading.Tasks;
using ErikssonBeam.API.BeamClient;

class DirectConnection
{
    static async Task ConnectToProcess(int processId)
    {
        var args = new ErikssonBeamConnectionAttemptArgs
        {
            LicenseKey = Environment.GetEnvironmentVariable("ERIKSSON_LICENSE_KEY"),
            ProcessID = processId,
            IdleTimeoutMs = 30000,
            MaxAttempts = 5,
            WaitTimeBetweenAttemptsMs = 1000
        };

        Console.WriteLine($"Connecting to process {processId}...");

        try
        {
            using var client = await ErikssonBeamClient.AttemptConnection(args);

            Console.WriteLine($"Connected: {client.IsConnected}");
            Console.WriteLine($"Target Process: {client.TargetProcess}");

            // Get open files
            var files = await client.GetOpenBeamProjects();
            Console.WriteLine($"Open files: {string.Join(", ", files)}");

            // Pull and display info for each file
            foreach (var file in files)
            {
                var design = await client.PullBeamDesignerAsync(file);
                Console.WriteLine($"  {file}: {design.DesignCriteria.ProjectInformation.ProjectName}");
            }
        }
        catch (ErikssonBeamNotRunningException ex)
        {
            Console.WriteLine($"Process {processId} not available: {ex.Message}");
        }
    }

    static async Task Main()
    {
        // First, find available instances
        var instances = await ErikssonBeamFinder.GetSupportedErikssonBeamInstances();

        if (instances.Length > 0)
        {
            await ConnectToProcess(instances[0]);
        }
        else
        {
            Console.WriteLine("No Eriksson Beam instances found");
        }
    }
}

ErikssonBeamClient