this.driverServiceProcess.Start();
    }
    catch
    {
        this.driverServiceProcess.Dispose();
        throw;
    }
}

bool serviceAvailable = await this.WaitForServiceInitializationAsync().ConfigureAwait(false);
DriverProcessStartedEventArgs processStartedEventArgs = new DriverProcessStartedEventArgs(this.driverServiceProcess);

using (var httpClient = new HttpClient())
{
    httpClient.DefaultRequestHeaders.ConnectionClose = true;
    httpClient.Timeout = TimeSpan.FromSeconds(5);

    Uri serviceHealthUri = new Uri(this.ServiceUrl, new Uri(DriverCommand.Status, UriKind.Relative));
    using (var response = await httpClient.GetAsync(serviceHealthUri))
    {
        // Checking the response from the 'status' end point. Note that we are simply checking
        // that the HTTP status returned is a 200 status, and that the response has the correct
        // Content-Type header. A more sophisticated check would parse the JSON response and
        // validate its values. At the moment we do not do this more sophisticated check.
        isInitialized = response.StatusCode == HttpStatusCode.OK && response.Content.Headers.ContentType is { MediaType: string mediaType } && mediaType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase);
    }
}

public async ValueTask DisposeAsync()
{
    await DisposeAsyncCore();
    Dispose(false);
    GC.SuppressFinalize(this);
}

        return Task.Run(this.IsInitializedAsync).GetAwaiter().GetResult();
    }
}

/// <summary>
/// Gets a value indicating whether the service is responding to HTTP requests.
/// </summary>
/// <returns>A task that represents the asynchronous initialization check operation.</returns>
protected async virtual Task<bool> IsInitializedAsync()
{
    bool isInitialized = false;
    try
    {
        using (var httpClient = new HttpClient())
        {
            httpClient.DefaultRequestHeaders.ConnectionClose = true;
            httpClient.Timeout = TimeSpan.FromSeconds(5);

            Uri serviceHealthUri = new Uri(this.ServiceUrl, new Uri(DriverCommand.Status, UriKind.Relative));
            using (var response = await httpClient.GetAsync(serviceHealthUri))
            {
                // Checking the response from the 'status' end point. Note that we are simply checking
                // that the HTTP status returned is a 200 status, and that the response has the correct
                // Content-Type header. A more sophisticated check would parse the JSON response and
                // validate its values. At the moment we do not do this more sophisticated check.
                isInitialized = response.StatusCode == HttpStatusCode.OK && response.Content.Headers.ContentType is { MediaType: string mediaType } && mediaType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase);
            }
        }
    }
    catch (Exception ex) when (ex is HttpRequestException || ex is TaskCanceledException)
    {
        // Do nothing. The exception is expected, meaning driver service is not initialized.
    }

    return isInitialized;
}

/// <summary>
/// Releases all resources associated with this <see cref="DriverService"/>.
/// </summary>
public void Dispose()
{
    this.Dispose(true);
    GC.SuppressFinalize(this);
}

/// <summary>
/// Starts the DriverService if it is not already running.
/// </summary>
public void Start()
{
    Task.Run(this.StartAsync).GetAwaiter().GetResult();
}

bool serviceAvailable = await this.WaitForServiceInitializationAsync().ConfigureAwait(false);
DriverProcessStartedEventArgs processStartedEventArgs = new DriverProcessStartedEventArgs(this.driverServiceProcess);
this.OnDriverProcessStarted(processStartedEventArgs);

if (!serviceAvailable)
{

protected virtual void Dispose(bool disposing)
{
    if (!this.isDisposed)
    {
        if (disposing)
        {
            Task.Run(this.StopAsync).GetAwaiter().GetResult();
        }

        this.isDisposed = true;
    }
}

/// <summary>
/// Releases all resources associated with this <see cref="DriverService"/>.
/// </summary>
/// <returns>A task that represents the asynchronous dispose operation.</returns>
public async ValueTask DisposeAsync()
{
    await DisposeAsyncCore();
    Dispose(false);
    GC.SuppressFinalize(this);
}

/// <summary>
/// Releases all resources associated with this type in the instance's type chain. Override to dispose more resources.
/// </summary>
/// <returns>A task that represents the asynchronous dispose operation.</returns>
protected virtual async ValueTask DisposeAsyncCore()
{
    await this.StopAsync().ConfigureAwait(false);
}

/// <summary>
/// Raises the <see cref="DriverProcessStarting"/> event.
/// </summary>
/// <param name="eventArgs">A <see cref="DriverProcessStartingEventArgs"/> that contains the event data.</param>
protected void OnDriverProcessStarting(DriverProcessStartingEventArgs eventArgs)
{
    if (eventArgs == null)
    {
        throw new ArgumentNullException(nameof(eventArgs), "eventArgs must not be null");
    }

    this.DriverProcessStarting?.Invoke(this, eventArgs);
}

/// <summary>
/// Raises the <see cref="DriverProcessStarted"/> event.
/// </summary>
/// <param name="eventArgs">A <see cref="DriverProcessStartedEventArgs"/> that contains the event data.</param>
protected void OnDriverProcessStarted(DriverProcessStartedEventArgs eventArgs)
{
    if (eventArgs == null)
    {
        throw new ArgumentNullException(nameof(eventArgs), "eventArgs must not be null");
    }

    this.DriverProcessStarted?.Invoke(this, eventArgs);
}

/// <summary>
/// Stops the DriverService.
/// </summary>
private async Task StopAsync()
{