public async Task HandleableCollectionThrowsWhenDisposedTest() { var collection = new HandleableCollection <int>(); AddRangeAndVerifyItems(collection, endInclusive: 9); HandleableCollection <int> .Handler handler = (int item, out bool removeItem) => { removeItem = false; return(20 == item); }; using var cancellation = new CancellationTokenSource(DefaultPositiveVerificationTimeout); Task handleTask = Task.Run(() => collection.Handle(handler, DefaultPositiveVerificationTimeout)); Task handleAsyncTask = collection.HandleAsync(handler, cancellation.Token); // Task.Delay intentionally shorter than default timeout to check that Handle* // calls did not complete quickly. Task delayTask = Task.Delay(TimeSpan.FromSeconds(1)); Task completedTask = await Task.WhenAny(delayTask, handleTask, handleAsyncTask); // Check that the handle tasks didn't complete Assert.Equal(delayTask, completedTask); collection.Dispose(); // Incomplete calls from prior to disposal should throw ObjectDisposedException await Assert.ThrowsAsync <ObjectDisposedException>(() => handleTask); await Assert.ThrowsAsync <ObjectDisposedException>(() => handleAsyncTask); // New calls should throw ObjectDisposedException Assert.Throws <ObjectDisposedException>( () => collection.Add(10)); Assert.Throws <ObjectDisposedException>( () => collection.ClearItems()); Assert.Throws <ObjectDisposedException>( () => collection.Handle(DefaultPositiveVerificationTimeout)); Assert.Throws <ObjectDisposedException>( () => collection.Handle(handler, DefaultPositiveVerificationTimeout)); await Assert.ThrowsAsync <ObjectDisposedException>( () => collection.HandleAsync(cancellation.Token)); await Assert.ThrowsAsync <ObjectDisposedException>( () => collection.HandleAsync(handler, cancellation.Token)); Assert.Throws <ObjectDisposedException>( () => ((IEnumerable)collection).GetEnumerator()); Assert.Throws <ObjectDisposedException>( () => ((IEnumerable <int>)collection).GetEnumerator()); }
/// <summary> /// Listens at the address for new connections. /// </summary> /// <param name="maxConnections">The maximum number of connections the server will support.</param> /// <param name="token">The token to monitor for cancellation requests.</param> /// <returns>A task that completes when the server is no longer listening at the address.</returns> private async Task ListenAsync(int maxConnections, CancellationToken token) { // This disposal shuts down the transport in case an exception is thrown. using var transport = IpcServerTransport.Create(_address, maxConnections, _enableTcpIpProtocol, TransportCallback); // This disposal shuts down the transport in case of cancellation; causes the transport // to not recreate the server stream before the AcceptAsync call observes the cancellation. using var _ = token.Register(() => transport.Dispose()); while (!token.IsCancellationRequested) { Stream stream = null; IpcAdvertise advertise = null; try { stream = await transport.AcceptAsync(token).ConfigureAwait(false); } catch (OperationCanceledException) { } catch (Exception) { // The advertise data could be incomplete if the runtime shuts down before completely writing // the information. Catch the exception and continue waiting for a new connection. } if (null != stream) { // Cancel parsing of advertise data after timeout period to // mitigate runtimes that write partial data and do not close the stream (avoid waiting forever). using var parseCancellationSource = new CancellationTokenSource(); using var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(token, parseCancellationSource.Token); try { parseCancellationSource.CancelAfter(ParseAdvertiseTimeout); advertise = await IpcAdvertise.ParseAsync(stream, linkedSource.Token).ConfigureAwait(false); } catch (Exception) { stream.Dispose(); } } if (null != advertise) { Guid runtimeCookie = advertise.RuntimeInstanceCookie; int pid = unchecked ((int)advertise.ProcessId); // The valueFactory parameter of the GetOrAdd overload that uses Func<TKey, TValue> valueFactory // does not execute the factory under a lock thus it is not thread-safe. Create the collection and // use a thread-safe version of GetOrAdd; use equality comparison on the result to determine if // the new collection was added to the dictionary or if an existing one was returned. var newStreamCollection = new HandleableCollection <Stream>(); var streamCollection = _streamCollections.GetOrAdd(runtimeCookie, newStreamCollection); try { streamCollection.ClearItems(); streamCollection.Add(stream); if (newStreamCollection == streamCollection) { ServerIpcEndpoint endpoint = new ServerIpcEndpoint(this, runtimeCookie); _endpointInfos.Add(new IpcEndpointInfo(endpoint, pid, runtimeCookie)); } else { newStreamCollection.Dispose(); } } catch (ObjectDisposedException) { // The stream collection could be disposed by RemoveConnection which would cause an // ObjectDisposedException to be thrown if trying to clear/add the stream. stream.Dispose(); } } } }