public static async Task <SessionWithSolution> CreateAsync(RemoteHostClient.Connection connection, Solution solution, CancellationToken cancellationToken) { Contract.ThrowIfNull(connection); Contract.ThrowIfNull(solution); var service = solution.Workspace.Services.GetRequiredService <IRemotableDataService>(); var scope = await service.CreatePinnedRemotableDataScopeAsync(solution, cancellationToken).ConfigureAwait(false); SessionWithSolution?session = null; try { // set connection state for this session. // we might remove this in future. see https://github.com/dotnet/roslyn/issues/24836 await connection.InvokeAsync( WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, new object[] { scope.SolutionInfo }, cancellationToken).ConfigureAwait(false); // transfer ownership of connection and scope to the session object: session = new SessionWithSolution(connection, scope); } finally { if (session == null) { scope.Dispose(); } } return(session); }
public static async Task <SessionWithSolution> CreateAsync(RemoteHostClient.Connection connection, Solution solution, CancellationToken cancellationToken) { Contract.ThrowIfNull(connection); Contract.ThrowIfNull(solution); PinnedRemotableDataScope scope = null; try { scope = await solution.GetPinnedScopeAsync(cancellationToken).ConfigureAwait(false); // set connection state for this session. // we might remove this in future. see https://github.com/dotnet/roslyn/issues/24836 await connection.InvokeAsync( WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, new object[] { scope.SolutionInfo }, cancellationToken).ConfigureAwait(false); return(new SessionWithSolution(connection, scope)); } catch { // make sure disposable objects are disposed when // exceptions are thrown connection.Dispose(); scope?.Dispose(); // we only expect this to happen on cancellation. otherwise, rethrow cancellationToken.ThrowIfCancellationRequested(); throw; } }
public KeepAliveSession(RemoteHostClient client, RemoteHostClient.Connection connection, string serviceName, object callbackTarget) { _gate = new object(); Initialize(client, connection); _remoteHostClientService = client.Workspace.Services.GetService <IRemoteHostClientService>(); _serviceName = serviceName; _callbackTarget = callbackTarget; }
public KeepAliveSession(RemoteHostClient client, RemoteHostClient.Connection connection, string serviceName, object callbackTarget) { Initialize_NoLock(client, connection); _gate = new SemaphoreSlim(initialCount: 1); _remoteHostClientService = client.Workspace.Services.GetService <IRemoteHostClientService>(); _serviceName = serviceName; _callbackTarget = callbackTarget; }
public void Shutdown() { using (_gate.DisposableWait(_cancellationToken)) { if (_client != null) { _client.StatusChanged -= OnStatusChanged; } _connection?.Dispose(); _client = null; _connection = null; } }
public static async Task <SessionWithSolution> CreateAsync(RemoteHostClient.Connection connection, PinnedRemotableDataScope scope, CancellationToken cancellationToken) { var sessionWithSolution = new SessionWithSolution(connection, scope); try { await connection.RegisterPinnedRemotableDataScopeAsync(scope).ConfigureAwait(false); return(sessionWithSolution); } catch { sessionWithSolution.Dispose(); // we only expect this to happen on cancellation. otherwise, rethrow cancellationToken.ThrowIfCancellationRequested(); throw; } }
public static async Task <SessionWithSolution> CreateAsync(RemoteHostClient.Connection connection, Solution solution, CancellationToken cancellationToken) { Contract.ThrowIfNull(connection); Contract.ThrowIfNull(solution); PinnedRemotableDataScope?scope = null; try { var service = solution.Workspace.Services.GetRequiredService <IRemotableDataService>(); scope = await service.CreatePinnedRemotableDataScopeAsync(solution, cancellationToken).ConfigureAwait(false); // set connection state for this session. // we might remove this in future. see https://github.com/dotnet/roslyn/issues/24836 await connection.InvokeAsync( WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, new object[] { scope.SolutionInfo }, cancellationToken).ConfigureAwait(false); return(new SessionWithSolution(connection, scope)); } catch { // Make sure disposable objects are disposed when exceptions are thrown. The try/finally is used to // ensure 'scope' is disposed even if an exception is thrown while disposing 'connection'. try { connection.Dispose(); } finally { scope?.Dispose(); } // we only expect this to happen on cancellation. otherwise, rethrow cancellationToken.ThrowIfCancellationRequested(); throw; } }
public static async Task <SessionWithSolution> CreateAsync(RemoteHostClient.Connection connection, PinnedRemotableDataScope scope, CancellationToken cancellationToken) { var sessionWithSolution = new SessionWithSolution(connection, scope); try { // set connection state for this session. // we might remove this in future. see https://github.com/dotnet/roslyn/issues/24836 await connection.InvokeAsync( WellKnownServiceHubServices.ServiceHubServiceBase_Initialize, new object[] { scope.SolutionInfo }, cancellationToken).ConfigureAwait(false); return(sessionWithSolution); } catch { sessionWithSolution.Dispose(); // we only expect this to happen on cancellation. otherwise, rethrow cancellationToken.ThrowIfCancellationRequested(); throw; } }
private SessionWithSolution(RemoteHostClient.Connection connection, PinnedRemotableDataScope scope) { _connection = connection; _scope = scope; }
private SessionWithSolution(RemoteHostClient.Connection connection, PinnedRemotableDataScope scope, CancellationToken cancellationToken) { _connection = connection; _scope = scope; _cancellationToken = cancellationToken; }
public KeepAliveSession(RemoteHostClient.Connection connection, IRemotableDataService remotableDataService) { _remotableDataService = remotableDataService; _connection = connection; }