public static IObservable <Socket> StartSocketObservable(this TcpListener listener, int maxConcurrent)
{
Contract.Requires(listener != null);
Contract.Requires(maxConcurrent > 0);
Contract.Ensures(Contract.Result <IObservable <Socket> >() != null);
return(listener.StartObservable(
() => Observable.StartAsync(listener.AcceptSocketAsync),
maxConcurrent));
}
/// <summary>
/// Returns an observable of concurrent TCP connections. (See the remarks section for important details about the concurrent behavior.)
/// </summary>
/// <remarks>
/// <alert type="warning">
/// <see cref="Start(IPEndPoint)"/> returns an observable that may send notifications concurrently. This behavior allows
/// observers to receive multiple clients concurrently, as is common in hosting scenarios; however, it violates an important contract
/// in Rx. The Rx Design Guidelines document states that Rx operators assume notifications are sent in a serialized fashion. The only
/// methods that do not conflict with this guideline and are safe to call on the observable that is returned by
/// <see cref="Start(IPEndPoint)"/> are <strong>Subscribe</strong> and <strong>Synchronize</strong>. Do not attempt to use
/// any other Rx operators unless the observable is synchronized first.
/// </alert>
/// </remarks>
/// <param name="address">The local IP address on which to listen for clients.</param>
/// <param name="port">The local port number on which to listen for clients.</param>
/// <param name="maxConcurrent">The maximum number of clients that can be pushed through the observable simultaneously.</param>
/// <returns>An observable of concurrent TCP connections.</returns>
public static IObservable <TcpClient> Start(IPAddress address, int port, int maxConcurrent)
{
Contract.Requires(address != null);
Contract.Requires(port >= IPEndPoint.MinPort && port <= IPEndPoint.MaxPort);
Contract.Ensures(Contract.Result <IObservable <TcpClient> >() != null);
return(Observable.Defer(() =>
{
var listener = new TcpListener(address, port);
return listener.StartObservable(maxConcurrent).Finally(listener.Stop);
}));
}
/// <summary>
/// Returns an observable of concurrent TCP connections. (See the remarks section for important details about the concurrent behavior.)
/// </summary>
/// <remarks>
/// <alert type="warning">
/// <see cref="Start(IPEndPoint)"/> returns an observable that may send notifications concurrently. This behavior allows
/// observers to receive multiple clients concurrently, as is common in hosting scenarios; however, it violates an important contract
/// in Rx. The Rx Design Guidelines document states that Rx operators assume notifications are sent in a serialized fashion. The only
/// methods that do not conflict with this guideline and are safe to call on the observable that is returned by
/// <see cref="Start(IPEndPoint)"/> are <strong>Subscribe</strong> and <strong>Synchronize</strong>. Do not attempt to use
/// any other Rx operators unless the observable is synchronized first.
/// </alert>
/// </remarks>
/// <param name="address">The local IP address on which to listen for clients.</param>
/// <param name="port">The local port number on which to listen for clients.</param>
/// <param name="maxConcurrent">The maximum number of clients that can be pushed through the observable simultaneously.</param>
/// <returns>An observable of concurrent TCP connections.</returns>
public static IObservable<TcpClient> Start(IPAddress address, int port, int maxConcurrent)
{
Contract.Requires(address != null);
Contract.Requires(port >= IPEndPoint.MinPort && port <= IPEndPoint.MaxPort);
Contract.Ensures(Contract.Result<IObservable<TcpClient>>() != null);
return Observable.Defer(() =>
{
var listener = new TcpListener(address, port);
return listener.StartObservable(maxConcurrent).Finally(listener.Stop);
});
}