var cert = LoadCertificate(settings);

using (NoSynchronizationContextScope.Enter())
{
	var container = SolrNet.Cloud.Startup.Container;

	container.RemoveAll<SolrNet.Cloud.ISolrOperationsProvider>();
	var cloudStateProvider = new SolrNet.Cloud.ZooKeeperClient.SolrCloudStateProvider(settings.ZookeeperConnectionString, settings.TimeoutInSeconds);
	SolrNet.Cloud.Startup.InitAsync<T>(cloudStateProvider: cloudStateProvider, collectionName: settings.CollectionName, isPostConnection: true)
		.ConfigureAwait(false)
		.GetAwaiter()
		.GetResult();

	var requestFactory = cert is null
		? new HttpWebRequestFactory() as IHttpWebRequestFactory
		: new CertificateHttpWebRequestFactory(cert);
	container.RemoveAll<SolrNet.Cloud.ISolrOperationsProvider>();
	container.Register<SolrNet.Cloud.ISolrOperationsProvider>(c => new MySolrOperationsProvider(requestFactory, settings.TimeoutInSeconds));
}

public class MySolrOperationsProvider : SolrNet.Cloud.ISolrOperationsProvider
{
    private readonly IHttpWebRequestFactory _requestFactory;
    private readonly int _timeOutSeconds;

    public MySolrOperationsProvider(IHttpWebRequestFactory requestFactory, int timeOutSeconds)
    {
        _requestFactory = requestFactory;
        _timeOutSeconds = timeOutSeconds;
    }

    public ISolrBasicOperations<T> GetBasicOperations<T>(string url, bool isPostConnection = false)
    {
        var connection = new SolrNet.Impl.SolrConnection(url);
        connection.HttpWebRequestFactory = _requestFactory;
        connection.Timeout = (int)TimeSpan.FromSeconds(_timeOutSeconds).TotalMilliseconds;

        if (!isPostConnection)
        {
            return SolrNet.SolrNet.GetBasicServer<T>(connection);
        }
        else
        {
            var postConnection = new SolrNet.Impl.PostSolrConnection(connection, url);
            postConnection.HttpWebRequestFactory = _requestFactory;
            return SolrNet.SolrNet.GetBasicServer<T>(postConnection);
        }
    }

    public ISolrOperations<T> GetOperations<T>(string url, bool isPostConnection = false)
    {
        var connection = new SolrNet.Impl.SolrConnection(url);
        connection.HttpWebRequestFactory = _requestFactory;
        connection.Timeout = (int)TimeSpan.FromSeconds(_timeOutSeconds).TotalMilliseconds;

        if (!isPostConnection)
        {
            return SolrNet.SolrNet.GetServer<T>(connection);
        }
        else
        {
            var postConnection = new SolrNet.Impl.PostSolrConnection(connection, url);
            postConnection.HttpWebRequestFactory = _requestFactory;
            return SolrNet.SolrNet.GetServer<T>(postConnection);
        }
    }
}

public static class NoSynchronizationContextScope
{
    public static IDisposable Enter()
    {
        var context = SynchronizationContext.Current;
        SynchronizationContext.SetSynchronizationContext(null);
        return new Restorer(context);
    }

    private struct Restorer : IDisposable
    {
        private readonly SynchronizationContext _synchronizationContext;

        public Restorer(SynchronizationContext synchronizationContext)
        {
            _synchronizationContext = synchronizationContext;
        }

        public void Dispose()
        {
            SynchronizationContext.SetSynchronizationContext(_synchronizationContext);
        }
    }
}

public class CertificateHttpWebRequestFactory : IHttpWebRequestFactory
{
    private readonly X509Certificate _certificate;

    public CertificateHttpWebRequestFactory(X509Certificate certificate)
    {
        _certificate = certificate;
    }

    public IHttpWebRequest Create(Uri url)
    {
        var req = (HttpWebRequest)WebRequest.Create(url);
        req.ClientCertificates.Add(_certificate);
        return new HttpWebRequestAdapter(req);
    }

    public IHttpWebRequest Create(string url)
    {
        return Create(new Uri(url));
    }
}

        var cert = LoadCertificate(certificatePath, certificatePass);
        var requestFactory = cert is null
            ? new HttpWebRequestFactory() as IHttpWebRequestFactory
            : new ClientCertificateHttpWebRequestFactory(cert);

        var cloudStateProvider = new SolrNet.Cloud.ZooKeeperClient.SolrCloudStateProvider(zkConnectionString, zooKeeperTimeoutMs: timeoutSeconds * 1000);
        SolrNet.Cloud.Startup.InitAsync<T>(
            cloudStateProvider: cloudStateProvider,
            collectionName: collectionName,
            isPostConnection: true,
            solrOperationsProvider: new ClientCertificateSolrOperationsProvider(requestFactory, timeoutSeconds * 1000))
                .ConfigureAwait(false)
                .GetAwaiter()
                .GetResult();

        SolrNet.Cloud.Startup.Reset();