编写客户端包装器类以隔离其类实现IDisposable但接口不实现的客户端的内部细节

Question

我正在编写一个在NuGet包中定义的外部客户端的客户端包装器。 NuGet包中包含以下接口和类。

public interface IServiceClient
{
    Task<Job> CreateJobAsync(JobDetails jobdetails);
}

public class ServiceClient : IServiceClient, IDisposable
{
    public async Task<Job> CreateJobAsync(JobDetails jobDetails)
    {   
        // Some processing and returns a job that contains required response and status

        return job;
    }
}

在我的应用程序中，我在服务客户端周围写了一个客户端包装器，如下所示：

public interface IServiceClientWrapper
{
    Task<ResponseDto> PostAsync(RequestDto request);
}

public class ServiceClientWrapper : IServiceClientWrapper
{
    private static IServiceClient serviceClient;

    public static void Init()
    {
        // See below for defintion
        serviceClient = ClientFactory.Create();
    }   

    public async Task<ResponseDto> PostAsync(RequestDto request)
    {
        // Convert request to JobDetails as required

        var job = await serviceClient.CreateJobAsync(jobDetails);

        // Convert job to ResponseDto and return
        return response;
    }

    // Since ServiceClient implements IDisposable
    public static void Close()
    {
        if (serviceClient != null)
        {
            ((ServiceClient)serviceClient).Dispose();
        }
    }
}

internal static class ClientFactory
{   
    public static IServiceClient ServiceClient { get; set; }

    public static IServiceClient Create()
    {
        if (ServiceClient != null)
        {
            // Used during unit testing
            return ServiceClient;
        }

        return new ServiceClient(APIBaseAddress, AccessKey);
    }
}

问题：

由于接口未标记为IDisposable，因此我引入了Init和Close方法来执行此操作。有没有更好的方法来处理这个？
将serviceClient作为静态，是否是线程安全的，因为我总是使用每个请求的新参数调用非静态CreateJobAsync方法？