From 041f327f87e4cca4ba49f6c37d0a7bfa303ca2de Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 20 Nov 2018 22:12:48 +0100
Subject: [PATCH 01/49] Observable Subscriptions (#80)

* create observable subscription

* create integration test server and test project

* fix debug output

* create basic unit test for subscription

* make unit test politically correct

* make sure all ClientWebSockets are disposed on disposing the GraphQlHttpClient

* fix comment

* Modified GraphQL.Client.csproj
---
 GraphQL.Client.sln                            |  16 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |   5 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  37 ++-
 .../Http/GraphQLHttpObservableSubscription.cs | 268 ++++++++++++++++++
 .../Http/GraphQLHttpSubscriptionResult.cs     |   8 +-
 .../Http/HttpClientExtensions.cs              |  10 +
 src/GraphQL.Client/IGraphQLClient.cs          |   2 +
 .../Response/GraphQLSubscriptionResponse.cs   |   2 +-
 .../GraphQL.Client.Tests.csproj               |   4 +-
 .../GraphQL.Integration.Tests.csproj          |  28 ++
 .../GraphQLClientExtensions.cs                |  34 +++
 .../ObservableTester.cs                       | 151 ++++++++++
 .../Properties/launchSettings.json            |  27 ++
 .../SubscriptionsTest.cs                      | 114 ++++++++
 .../WebApplicationFactoryExtensions.cs        |  19 ++
 .../ChatSchema/ChatMutation.cs                |  31 ++
 .../ChatSchema/ChatQuery.cs                   |  13 +
 .../ChatSchema/ChatSchema.cs                  |  14 +
 .../ChatSchema/ChatSubscriptions.cs           |  74 +++++
 .../IntegrationTestServer/ChatSchema/IChat.cs |  79 ++++++
 .../ChatSchema/Message.cs                     |  15 +
 .../ChatSchema/MessageFrom.cs                 |   9 +
 .../ChatSchema/MessageFromType.cs             |  13 +
 .../ChatSchema/MessageType.cs                 |  21 ++
 .../ChatSchema/ReceivedMessage.cs             |  13 +
 .../IntegrationTestServer.csproj              |  22 ++
 tests/IntegrationTestServer/Program.cs        |  17 ++
 .../Properties/launchSettings.json            |  28 ++
 tests/IntegrationTestServer/Startup.cs        |  69 +++++
 29 files changed, 1127 insertions(+), 16 deletions(-)
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
 create mode 100644 tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
 create mode 100644 tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
 create mode 100644 tests/GraphQL.Integration.Tests/ObservableTester.cs
 create mode 100644 tests/GraphQL.Integration.Tests/Properties/launchSettings.json
 create mode 100644 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/IChat.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/Message.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageType.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
 create mode 100644 tests/IntegrationTestServer/IntegrationTestServer.csproj
 create mode 100644 tests/IntegrationTestServer/Program.cs
 create mode 100644 tests/IntegrationTestServer/Properties/launchSettings.json
 create mode 100644 tests/IntegrationTestServer/Startup.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 45a422a5..722a7d85 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -43,7 +43,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".circleci", ".circleci", "{
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{9413EC62-CDDE-4E77-9784-E1136EA5D1EE}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Sample", "samples\GraphQL.Client.Sample\GraphQL.Client.Sample.csproj", "{B21E97C3-F328-473F-A054-A4BF272B63F0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Sample", "samples\GraphQL.Client.Sample\GraphQL.Client.Sample.csproj", "{B21E97C3-F328-473F-A054-A4BF272B63F0}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests", "tests\GraphQL.Integration.Tests\GraphQL.Integration.Tests.csproj", "{86BC3878-6549-4EF1-9672-B7C15A3FDF46}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -71,6 +75,14 @@ Global
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Release|Any CPU.Build.0 = Release|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -83,6 +95,8 @@ Global
 		{6326E0E2-3F48-4BAF-80D3-47AED5EB647C} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
 		{C1406F03-650F-4633-887D-312943251919} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
 		{B21E97C3-F328-473F-A054-A4BF272B63F0} = {9413EC62-CDDE-4E77-9784-E1136EA5D1EE}
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 99a24460..200758df 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -1,11 +1,11 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../src.props" />
 
 	<PropertyGroup>
 		<Description>A GraphQL Client</Description>
-		<TargetFrameworks>netstandard1.3;netstandard2.0</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -14,6 +14,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
 	<!-- Allow method ReadAsAsync<T>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 58da72ee..fe8f4710 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -40,6 +41,7 @@ public GraphQLHttpClientOptions Options {
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
+		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		/// <summary>
 		/// Initializes a new instance
@@ -117,23 +119,44 @@ public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, Cancell
 			this.SendSubscribeAsync(new GraphQLRequest { Query = query }, cancellationToken);
 
 		[Obsolete("EXPERIMENTAL API")]
-		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
+		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			GraphQLHttpSubscriptionResult graphQLSubscriptionResult = _createSubscription(request, cancellationToken);
+			return Task.FromResult<IGraphQLSubscriptionResult>(graphQLSubscriptionResult);
+		}
+
+		private GraphQLHttpSubscriptionResult _createSubscription(GraphQLRequest request, CancellationToken cancellationToken)
+		{
 			if (request == null) { throw new ArgumentNullException(nameof(request)); }
 			if (request.Query == null) { throw new ArgumentNullException(nameof(request.Query)); }
 
-			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
-			var webSocketUri = new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
-			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(webSocketUri, request);
+			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(_getWebSocketUri(), request);
 			graphQLSubscriptionResult.StartAsync(cancellationToken);
-			return Task.FromResult<IGraphQLSubscriptionResult>(graphQLSubscriptionResult);
+			return graphQLSubscriptionResult;
+		}
+
+		private Uri _getWebSocketUri()
+		{
+			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
+			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
+		}
+
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
+		{
+			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token);
+			return observable;
 		}
 
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
-		public void Dispose() =>
+		public void Dispose()
+		{
 			this.graphQLHttpHandler.Dispose();
-
+			_cancellationTokenSource.Cancel();
+			_cancellationTokenSource.Dispose();
+		}
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
new file mode 100644
index 00000000..d3f71990
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -0,0 +1,268 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Http {
+
+	/// <summary>
+	/// Represents the result of a subscription query
+	/// </summary>
+	[Obsolete("EXPERIMENTAL API")]
+	public class GraphQLHttpObservableSubscription : IDisposable {
+
+		private readonly ClientWebSocket clientWebSocket = new ClientWebSocket();
+		private readonly Uri webSocketUri;
+		private readonly GraphQLRequest graphQLRequest;
+		private readonly byte[] buffer = new byte[1024 * 1024];
+		private readonly ArraySegment<byte> arraySegment;
+		private readonly CancellationTokenSource _cancellationTokenSource;
+
+		private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default) {
+			_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+			_cancellationTokenSource.Token.Register(Dispose);
+			this.webSocketUri = webSocketUri;
+			this.graphQLRequest = graphQLRequest;
+			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+			arraySegment = new ArraySegment<byte>(buffer);
+		}
+
+		public async Task ConnectAsync(CancellationToken token)
+		{
+			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
+			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
+		}
+
+		public async Task<GraphQLResponse> ReceiveResultAsync()
+		{
+			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
+			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+			switch (webSocketResponse.Type)
+			{
+				case GQLWebSocketMessageType.GQL_COMPLETE:
+					Debug.WriteLine($"received 'complete' message on subscription {this.GetHashCode()}");
+					Dispose();
+					break;
+				case GQLWebSocketMessageType.GQL_ERROR:
+					Debug.WriteLine($"received 'error' message on subscription {this.GetHashCode()}");
+					throw new GQLSubscriptionException(webSocketResponse.Payload);
+				default:
+					Debug.WriteLine($"received payload on subscription {this.GetHashCode()}");
+					break;
+			}
+
+			return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
+		}
+
+		public async Task CloseAsync(CancellationToken cancellationToken = default)
+		{
+			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
+			if (this.clientWebSocket.State == WebSocketState.Open) {
+				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
+			}
+			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
+		}
+
+		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
+		{
+			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
+			var webSocketRequest = new GraphQLSubscriptionRequest
+			{
+				Id = "1",
+				Type = GQLWebSocketMessageType.GQL_START,
+				Payload = this.graphQLRequest
+			};
+			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
+		}
+
+		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
+		{
+			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
+			var webSocketRequest = new GraphQLSubscriptionRequest
+			{
+				Id = "1",
+				Type = GQLWebSocketMessageType.GQL_STOP,
+				Payload = this.graphQLRequest
+			};
+			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
+		}
+
+		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default)
+		{
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
+		}
+
+		#region IDisposable
+
+		public void Dispose()
+		{
+			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+			if(Disposed == null) Disposed = DisposeAsync();
+		}
+
+		public Task Disposed { get; private set; }
+
+		private async Task DisposeAsync()
+		{
+			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
+			if(!_cancellationTokenSource.IsCancellationRequested)
+				_cancellationTokenSource.Cancel();
+			await CloseAsync().ConfigureAwait(false);
+			clientWebSocket?.Dispose();
+			_cancellationTokenSource.Dispose();
+			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
+		}
+
+		#endregion
+
+		#region Static Factories
+
+		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
+		{
+			return Observable.Using(
+				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
+				InitializeSubscription
+				).Publish().RefCount();
+		}
+
+
+		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
+		{
+			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
+			return Task.FromResult(subscription);
+		}
+
+		private static async Task<IObservable<GraphQLResponse>> InitializeSubscription(GraphQLHttpObservableSubscription observableSubscription, CancellationToken cancelToken)
+		{
+			await observableSubscription.ConnectAsync(cancelToken).ConfigureAwait(false);
+			await observableSubscription.SendInitialMessageAsync(cancelToken).ConfigureAwait(false);
+			return Observable.Defer(() => observableSubscription.ReceiveResultAsync().ToObservable()).Repeat();
+		}
+
+		#endregion
+
+		[Serializable]
+		public class GQLSubscriptionException : Exception
+		{
+			//
+			// For guidelines regarding the creation of new exception types, see
+			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+			// and
+			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+			//
+
+			public GQLSubscriptionException()
+			{
+			}
+
+			public GQLSubscriptionException(object error) : base(error.ToString())
+			{
+			}
+
+			protected GQLSubscriptionException(
+				SerializationInfo info,
+				StreamingContext context) : base(info, context)
+			{
+			}
+		}
+
+		public static class GQLWebSocketMessageType
+		{
+
+			/// <summary>
+			///     Client sends this message after plain websocket connection to start the communication with the server
+			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+			///     to this message.
+			///     payload: Object : optional parameters that the client specifies in connectionParams
+			/// </summary>
+			public const string GQL_CONNECTION_INIT = "connection_init";
+
+			/// <summary>
+			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+			///     the connection.
+			/// </summary>
+			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+
+			/// <summary>
+			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+			///     the connection.
+			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+			///     client, just ignore the message).
+			///     payload: Object: the server side error
+			/// </summary>
+			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+
+			/// <summary>
+			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+			///     client connection alive.
+			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+			///     server.
+			///     <remarks>
+			///         NOTE: This one here don't follow the standard due to connection optimization
+			///     </remarks>
+			/// </summary>
+			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+
+			/// <summary>
+			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+			///     id: string : operation id
+			/// </summary>
+			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+
+			/// <summary>
+			///     Client sends this message to execute GraphQL operation
+			///     id: string : The id of the GraphQL operation to start
+			///     payload: Object:
+			///     query: string : GraphQL operation as string or parsed GraphQL document node
+			///     variables?: Object : Object with GraphQL variables
+			///     operationName?: string : GraphQL operation name
+			/// </summary>
+			public const string GQL_START = "start";
+
+			/// <summary>
+			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+			///     is a response for GQL_START message.
+			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+			///     id: string : ID of the operation that was successfully set up
+			///     payload: Object :
+			///     data: any: Execution result
+			///     errors?: Error[] : Array of resolvers errors
+			/// </summary>
+			public const string GQL_DATA = "data"; // Server -> Client
+
+			/// <summary>
+			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+			///     payload: Error : payload with the error attributed to the operation failing on the server
+			///     id: string : operation ID of the operation that failed on the server
+			/// </summary>
+			public const string GQL_ERROR = "error"; // Server -> Client
+
+			/// <summary>
+			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+			///     specific operation.
+			///     id: string : operation ID of the operation that completed
+			/// </summary>
+			public const string GQL_COMPLETE = "complete"; // Server -> Client
+
+			/// <summary>
+			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+			///     id: string : operation id
+			/// </summary>
+			public const string GQL_STOP = "stop"; // Client -> Server
+		}
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
index c916f82e..e0c2dc6d 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
@@ -39,9 +39,11 @@ public async void StartAsync(CancellationToken cancellationToken = default) {
 					var webSocketReceiveResult = await this.clientWebSocket.ReceiveAsync(arraySegment, cancellationToken);
 					var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
 					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
-					if (webSocketResponse != null) {
-						this.LastResponse = webSocketResponse.Payload;
-						this.OnReceive?.Invoke(webSocketResponse.Payload);
+					if (webSocketResponse != null)
+					{
+						var response = (GraphQLResponse) webSocketResponse.Payload;
+						this.LastResponse = response;
+						this.OnReceive?.Invoke(response);
 					}
 				}
 			}
diff --git a/src/GraphQL.Client/Http/HttpClientExtensions.cs b/src/GraphQL.Client/Http/HttpClientExtensions.cs
index c0fb4b49..1d7ca0e4 100644
--- a/src/GraphQL.Client/Http/HttpClientExtensions.cs
+++ b/src/GraphQL.Client/Http/HttpClientExtensions.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Net.Http;
 
 namespace GraphQL.Client.Http {
@@ -16,6 +17,15 @@ public static class HttpClientExtensions {
 		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
 			new GraphQLHttpClient(graphQLHttpClientOptions, httpClient);
 
+		/// <summary>
+		/// Creates a <see cref="GraphQLHttpClient"/> from a <see cref="HttpClient"/>
+		/// </summary>
+		/// <param name="httpClient"></param>
+		/// <param name="endPoint"></param>
+		/// <returns></returns>
+		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint) =>
+			new GraphQLHttpClient(new GraphQLHttpClientOptions { EndPoint = endPoint }, httpClient);
+
 	}
 
 }
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 108762f7..3343da14 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -36,6 +36,8 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
 
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
 	}
 
 }
diff --git a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs b/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
index 3ba69331..71c47c72 100644
--- a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
+++ b/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
@@ -22,7 +22,7 @@ public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionRespons
 		/// <summary>
 		/// The Payload of the Response
 		/// </summary>
-		public GraphQLResponse Payload { get; set; }
+		public dynamic Payload { get; set; }
 
 		/// <inheritdoc />
 		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionResponse);
diff --git a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
index e8584d6d..cef55529 100644
--- a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
+++ b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
@@ -1,10 +1,10 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../tests.props" />
 
 	<PropertyGroup>
-		<TargetFrameworks>netcoreapp1.0;netcoreapp1.1;netcoreapp2.0;netcoreapp2.1</TargetFrameworks>
+		<TargetFrameworks>netcoreapp2.0;netcoreapp2.1</TargetFrameworks>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
new file mode 100644
index 00000000..5fc195bc
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.5" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="2.1.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
+    <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
new file mode 100644
index 00000000..e8b4babf
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Threading.Tasks;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class GraphQLClientExtensions
+	{
+		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
+		{
+			var graphQLRequest = new GraphQLRequest
+			{
+				Query = @"
+				mutation($input: MessageInputType){
+				  addMessage(message: $input){
+				    content
+				  }
+				}",
+				Variables = new
+				{
+					input = new
+					{
+						fromId = "me",
+						content = message,
+						sentAt = DateTime.Now
+					}
+				}
+			};
+			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
new file mode 100644
index 00000000..e7993a36
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace GraphQL.Integration.Tests
+{
+	public class ObservableTester<T> : IDisposable
+	{
+		private readonly IDisposable _subscription;
+		private ManualResetEventSlim _updateReceived { get; } = new ManualResetEventSlim();
+		private ManualResetEventSlim _completed { get; } = new ManualResetEventSlim();
+		private ManualResetEventSlim _error { get; } = new ManualResetEventSlim();
+
+		/// <summary>
+		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+		/// </summary>
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// </summary>
+		public bool UpdateReceived => _updateReceived.IsSet;
+		/// <summary>
+		/// The last payload which was received.
+		/// </summary>
+		public T LastPayload { get; private set; }
+
+		public Exception Error { get; private set; }
+
+		/// <summary>
+		/// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
+		/// </summary>
+		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
+		public ObservableTester(IObservable<T> observable)
+		{
+			_subscription = observable.Subscribe(
+				obj => {
+					LastPayload = obj;
+					_updateReceived.Set();
+				},
+				ex =>
+				{
+					Error = ex;
+					_error.Set();
+				},
+				() => _completed.Set()
+			);
+		}
+
+		/// <summary>
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// </summary>
+		/// <param name="assertPayload">action to assert the contents of the payload</param>
+		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
+		{
+			try
+			{
+				if (!_updateReceived.Wait(Timeout))
+					Assert.True(false, "no update received!");
+
+				assertPayload?.Invoke(LastPayload);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
+		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
+		{
+			try
+			{
+				if (_updateReceived.Wait(100))
+					Assert.True(false, "update was inadvertently pushed!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		public void ShouldHaveCompleted()
+		{
+			try
+			{
+				if (!_completed.Wait(Timeout))
+					Assert.True(false, "subscription did not complete!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		public void ShouldHaveThrownError(Action<Exception> assertError = null)
+		{
+			try
+			{
+				if (!_error.Wait(Timeout))
+					Assert.True(false, "subscription did not throw an error!");
+
+				assertError?.Invoke(Error);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Resets the tester class. Should be called before triggering the potential update
+		/// </summary>
+		public void Reset()
+		{
+			if (_completed.IsSet)
+				throw new InvalidOperationException(
+					"the subscription sequence has completed. this tester instance cannot be reused");
+
+			LastPayload = default(T);
+			_updateReceived.Reset();
+		}
+
+		/// <inheritdoc />
+		public void Dispose()
+		{
+			_subscription?.Dispose();
+		}
+	}
+
+	public static class ObservableExtensions
+	{
+		public static ObservableTester<T> SubscribeTester<T>(this IObservable<T> observable)
+		{
+			return new ObservableTester<T>(observable);
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/Properties/launchSettings.json b/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
new file mode 100644
index 00000000..f8fea71b
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
@@ -0,0 +1,27 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:51432/",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "GraphQL.Integration.Tests": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:51433/"
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
new file mode 100644
index 00000000..f8a66760
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -0,0 +1,114 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+
+namespace GraphQL.Integration.Tests
+{
+	public class SubscriptionsTest
+	{
+		public static IWebHost CreateServer(int port)
+		{
+			var configBuilder = new ConfigurationBuilder();
+			configBuilder.AddInMemoryCollection();
+			var config = configBuilder.Build();
+			config["server.urls"] = $"http://localhost:{port}";
+
+			var host = new WebHostBuilder()
+				.ConfigureLogging((ctx, logging) => logging.AddDebug())
+				.UseConfiguration(config)
+				.UseKestrel()
+				.UseStartup<IntegrationTestServer.Startup>()
+				.Build();
+
+			host.Start();
+
+			return host;
+		}
+
+		private readonly IWebHost _server;
+
+		public SubscriptionsTest()
+		{}
+
+		private GraphQLHttpClient GetGraphQLClient(int port)
+			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
+
+
+		[Fact]
+		public async void AssertTestingHarness()
+		{
+			var port = 5001;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				const string message = "some random testing message";
+				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
+
+				Assert.Equal(message, (string)response.Data.addMessage.content);
+			}
+		}
+
+		[Fact]
+		public async void CanCreateObservableSubscription()
+		{
+			var port = 5002;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+				var graphQLRequest = new GraphQLRequest
+				{
+					Query = @"
+					subscription {
+					  messageAdded{
+					    content
+					  }
+					}"
+				};
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+				const string message1 = "Hello World";
+
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string) response.Data.addMessage.content);
+
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				tester.Reset();
+
+				const string message2 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				tester.Reset();
+
+				// disposing the client should throw a TaskCanceledException on the subscription
+				client.Dispose();
+				tester.ShouldHaveThrownError(exception =>
+				{
+					Assert.True(exception is TaskCanceledException,
+							$"exception is of unexpected type {exception.GetType().Name}");
+				});
+			}
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
new file mode 100644
index 00000000..32b32e61
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
@@ -0,0 +1,19 @@
+using System;
+using GraphQL.Client.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class WebApplicationFactoryExtensions
+	{
+		public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
+			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint: class
+		{
+			var httpClient = factory.CreateClient();
+			var uriBuilder = new UriBuilder(httpClient.BaseAddress);
+			uriBuilder.Path = graphQlSchemaUrl;
+			uriBuilder.Scheme = urlScheme;
+			return httpClient.AsGraphQLClient(uriBuilder.Uri);
+		}
+	}
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
new file mode 100644
index 00000000..7c2a2333
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -0,0 +1,31 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatMutation : ObjectGraphType<object>
+    {
+        public ChatMutation(IChat chat)
+        {
+            Field<MessageType>("addMessage",
+                arguments: new QueryArguments(
+                    new QueryArgument<MessageInputType> {Name = "message"}
+                ),
+                resolve: context =>
+                {
+                    var receivedMessage = context.GetArgument<ReceivedMessage>("message");
+                    var message = chat.AddMessage(receivedMessage);
+                    return message;
+                });
+        }
+    }
+
+    public class MessageInputType : InputObjectGraphType
+    {
+        public MessageInputType()
+        {
+            Field<StringGraphType>("fromId");
+            Field<StringGraphType>("content");
+            Field<DateGraphType>("sentAt");
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
new file mode 100644
index 00000000..579c364f
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
@@ -0,0 +1,13 @@
+using System.Linq;
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatQuery : ObjectGraphType
+    {
+        public ChatQuery(IChat chat)
+        {
+            Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
new file mode 100644
index 00000000..904623a2
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
@@ -0,0 +1,14 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatSchema : Schema
+    {
+        public ChatSchema(IChat chat) 
+        {
+            Query = new ChatQuery(chat);
+            Mutation = new ChatMutation(chat);
+            Subscription = new ChatSubscriptions(chat);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
new file mode 100644
index 00000000..3c8c9624
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Security.Claims;
+using GraphQL;
+using GraphQL.Resolvers;
+using GraphQL.Server.Transports.Subscriptions.Abstractions;
+using GraphQL.Subscription;
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatSubscriptions : ObjectGraphType<object>
+    {
+        private readonly IChat _chat;
+
+        public ChatSubscriptions(IChat chat)
+        {
+            _chat = chat;
+            AddField(new EventStreamFieldType
+            {
+                Name = "messageAdded",
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(Subscribe)
+            });
+
+            AddField(new EventStreamFieldType
+            {
+                Name = "messageAddedByUser",
+                Arguments = new QueryArguments(
+                    new QueryArgument<NonNullGraphType<StringGraphType>> {Name = "id"}
+                ),
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(SubscribeById)
+            });
+        }
+
+        private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
+        {
+            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var user = messageContext.Get<ClaimsPrincipal>("user");
+
+            var sub = "Anonymous";
+            if (user != null)
+                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+
+            var messages = _chat.Messages(sub);
+
+            var id = context.GetArgument<string>("id");
+            return messages.Where(message => message.From.Id == id);
+        }
+
+        private Message ResolveMessage(ResolveFieldContext context)
+        {
+            var message = context.Source as Message;
+
+            return message;
+        }
+
+        private IObservable<Message> Subscribe(ResolveEventStreamContext context)
+        {
+            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var user = messageContext.Get<ClaimsPrincipal>("user");
+
+            var sub = "Anonymous";
+            if (user != null)
+                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+
+            return _chat.Messages(sub);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
new file mode 100644
index 00000000..68c8e86b
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Concurrent;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public interface IChat
+    {
+        ConcurrentStack<Message> AllMessages { get; }
+
+        Message AddMessage(Message message);
+
+        IObservable<Message> Messages(string user);
+
+        Message AddMessage(ReceivedMessage message);
+    }
+
+    public class Chat : IChat
+    {
+        private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+
+        public Chat()
+        {
+            AllMessages = new ConcurrentStack<Message>();
+            Users = new ConcurrentDictionary<string, string>
+            {
+                ["1"] = "developer",
+                ["2"] = "tester"
+            };
+        }
+
+        public ConcurrentDictionary<string, string> Users { get; set; }
+
+        public ConcurrentStack<Message> AllMessages { get; }
+
+        public Message AddMessage(ReceivedMessage message)
+        {
+            if (!Users.TryGetValue(message.FromId, out var displayName))
+            {
+                displayName = "(unknown)";
+            }
+
+            return AddMessage(new Message
+            {
+                Content = message.Content,
+                SentAt = message.SentAt,
+                From = new MessageFrom
+                {
+                    DisplayName = displayName,
+                    Id = message.FromId
+                }
+            });
+        }
+
+        public Message AddMessage(Message message)
+        {
+            AllMessages.Push(message);
+            _messageStream.OnNext(message);
+            return message;
+        }
+
+        public IObservable<Message> Messages(string user)
+        {
+            return _messageStream
+                .Select(message =>
+                {
+                    message.Sub = user;
+                    return message;
+                })
+                .AsObservable();
+        }
+
+        public void AddError(Exception exception)
+        {
+            _messageStream.OnError(exception);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/Message.cs b/tests/IntegrationTestServer/ChatSchema/Message.cs
new file mode 100644
index 00000000..f3b90cb1
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/Message.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class Message
+    {
+        public MessageFrom From { get; set; }
+
+        public string Sub { get; set; }
+
+        public string Content { get; set; }
+
+        public DateTime SentAt { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
new file mode 100644
index 00000000..5346cb6b
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
@@ -0,0 +1,9 @@
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageFrom
+    {
+        public string Id { get; set; }
+
+        public string DisplayName { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
new file mode 100644
index 00000000..98830475
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
@@ -0,0 +1,13 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageFromType : ObjectGraphType<MessageFrom>
+    {
+        public MessageFromType()
+        {
+            Field(o => o.Id);
+            Field(o => o.DisplayName);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageType.cs b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
new file mode 100644
index 00000000..320f5b55
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
@@ -0,0 +1,21 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageType : ObjectGraphType<Message>
+    {
+        public MessageType()
+        {
+            Field(o => o.Content);
+            Field(o => o.SentAt);
+            Field(o => o.Sub);
+            Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
+        }
+
+        private MessageFrom ResolveFrom(ResolveFieldContext<Message> context)
+        {
+            var message = context.Source;
+            return message.From;
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
new file mode 100644
index 00000000..0f1a409a
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ReceivedMessage
+    {
+        public string FromId { get; set; }
+
+        public string Content { get; set; }
+
+        public DateTime SentAt { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
new file mode 100644
index 00000000..179554ff
--- /dev/null
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="wwwroot\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.2.0" />
+    <PackageReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
new file mode 100644
index 00000000..fd8448a8
--- /dev/null
+++ b/tests/IntegrationTestServer/Program.cs
@@ -0,0 +1,17 @@
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+
+namespace IntegrationTestServer
+{
+	public class Program
+	{
+		public static void Main(string[] args)
+		{
+			CreateWebHostBuilder(args).Build().Run();
+		}
+
+		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+			WebHost.CreateDefaultBuilder(args)
+				.UseStartup<Startup>();
+	}
+}
diff --git a/tests/IntegrationTestServer/Properties/launchSettings.json b/tests/IntegrationTestServer/Properties/launchSettings.json
new file mode 100644
index 00000000..cd6aedd6
--- /dev/null
+++ b/tests/IntegrationTestServer/Properties/launchSettings.json
@@ -0,0 +1,28 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:55069/ui/graphiql/",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IntegrationTestServer": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "ui/graphiql",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:5005/"
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
new file mode 100644
index 00000000..0161c739
--- /dev/null
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -0,0 +1,69 @@
+using GraphQL.Server;
+using GraphQL.Server.Ui.GraphiQL;
+using GraphQL.Server.Ui.Voyager;
+using IntegrationTestServer.ChatSchema;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace IntegrationTestServer
+{
+	public class Startup
+	{
+		public Startup(IConfiguration configuration, IHostingEnvironment environment)
+		{
+			Configuration = configuration;
+			Environment = environment;
+		}
+
+		public IConfiguration Configuration { get; }
+		public IHostingEnvironment Environment { get; }
+
+		// This method gets called by the runtime. Use this method to add services to the container.
+		// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
+		public void ConfigureServices(IServiceCollection services)
+		{
+			services.AddSingleton<IChat, Chat>();
+			services.AddSingleton<ChatSchema.ChatSchema>();
+			services.AddSingleton<ChatQuery>();
+			services.AddSingleton<ChatMutation>();
+			services.AddSingleton<ChatSubscriptions>();
+			services.AddSingleton<MessageType>();
+			services.AddSingleton<MessageInputType>();
+
+			services.AddGraphQL(options =>
+				{
+					options.EnableMetrics = true;
+					options.ExposeExceptions = Environment.IsDevelopment();
+				})
+				.AddWebSockets();
+
+			services.AddMvc();
+		}
+
+		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+		public void Configure(IApplicationBuilder app, IHostingEnvironment env)
+		{
+			if (env.IsDevelopment())
+			{
+				app.UseDeveloperExceptionPage();
+			}
+
+			app.UseWebSockets();
+			app.UseGraphQLWebSockets<ChatSchema.ChatSchema>("/graphql");
+			app.UseGraphQL<ChatSchema.ChatSchema>("/graphql");
+			app.UseGraphiQLServer(new GraphiQLOptions
+			{
+				GraphiQLPath = "/ui/graphiql",
+				GraphQLEndPoint = "/graphql"
+			});
+			app.UseGraphQLVoyager(new GraphQLVoyagerOptions()
+			{
+				GraphQLEndPoint = "/graphql",
+				Path = "/ui/voyager"
+			});
+			app.UseMvc();
+		}
+	}
+}

From 546b304efee3e0b1eabeb5267319921f157d2580 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 29 Nov 2018 08:42:53 +0100
Subject: [PATCH 02/49] add StringEnumConverter to JsonSerializerSettings

---
 src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 9ff6b091..73a00430 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -1,7 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.Http {
@@ -20,7 +22,11 @@ public class GraphQLHttpClientOptions {
 		/// The <see cref="Newtonsoft.Json.JsonSerializerSettings"/> that is going to be used
 		/// </summary>
 		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver()
+			ContractResolver = new CamelCasePropertyNamesContractResolver(),
+			Converters = new List<JsonConverter>
+			{
+				new StringEnumConverter()
+			}
 		};
 
 		/// <summary>

From a8cff74aa083e663c50fc83999c06f6ad33f0ecf Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 29 Nov 2018 09:40:24 +0100
Subject: [PATCH 03/49] fix dependencies

---
 src/GraphQL.Client/GraphQL.Client.csproj     | 6 ++++++
 src/GraphQL.Client/Http/GraphQLHttpClient.cs | 1 -
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 200758df..97a78f0e 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -17,6 +17,12 @@
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <Reference Include="System.Reactive">
+	    <HintPath>C:\Users\arose\.nuget\packages\system.reactive\4.1.2\lib\netstandard2.0\System.Reactive.dll</HintPath>
+	  </Reference>
+	</ItemGroup>
+
 	<!-- Allow method ReadAsAsync<T>
 	<ItemGroup>
 		<PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.4" />
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index fe8f4710..cfc966b7 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;

From e3a2154b3d318e1d275698d69d56f6e911af8846 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 29 Nov 2018 09:43:34 +0100
Subject: [PATCH 04/49] change version

---
 root.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/root.props b/root.props
index e2fc2d0c..88283610 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.3</Version>
+		<Version>2.0.0-subscriptions-api.4</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 

From eca5d24b40a9017b7ad3aa6c97e637220b904fff Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 29 Nov 2018 09:47:49 +0100
Subject: [PATCH 05/49] fix version

---
 root.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 88283610..32db78cf 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-subscriptions-api.4</Version>
+		<Version>2.0.0-alpha.subscriptions-api.4</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 

From 29113452fa0092078171793d2a402b21448fc4cb Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 3 Dec 2018 17:59:59 +0100
Subject: [PATCH 06/49] fix CloseAsync

---
 .../Http/GraphQLHttpObservableSubscription.cs | 10 ++-
 .../ObservableTester.cs                       | 26 +++----
 .../SubscriptionsTest.cs                      | 69 ++++++++++++++-----
 3 files changed, 73 insertions(+), 32 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index d3f71990..fa77239c 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -67,6 +67,12 @@ public async Task<GraphQLResponse> ReceiveResultAsync()
 
 		public async Task CloseAsync(CancellationToken cancellationToken = default)
 		{
+			// don't attempt to close the websocket if it is in a failed state
+			if (this.clientWebSocket.State != WebSocketState.Open &&
+			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
+			    this.clientWebSocket.State != WebSocketState.CloseSent)
+				return;
+
 			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
 			if (this.clientWebSocket.State == WebSocketState.Open) {
 				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
@@ -135,7 +141,9 @@ public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUr
 			return Observable.Using(
 				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
 				InitializeSubscription
-				).Publish().RefCount();
+				)
+				.Catch<GraphQLResponse, OperationCanceledException>(exception => Observable.Empty<GraphQLResponse>())
+				.Publish().RefCount();
 		}
 
 
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index e7993a36..7bcf8522 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -20,7 +20,7 @@ public class ObservableTester<T> : IDisposable
 		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
 
 		/// <summary>
-		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// Indicates that an update has been received since the last <see cref="_reset"/>
 		/// </summary>
 		public bool UpdateReceived => _updateReceived.IsSet;
 		/// <summary>
@@ -51,7 +51,7 @@ public ObservableTester(IObservable<T> observable)
 		}
 
 		/// <summary>
-		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>.
 		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
 		/// </summary>
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
@@ -66,12 +66,12 @@ public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
 		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
@@ -83,12 +83,12 @@ public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		public void ShouldHaveCompleted()
 		{
@@ -99,12 +99,12 @@ public void ShouldHaveCompleted()
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		public void ShouldHaveThrownError(Action<Exception> assertError = null)
 		{
@@ -117,18 +117,18 @@ public void ShouldHaveThrownError(Action<Exception> assertError = null)
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
 		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
-		public void Reset()
+		private void _reset()
 		{
-			if (_completed.IsSet)
-				throw new InvalidOperationException(
-					"the subscription sequence has completed. this tester instance cannot be reused");
+			//if (_completed.IsSet)
+			//	throw new InvalidOperationException(
+			//		"the subscription sequence has completed. this tester instance cannot be reused");
 
 			LastPayload = default(T);
 			_updateReceived.Reset();
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index f8a66760..3b404f23 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -57,6 +57,17 @@ public async void AssertTestingHarness()
 			}
 		}
 
+		private const string SubscriptionQuery = @"
+			subscription {
+			  messageAdded{
+			    content
+			  }
+			}";
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
+		{
+			Query = SubscriptionQuery
+		};
+
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
@@ -64,18 +75,8 @@ public async void CanCreateObservableSubscription()
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
-				var graphQLRequest = new GraphQLRequest
-				{
-					Query = @"
-					subscription {
-					  messageAdded{
-					    content
-					  }
-					}"
-				};
-
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -89,8 +90,6 @@ public async void CanCreateObservableSubscription()
 					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				tester.Reset();
-
 				const string message2 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
 				Assert.Equal(message2, (string)response.Data.addMessage.content);
@@ -99,15 +98,49 @@ public async void CanCreateObservableSubscription()
 					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				tester.Reset();
-
 				// disposing the client should throw a TaskCanceledException on the subscription
 				client.Dispose();
-				tester.ShouldHaveThrownError(exception =>
+				tester.ShouldHaveCompleted();
+			}
+		}
+
+		[Fact]
+		public async void CanReconnectWithSameObservable()
+		{
+			var port = 5003;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+				const string message1 = "Hello World";
+
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+				Debug.WriteLine("disposing subscription...");
+				tester.Dispose();
+
+				Debug.WriteLine("creating new subscription...");
+				tester = observable.SubscribeTester();
+				const string message2 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.True(exception is TaskCanceledException,
-							$"exception is of unexpected type {exception.GetType().Name}");
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester.ShouldHaveCompleted();
 			}
 		}
 	}

From af78196058c8511aaa3617fecee80e7e5069a378 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 3 Dec 2018 18:01:01 +0100
Subject: [PATCH 07/49] lock dispose

---
 .../Http/GraphQLHttpObservableSubscription.cs          | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index fa77239c..04adb611 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -112,15 +112,17 @@ private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSu
 		}
 
 		#region IDisposable
-
+		public Task Disposed { get; private set; }
+		private object _disposedLocker = new object();
 		public void Dispose()
 		{
 			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-			if(Disposed == null) Disposed = DisposeAsync();
+			lock (_disposedLocker)
+			{
+				if (Disposed == null) Disposed = DisposeAsync();
+			}
 		}
 
-		public Task Disposed { get; private set; }
-
 		private async Task DisposeAsync()
 		{
 			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");

From 43cb3ddb04a63f2c117e7dec7553f9a966f686bf Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 09:36:46 +0100
Subject: [PATCH 08/49] implement external exception handling for subscription
 streams

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 23 ++++++++
 .../Http/GraphQLHttpObservableSubscription.cs | 53 ++++++++++++++++---
 src/GraphQL.Client/IGraphQLClient.cs          | 34 ++++++++++++
 3 files changed, 104 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index cfc966b7..4de48c2f 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -140,6 +141,7 @@ private Uri _getWebSocketUri()
 			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
 		}
 
+		/// <inheritdoc />
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
@@ -147,6 +149,27 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			return observable;
 		}
 
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+		{
+			return CreateSubscriptionStream(request, e =>
+			{
+				if (e is WebSocketException webSocketException)
+					webSocketExceptionHandler(webSocketException);
+				else
+					throw e;
+			});
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
+		{
+			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token, exceptionHandler);
+			return observable;
+		}
+
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index 04adb611..f742b698 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -138,17 +138,58 @@ private async Task DisposeAsync()
 
 		#region Static Factories
 
-		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
+		public static IObservable<GraphQLResponse> GetSubscriptionStream(
+			Uri webSocketUri,
+			GraphQLRequest graphQLRequest,
+			CancellationToken cancellationToken = default,
+			Action<Exception> onException = null)
 		{
-			return Observable.Using(
-				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
-				InitializeSubscription
-				)
+			return Observable
+				// create deferred observable using a GraphQLHttpObservableSubscription instance
+				.Defer(
+					() =>
+						Observable.Using(
+							token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
+							InitializeSubscription
+				))
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 				.Catch<GraphQLResponse, OperationCanceledException>(exception => Observable.Empty<GraphQLResponse>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+				{
+					try
+					{
+						// if the external handler is not set, propagate all exceptions (default behaviour without Retry())
+						if (onException == null) throw e;
+
+						// invoke external handler
+						// exceptions thrown by the handler will propagate to OnError()
+						onException(e);
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						return cancellationToken.IsCancellationRequested
+							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
+							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
+					}
+					catch (Exception exception)
+					{
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the subscription stream for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t =>
+					t.Item2 == null
+						? Observable.Return(t.Item1)
+						: Observable.Throw<GraphQLResponse>(t.Item2))
+				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
 
-
 		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
 		{
 			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 3343da14..60af36ab 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Common.Request;
@@ -36,8 +37,41 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
 
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// The stream must be recreated completely after an error has occured within its logic (i.e. a <see cref="WebSocketException"/>)
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }

From f1deb7f01a0347c01e5886c0f81e4ce71034608b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 09:40:42 +0100
Subject: [PATCH 09/49] fix doc comment

---
 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index f742b698..77397fb8 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -161,7 +161,7 @@ public static IObservable<GraphQLResponse> GetSubscriptionStream(
 				{
 					try
 					{
-						// if the external handler is not set, propagate all exceptions (default behaviour without Retry())
+						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
 						if (onException == null) throw e;
 
 						// invoke external handler

From 1a28d69b640cfa7c11ed4ec0741bbf5563259572 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 10:37:08 +0100
Subject: [PATCH 10/49] add back-off delay for automatic reconnects

---
 root.props                                    |  2 +-
 .../Http/GraphQLHttpObservableSubscription.cs | 35 +++++++++++++++----
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/root.props b/root.props
index 32db78cf..d6d65e56 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.4</Version>
+		<Version>2.0.0-alpha.subscriptions-api.6</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index 77397fb8..70b307fd 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -144,14 +144,21 @@ public static IObservable<GraphQLResponse> GetSubscriptionStream(
 			CancellationToken cancellationToken = default,
 			Action<Exception> onException = null)
 		{
+			int reconnectionAttempt = 0;
+
 			return Observable
 				// create deferred observable using a GraphQLHttpObservableSubscription instance
 				.Defer(
 					() =>
-						Observable.Using(
+					{
+						var observable = Observable.Using(
 							token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
-							InitializeSubscription
-				))
+							InitializeSubscription);
+
+						// when reconnecting, apply the delay computed by the BackOffStrategy
+						return (++reconnectionAttempt == 1) ? observable : observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1)) ;
+					}
+				)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 				.Catch<GraphQLResponse, OperationCanceledException>(exception => Observable.Empty<GraphQLResponse>())
 				// wrap results
@@ -183,13 +190,29 @@ public static IObservable<GraphQLResponse> GetSubscriptionStream(
 				.Retry()
 				// unwrap and push results or throw wrapped exceptions
 				.SelectMany(t =>
-					t.Item2 == null
-						? Observable.Return(t.Item1)
-						: Observable.Throw<GraphQLResponse>(t.Item2))
+				{
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLResponse>(t.Item2);
+
+					// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
+					reconnectionAttempt = 1;
+					return Observable.Return(t.Item1);
+				})
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
 
+		/// <summary>
+		/// The back-off strategy for automatic reconnects. Calculates the delay before the next connection attempt is made.<br/>
+		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+		/// </summary>
+		public static Func<int, TimeSpan> BackOffStrategy = n =>
+		{
+			var rnd = new Random();
+			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+		};
+
 		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
 		{
 			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);

From 7b19ab57a3dd0d218c6d759959357e14574a32a5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 15:16:28 +0100
Subject: [PATCH 11/49] create GraphQLHttpWebSocket class

---
 root.props                                    |   2 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |   4 +
 .../Http/GraphQLHttpObservableSubscription.cs |  98 +--------
 .../Http/GraphQLHttpSubscriptionResult.cs     |  98 +--------
 .../Http/GraphQLHttpWebSocket.cs              | 192 ++++++++++++++++++
 src/GraphQL.Common/GQLWebSocketMessageType.cs |  93 +++++++++
 ...nRequest.cs => GraphQLWebSocketRequest.cs} |  10 +-
 ...esponse.cs => GraphQLWebSocketResponse.cs} |  10 +-
 8 files changed, 313 insertions(+), 194 deletions(-)
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
 create mode 100644 src/GraphQL.Common/GQLWebSocketMessageType.cs
 rename src/GraphQL.Common/Request/{GraphQLSubscriptionRequest.cs => GraphQLWebSocketRequest.cs} (73%)
 rename src/GraphQL.Common/Response/{GraphQLSubscriptionResponse.cs => GraphQLWebSocketResponse.cs} (72%)

diff --git a/root.props b/root.props
index d6d65e56..20595010 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.6</Version>
+		<Version>2.0.0-alpha.subscriptions-api.7</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 4de48c2f..fb1982fb 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -41,6 +41,7 @@ public GraphQLHttpClientOptions Options {
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
+		internal readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		/// <summary>
@@ -76,6 +77,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
 		}
 
 		/// <summary>
@@ -90,6 +92,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
 		}
 
 		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
@@ -100,6 +103,7 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index 70b307fd..d4d5678a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -7,6 +7,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
@@ -33,6 +34,7 @@ private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graph
 			this.webSocketUri = webSocketUri;
 			this.graphQLRequest = graphQLRequest;
 			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+
 			arraySegment = new ArraySegment<byte>(buffer);
 		}
 
@@ -47,7 +49,7 @@ public async Task<GraphQLResponse> ReceiveResultAsync()
 		{
 			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
 			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 			switch (webSocketResponse.Type)
 			{
 				case GQLWebSocketMessageType.GQL_COMPLETE:
@@ -83,7 +85,7 @@ public async Task CloseAsync(CancellationToken cancellationToken = default)
 		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
 		{
 			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLSubscriptionRequest
+			var webSocketRequest = new GraphQLWebSocketRequest
 			{
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_START,
@@ -95,7 +97,7 @@ private Task SendInitialMessageAsync(CancellationToken cancellationToken = defau
 		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
 		{
 			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLSubscriptionRequest
+			var webSocketRequest = new GraphQLWebSocketRequest
 			{
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_STOP,
@@ -104,9 +106,9 @@ private Task SendCloseMessageAsync(CancellationToken cancellationToken = default
 			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
 		}
 
-		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default)
+		private Task SendGraphQLSubscriptionRequest(GraphQLWebSocketRequest graphQlWebSocketRequest, CancellationToken cancellationToken = default)
 		{
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQlWebSocketRequest);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
 			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
 		}
@@ -252,91 +254,5 @@ protected GQLSubscriptionException(
 			{
 			}
 		}
-
-		public static class GQLWebSocketMessageType
-		{
-
-			/// <summary>
-			///     Client sends this message after plain websocket connection to start the communication with the server
-			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-			///     to this message.
-			///     payload: Object : optional parameters that the client specifies in connectionParams
-			/// </summary>
-			public const string GQL_CONNECTION_INIT = "connection_init";
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-			///     the connection.
-			/// </summary>
-			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-			///     the connection.
-			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-			///     client, just ignore the message).
-			///     payload: Object: the server side error
-			/// </summary>
-			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
-
-			/// <summary>
-			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-			///     client connection alive.
-			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-			///     server.
-			///     <remarks>
-			///         NOTE: This one here don't follow the standard due to connection optimization
-			///     </remarks>
-			/// </summary>
-			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
-
-			/// <summary>
-			///     Client sends this message to execute GraphQL operation
-			///     id: string : The id of the GraphQL operation to start
-			///     payload: Object:
-			///     query: string : GraphQL operation as string or parsed GraphQL document node
-			///     variables?: Object : Object with GraphQL variables
-			///     operationName?: string : GraphQL operation name
-			/// </summary>
-			public const string GQL_START = "start";
-
-			/// <summary>
-			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-			///     is a response for GQL_START message.
-			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-			///     id: string : ID of the operation that was successfully set up
-			///     payload: Object :
-			///     data: any: Execution result
-			///     errors?: Error[] : Array of resolvers errors
-			/// </summary>
-			public const string GQL_DATA = "data"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-			///     payload: Error : payload with the error attributed to the operation failing on the server
-			///     id: string : operation ID of the operation that failed on the server
-			/// </summary>
-			public const string GQL_ERROR = "error"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-			///     specific operation.
-			///     id: string : operation ID of the operation that completed
-			/// </summary>
-			public const string GQL_COMPLETE = "complete"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_STOP = "stop"; // Client -> Server
-		}
 	}
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
index e0c2dc6d..34ab6f0a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
@@ -3,6 +3,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
@@ -38,7 +39,7 @@ public async void StartAsync(CancellationToken cancellationToken = default) {
 				while (this.clientWebSocket.State == WebSocketState.Open) {
 					var webSocketReceiveResult = await this.clientWebSocket.ReceiveAsync(arraySegment, cancellationToken);
 					var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 					if (webSocketResponse != null)
 					{
 						var response = (GraphQLResponse) webSocketResponse.Payload;
@@ -62,7 +63,7 @@ public void Dispose() {
 		}
 
 		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLSubscriptionRequest {
+			var webSocketRequest = new GraphQLWebSocketRequest {
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_START,
 				Payload = this.graphQLRequest
@@ -71,7 +72,7 @@ private Task SendInitialMessageAsync(CancellationToken cancellationToken = defau
 		}
 
 		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLSubscriptionRequest {
+			var webSocketRequest = new GraphQLWebSocketRequest {
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_STOP,
 				Payload = this.graphQLRequest
@@ -79,98 +80,11 @@ private Task SendCloseMessageAsync(CancellationToken cancellationToken = default
 			return this.SendGraphQLSubscriptionRequest(webSocketRequest);
 		}
 
-		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default) {
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+		private Task SendGraphQLSubscriptionRequest(GraphQLWebSocketRequest graphQlWebSocketRequest, CancellationToken cancellationToken = default) {
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQlWebSocketRequest);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
 			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
 		}
-
-		private static class GQLWebSocketMessageType {
-
-			/// <summary>
-			///     Client sends this message after plain websocket connection to start the communication with the server
-			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-			///     to this message.
-			///     payload: Object : optional parameters that the client specifies in connectionParams
-			/// </summary>
-			public const string GQL_CONNECTION_INIT = "connection_init";
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-			///     the connection.
-			/// </summary>
-			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-			///     the connection.
-			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-			///     client, just ignore the message).
-			///     payload: Object: the server side error
-			/// </summary>
-			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
-
-			/// <summary>
-			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-			///     client connection alive.
-			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-			///     server.
-			///     <remarks>
-			///         NOTE: This one here don't follow the standard due to connection optimization
-			///     </remarks>
-			/// </summary>
-			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
-
-			/// <summary>
-			///     Client sends this message to execute GraphQL operation
-			///     id: string : The id of the GraphQL operation to start
-			///     payload: Object:
-			///     query: string : GraphQL operation as string or parsed GraphQL document node
-			///     variables?: Object : Object with GraphQL variables
-			///     operationName?: string : GraphQL operation name
-			/// </summary>
-			public const string GQL_START = "start";
-
-			/// <summary>
-			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-			///     is a response for GQL_START message.
-			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-			///     id: string : ID of the operation that was successfully set up
-			///     payload: Object :
-			///     data: any: Execution result
-			///     errors?: Error[] : Array of resolvers errors
-			/// </summary>
-			public const string GQL_DATA = "data"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-			///     payload: Error : payload with the error attributed to the operation failing on the server
-			///     id: string : operation ID of the operation that failed on the server
-			/// </summary>
-			public const string GQL_ERROR = "error"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-			///     specific operation.
-			///     id: string : operation ID of the operation that completed
-			/// </summary>
-			public const string GQL_COMPLETE = "complete"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_STOP = "stop"; // Client -> Server
-
-		}
-
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
new file mode 100644
index 00000000..b307487b
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -0,0 +1,192 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Reactive.Threading.Tasks;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Http
+{
+	internal class GraphQLHttpWebSocket: IDisposable
+	{
+		private readonly Uri webSocketUri;
+		private readonly byte[] buffer = new byte[1024 * 1024];
+		private readonly ArraySegment<byte> arraySegment;
+		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+
+		private ClientWebSocket clientWebSocket = null;
+
+		public GraphQLHttpWebSocket(Uri webSocketUri)
+		{
+			this.webSocketUri = webSocketUri;
+			arraySegment = new ArraySegment<byte>(buffer);
+		}
+
+		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		{
+			if (clientWebSocket == null)
+			{
+				throw new InvalidOperationException("websocket not connected! subscribe to the response stream before sending a request!");
+			}
+			var webSocketRequestString = JsonConvert.SerializeObject(request);
+			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
+		}
+
+		public IObservable<GraphQLWebSocketResponse> ResponseStream
+		{
+			get
+			{
+				int reconnectionAttempt = 0;
+
+				return Observable
+					// create deferred observable using a GraphQLHttpObservableSubscription instance
+					.Defer(
+						() =>
+						{
+							var observable = Observable.Using(
+								token => _createClientWebsocket(),
+								(_, cancellationToken) => _initializeWebSocketConnection(cancellationToken));
+
+							// when reconnecting, apply the delay computed by the BackOffStrategy
+							return (++reconnectionAttempt == 1)
+								? observable
+								: observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1));
+						}
+					)
+					// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+					.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
+						Observable.Empty<GraphQLWebSocketResponse>())
+					// wrap results
+					.Select(response => new Tuple<GraphQLWebSocketResponse, Exception>(response, null))
+					// do exception handling
+					.Catch<Tuple<GraphQLWebSocketResponse, Exception>, Exception>(e =>
+					{
+						try
+						{
+							// exceptions thrown by the handler will propagate to OnError()
+							_handleExceptions(e);
+
+							// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+							return _cancellationTokenSource.Token.IsCancellationRequested
+								? Observable.Empty<Tuple<GraphQLWebSocketResponse, Exception>>()
+								: Observable.Throw<Tuple<GraphQLWebSocketResponse, Exception>>(e);
+						}
+						catch (Exception exception)
+						{
+							// wrap all other exceptions to be propagated behind retry
+							return Observable.Return(new Tuple<GraphQLWebSocketResponse, Exception>(null, exception));
+						}
+					})
+					// attempt to recreate the subscription stream for rethrown exceptions
+					.Retry()
+					// unwrap and push results or throw wrapped exceptions
+					.SelectMany(t =>
+					{
+						// if the result contains an exception, throw it on the observable
+						if (t.Item2 != null)
+							return Observable.Throw<GraphQLWebSocketResponse>(t.Item2);
+
+						// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
+						reconnectionAttempt = 1;
+						return Observable.Return(t.Item1);
+					})
+					// transform to hot observable and auto-connect
+					.Publish().RefCount();
+			}
+		}
+
+		/// <summary>
+		/// The back-off strategy for automatic reconnects. Calculates the delay before the next connection attempt is made.<br/>
+		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+		/// </summary>
+		public static Func<int, TimeSpan> BackOffStrategy = n =>
+		{
+			var rnd = new Random();
+			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+		};
+
+		#region Private Methods
+
+		private void _handleExceptions(Exception e)
+		{
+
+		}
+
+		private Task<IDisposable> _createClientWebsocket()
+		{
+			clientWebSocket = new ClientWebSocket();
+			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+
+			return Task.FromResult(Disposable.Create(() => clientWebSocket?.Dispose()));
+		}
+
+		private async Task<IObservable<GraphQLWebSocketResponse>> _initializeWebSocketConnection(CancellationToken cancelToken)
+		{
+			await _connectAsync(cancelToken).ConfigureAwait(false);
+			return Observable.Defer(() => _receiveResultAsync().ToObservable()).Repeat();
+		}
+
+		private async Task _connectAsync(CancellationToken token)
+		{
+			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
+			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
+		}
+
+		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
+		{
+			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
+			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+			return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+		}
+
+		private async Task _closeAsync(CancellationToken cancellationToken = default)
+		{
+			// don't attempt to close the websocket if it is in a failed state
+			if (this.clientWebSocket.State != WebSocketState.Open &&
+			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
+			    this.clientWebSocket.State != WebSocketState.CloseSent)
+				return;
+
+			Debug.WriteLine($"closing websocket {this.GetHashCode()}");
+			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
+		}
+
+		#endregion
+
+		#region IDisposable
+
+		private Task Disposed { get; set; }
+		private object _disposedLocker = new object();
+		public void Dispose()
+		{
+			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+			lock (_disposedLocker)
+			{
+				if (Disposed == null) Disposed = DisposeAsync();
+			}
+		}
+
+		private async Task DisposeAsync()
+		{
+			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
+			if (!_cancellationTokenSource.IsCancellationRequested)
+				_cancellationTokenSource.Cancel();
+			await _closeAsync().ConfigureAwait(false);
+			clientWebSocket?.Dispose();
+			_cancellationTokenSource.Dispose();
+			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
+		}
+		#endregion
+	}
+}
diff --git a/src/GraphQL.Common/GQLWebSocketMessageType.cs b/src/GraphQL.Common/GQLWebSocketMessageType.cs
new file mode 100644
index 00000000..1e2fff76
--- /dev/null
+++ b/src/GraphQL.Common/GQLWebSocketMessageType.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL.Common
+{
+	public static class GQLWebSocketMessageType
+	{
+
+		/// <summary>
+		///     Client sends this message after plain websocket connection to start the communication with the server
+		///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+		///     to this message.
+		///     payload: Object : optional parameters that the client specifies in connectionParams
+		/// </summary>
+		public const string GQL_CONNECTION_INIT = "connection_init";
+
+		/// <summary>
+		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+		///     the connection.
+		/// </summary>
+		public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+
+		/// <summary>
+		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+		///     the connection.
+		///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+		///     client, just ignore the message).
+		///     payload: Object: the server side error
+		/// </summary>
+		public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+
+		/// <summary>
+		///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+		///     client connection alive.
+		///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+		///     server.
+		///     <remarks>
+		///         NOTE: This one here don't follow the standard due to connection optimization
+		///     </remarks>
+		/// </summary>
+		public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+
+		/// <summary>
+		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+		///     id: string : operation id
+		/// </summary>
+		public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+
+		/// <summary>
+		///     Client sends this message to execute GraphQL operation
+		///     id: string : The id of the GraphQL operation to start
+		///     payload: Object:
+		///     query: string : GraphQL operation as string or parsed GraphQL document node
+		///     variables?: Object : Object with GraphQL variables
+		///     operationName?: string : GraphQL operation name
+		/// </summary>
+		public const string GQL_START = "start";
+
+		/// <summary>
+		///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+		///     is a response for GQL_START message.
+		///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+		///     id: string : ID of the operation that was successfully set up
+		///     payload: Object :
+		///     data: any: Execution result
+		///     errors?: Error[] : Array of resolvers errors
+		/// </summary>
+		public const string GQL_DATA = "data"; // Server -> Client
+
+		/// <summary>
+		///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+		///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+		///     payload: Error : payload with the error attributed to the operation failing on the server
+		///     id: string : operation ID of the operation that failed on the server
+		/// </summary>
+		public const string GQL_ERROR = "error"; // Server -> Client
+
+		/// <summary>
+		///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+		///     specific operation.
+		///     id: string : operation ID of the operation that completed
+		/// </summary>
+		public const string GQL_COMPLETE = "complete"; // Server -> Client
+
+		/// <summary>
+		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+		///     id: string : operation id
+		/// </summary>
+		public const string GQL_STOP = "stop"; // Client -> Server
+
+	}
+}
diff --git a/src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
similarity index 73%
rename from src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs
rename to src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
index a468a0b3..46e14dce 100644
--- a/src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Common.Request {
 	/// A Subscription Request
 	/// </summary>
 	[Obsolete("EXPERIMENTAL")]
-	public class GraphQLSubscriptionRequest : IEquatable<GraphQLSubscriptionRequest> {
+	public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 
 		/// <summary>
 		/// The Identifier of the Response
@@ -25,10 +25,10 @@ public class GraphQLSubscriptionRequest : IEquatable<GraphQLSubscriptionRequest>
 		public GraphQLRequest Payload { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionRequest);
+		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLSubscriptionRequest other) {
+		public bool Equals(GraphQLWebSocketRequest other) {
 			if (other == null) {
 				return false;
 			}
@@ -57,10 +57,10 @@ public override int GetHashCode() {
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLSubscriptionRequest request1, GraphQLSubscriptionRequest request2) => EqualityComparer<GraphQLSubscriptionRequest>.Default.Equals(request1, request2);
+		public static bool operator ==(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => EqualityComparer<GraphQLWebSocketRequest>.Default.Equals(request1, request2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLSubscriptionRequest request1, GraphQLSubscriptionRequest request2) => !(request1 == request2);
+		public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
 
 	}
 
diff --git a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs b/src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
similarity index 72%
rename from src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
rename to src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
index 71c47c72..cd3fb2f4 100644
--- a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
+++ b/src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Common.Response {
 	/// A Subscription Response
 	/// </summary>
 	[Obsolete("EXPERIMENTAL")]
-	public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionResponse> {
+	public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse> {
 
 		/// <summary>
 		/// The Identifier of the Response
@@ -25,10 +25,10 @@ public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionRespons
 		public dynamic Payload { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionResponse);
+		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketResponse);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLSubscriptionResponse other) {
+		public bool Equals(GraphQLWebSocketResponse other) {
 			if (other == null) {
 				return false;
 			}
@@ -57,10 +57,10 @@ public override int GetHashCode() {
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLSubscriptionResponse response1, GraphQLSubscriptionResponse response2) => EqualityComparer<GraphQLSubscriptionResponse>.Default.Equals(response1, response2);
+		public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLSubscriptionResponse response1, GraphQLSubscriptionResponse response2) => !(response1 == response2);
+		public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => !(response1 == response2);
 
 	}
 

From ad2c31f9ba1adcde35a10c87c345eaa6d4b2e8a9 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 18:19:40 +0100
Subject: [PATCH 12/49] get single socket working

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  43 ++--
 .../Http/GraphQLHttpObservableSubscription.cs | 112 +++++-----
 .../Http/GraphQLHttpWebSocket.cs              | 194 ++++++++++--------
 src/GraphQL.Client/IGraphQLClient.cs          |  48 ++---
 .../ObservableTester.cs                       |  23 ++-
 .../SubscriptionsTest.cs                      |   9 +-
 6 files changed, 225 insertions(+), 204 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index fb1982fb..67fd0661 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -149,30 +149,30 @@ private Uri _getWebSocketUri()
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token);
+			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(graphQlHttpWebSocket, request);
 			return observable;
 		}
 
-		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
-		{
-			return CreateSubscriptionStream(request, e =>
-			{
-				if (e is WebSocketException webSocketException)
-					webSocketExceptionHandler(webSocketException);
-				else
-					throw e;
-			});
-		}
-
-		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
-		{
-			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token, exceptionHandler);
-			return observable;
-		}
+		///// <inheritdoc />
+		//[Obsolete("EXPERIMENTAL API")]
+		//public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+		//{
+		//	return CreateSubscriptionStream(request, e =>
+		//	{
+		//		if (e is WebSocketException webSocketException)
+		//			webSocketExceptionHandler(webSocketException);
+		//		else
+		//			throw e;
+		//	});
+		//}
+
+		///// <inheritdoc />
+		//[Obsolete("EXPERIMENTAL API")]
+		//public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
+		//{
+		//	var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(graphQlHttpWebSocket, request, _cancellationTokenSource.Token, exceptionHandler);
+		//	return observable;
+		//}
 
 		/// <summary>
 		/// Releases unmanaged resources
@@ -180,6 +180,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		public void Dispose()
 		{
 			this.graphQLHttpHandler.Dispose();
+			this.graphQlHttpWebSocket.Dispose();
 			_cancellationTokenSource.Cancel();
 			_cancellationTokenSource.Dispose();
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index d4d5678a..128f316c 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
 using System.Runtime.Serialization;
@@ -140,69 +141,64 @@ private async Task DisposeAsync()
 
 		#region Static Factories
 
-		public static IObservable<GraphQLResponse> GetSubscriptionStream(
-			Uri webSocketUri,
-			GraphQLRequest graphQLRequest,
-			CancellationToken cancellationToken = default,
-			Action<Exception> onException = null)
+		internal static IObservable<GraphQLResponse> GetSubscriptionStream(
+			GraphQLHttpWebSocket webSocket,
+			GraphQLRequest graphQLRequest)
 		{
-			int reconnectionAttempt = 0;
-
-			return Observable
-				// create deferred observable using a GraphQLHttpObservableSubscription instance
-				.Defer(
-					() =>
-					{
-						var observable = Observable.Using(
-							token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
-							InitializeSubscription);
-
-						// when reconnecting, apply the delay computed by the BackOffStrategy
-						return (++reconnectionAttempt == 1) ? observable : observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1)) ;
-					}
-				)
-				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-				.Catch<GraphQLResponse, OperationCanceledException>(exception => Observable.Empty<GraphQLResponse>())
-				// wrap results
-				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
-				// do exception handling
-				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse>(async observer =>
 				{
-					try
+					var startRequest = new GraphQLWebSocketRequest
 					{
-						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
-						if (onException == null) throw e;
-
-						// invoke external handler
-						// exceptions thrown by the handler will propagate to OnError()
-						onException(e);
-
-						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-						return cancellationToken.IsCancellationRequested
-							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
-							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
-					}
-					catch (Exception exception)
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = graphQLRequest
+					};
+					var closeRequest = new GraphQLWebSocketRequest
 					{
-						// wrap all other exceptions to be propagated behind retry
-						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
-					}
-				})
-				// attempt to recreate the subscription stream for rethrown exceptions
-				.Retry()
-				// unwrap and push results or throw wrapped exceptions
-				.SelectMany(t =>
-				{
-					// if the result contains an exception, throw it on the observable
-					if (t.Item2 != null)
-						return Observable.Throw<GraphQLResponse>(t.Item2);
-
-					// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
-					reconnectionAttempt = 1;
-					return Observable.Return(t.Item1);
+						Id = startRequest.Id,
+						Type = GQLWebSocketMessageType.GQL_STOP
+					};
+
+					var disposable = new CompositeDisposable(
+						Disposable.Create(async () =>
+						{
+							Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+							await webSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+						}),
+						// subscribe to result stream
+						webSocket.ResponseStream
+							.Where(response => response.Id == startRequest.Id)
+							.SelectMany(response =>
+							{
+								switch (response.Type)
+								{
+									case GQLWebSocketMessageType.GQL_COMPLETE:
+										Debug.WriteLine(
+											$"received 'complete' message on subscription {startRequest.Id}");
+										return Observable.Empty<GraphQLResponse>();
+									case GQLWebSocketMessageType.GQL_ERROR:
+										Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
+										return Observable.Throw<GraphQLResponse>(
+											new GQLSubscriptionException(response.Payload));
+									default:
+										Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+										return Observable.Return(((JObject) response?.Payload)
+											?.ToObject<GraphQLResponse>());
+								}
+							})
+							.Subscribe(observer)
+					);
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					await webSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+
+					return disposable;
 				})
-				// transform to hot observable and auto-connect
-				.Publish().RefCount();
+			)
+			// transform to hot observable and auto-connect
+			.Publish().RefCount();
 		}
 
 		/// <summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index b307487b..43e41c3a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -3,16 +3,13 @@
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
-using System.Reactive.Subjects;
 using System.Reactive.Threading.Tasks;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http
 {
@@ -22,6 +19,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
 
 		private ClientWebSocket clientWebSocket = null;
 
@@ -29,80 +27,15 @@ public GraphQLHttpWebSocket(Uri webSocketUri)
 		{
 			this.webSocketUri = webSocketUri;
 			arraySegment = new ArraySegment<byte>(buffer);
+			ResponseStream = _createResponseStream();
 		}
 
-		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
-			if (clientWebSocket == null)
-			{
-				throw new InvalidOperationException("websocket not connected! subscribe to the response stream before sending a request!");
-			}
+			await _initializeWebSocket().ConfigureAwait(false);
 			var webSocketRequestString = JsonConvert.SerializeObject(request);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
-		}
-
-		public IObservable<GraphQLWebSocketResponse> ResponseStream
-		{
-			get
-			{
-				int reconnectionAttempt = 0;
-
-				return Observable
-					// create deferred observable using a GraphQLHttpObservableSubscription instance
-					.Defer(
-						() =>
-						{
-							var observable = Observable.Using(
-								token => _createClientWebsocket(),
-								(_, cancellationToken) => _initializeWebSocketConnection(cancellationToken));
-
-							// when reconnecting, apply the delay computed by the BackOffStrategy
-							return (++reconnectionAttempt == 1)
-								? observable
-								: observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1));
-						}
-					)
-					// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-					.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-						Observable.Empty<GraphQLWebSocketResponse>())
-					// wrap results
-					.Select(response => new Tuple<GraphQLWebSocketResponse, Exception>(response, null))
-					// do exception handling
-					.Catch<Tuple<GraphQLWebSocketResponse, Exception>, Exception>(e =>
-					{
-						try
-						{
-							// exceptions thrown by the handler will propagate to OnError()
-							_handleExceptions(e);
-
-							// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-							return _cancellationTokenSource.Token.IsCancellationRequested
-								? Observable.Empty<Tuple<GraphQLWebSocketResponse, Exception>>()
-								: Observable.Throw<Tuple<GraphQLWebSocketResponse, Exception>>(e);
-						}
-						catch (Exception exception)
-						{
-							// wrap all other exceptions to be propagated behind retry
-							return Observable.Return(new Tuple<GraphQLWebSocketResponse, Exception>(null, exception));
-						}
-					})
-					// attempt to recreate the subscription stream for rethrown exceptions
-					.Retry()
-					// unwrap and push results or throw wrapped exceptions
-					.SelectMany(t =>
-					{
-						// if the result contains an exception, throw it on the observable
-						if (t.Item2 != null)
-							return Observable.Throw<GraphQLWebSocketResponse>(t.Item2);
-
-						// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
-						reconnectionAttempt = 1;
-						return Observable.Return(t.Item1);
-					})
-					// transform to hot observable and auto-connect
-					.Publish().RefCount();
-			}
+			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
 		}
 
 		/// <summary>
@@ -117,46 +50,135 @@ public IObservable<GraphQLWebSocketResponse> ResponseStream
 
 		#region Private Methods
 
+		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		{
+			int reconnectionAttempt = 0;
+
+			return Observable.Create<GraphQLWebSocketResponse>(observer =>
+				{
+					var observable = _getReceiveResultStream().GetAwaiter().GetResult();
+					// when reconnecting, apply the delay computed by the BackOffStrategy
+					observable = (++reconnectionAttempt == 1)
+						? observable
+						: observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1));
+					return observable.Subscribe(observer);
+				})
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLWebSocketResponse>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLWebSocketResponse, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLWebSocketResponse, Exception>, Exception>(e =>
+				{
+					try
+					{
+						// exceptions thrown by the handler will propagate to OnError()
+						_handleExceptions(e);
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						return _cancellationTokenSource.Token.IsCancellationRequested
+							? Observable.Empty<Tuple<GraphQLWebSocketResponse, Exception>>()
+							: Observable.Throw<Tuple<GraphQLWebSocketResponse, Exception>>(e);
+					}
+					catch (Exception exception)
+					{
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLWebSocketResponse, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the subscription stream for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t =>
+				{
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLWebSocketResponse>(t.Item2);
+
+					// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
+					reconnectionAttempt = 1;
+
+					return t.Item1 == null
+						? Observable.Empty<GraphQLWebSocketResponse>()
+						: Observable.Return(t.Item1);
+				})
+				// transform to hot observable and auto-connect
+				.Publish().RefCount();
+		}
+
 		private void _handleExceptions(Exception e)
 		{
 
 		}
 
-		private Task<IDisposable> _createClientWebsocket()
+		private Task _initializeWebSocketTask;
+		private Task _initializeWebSocket()
 		{
+			// do not attempt to initialize if cancellation is requested
+			if(_disposed != null)
+				throw new OperationCanceledException();
+
+			// if an initialization task is already running, return that
+			if(_initializeWebSocketTask != null &&
+			   !_initializeWebSocketTask.IsFaulted &&
+			   !_initializeWebSocketTask.IsCompleted)
+				return _initializeWebSocketTask;
+
+			// if the websocket is open, return a completed task
+			if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
+				return Task.CompletedTask;
+
+			// else (re-)create websocket and connect
+			clientWebSocket?.Dispose();
 			clientWebSocket = new ClientWebSocket();
 			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-
-			return Task.FromResult(Disposable.Create(() => clientWebSocket?.Dispose()));
+			return _initializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 		}
 
-		private async Task<IObservable<GraphQLWebSocketResponse>> _initializeWebSocketConnection(CancellationToken cancelToken)
+		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
 		{
-			await _connectAsync(cancelToken).ConfigureAwait(false);
+			await _initializeWebSocket().ConfigureAwait(false);
 			return Observable.Defer(() => _receiveResultAsync().ToObservable()).Repeat();
 		}
 
 		private async Task _connectAsync(CancellationToken token)
 		{
-			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
+			Debug.WriteLine($"opening websocket {this.GetHashCode()}");
 			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
+			Debug.WriteLine($"connection established on websocket {this.GetHashCode()}");
 		}
 
 		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
-			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
-			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-			return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+			try
+			{
+				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+				var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
+				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+				throw;
+			}
 		}
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)
 		{
+			if(clientWebSocket == null)
+				return;
+
 			// don't attempt to close the websocket if it is in a failed state
 			if (this.clientWebSocket.State != WebSocketState.Open &&
 			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
 			    this.clientWebSocket.State != WebSocketState.CloseSent)
+			{
+				Debug.WriteLine($"websocket {this.GetHashCode()} state = {this.clientWebSocket.State}");
 				return;
+			}
 
 			Debug.WriteLine($"closing websocket {this.GetHashCode()}");
 			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
@@ -166,26 +188,26 @@ private async Task _closeAsync(CancellationToken cancellationToken = default)
 
 		#region IDisposable
 
-		private Task Disposed { get; set; }
+		private Task _disposed;
 		private object _disposedLocker = new object();
 		public void Dispose()
 		{
 			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
 			lock (_disposedLocker)
 			{
-				if (Disposed == null) Disposed = DisposeAsync();
+				if (_disposed == null) _disposed = DisposeAsync();
 			}
 		}
 
 		private async Task DisposeAsync()
 		{
-			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
+			Debug.WriteLine($"disposing websocket {this.GetHashCode()}...");
 			if (!_cancellationTokenSource.IsCancellationRequested)
 				_cancellationTokenSource.Cancel();
 			await _closeAsync().ConfigureAwait(false);
 			clientWebSocket?.Dispose();
 			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
+			Debug.WriteLine($"websocket {this.GetHashCode()} disposed");
 		}
 		#endregion
 	}
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 60af36ab..b2fa9308 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -47,31 +47,31 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
 
-		/// <summary>
-		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		/// All subscriptions made to this stream share the same hot observable.<br/>
-		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
-		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
-		/// </summary>
-		/// <param name="request">the GraphQL request for this subscription</param>
-		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
-		/// <returns>an observable stream for the specified subscription</returns>
-		[Obsolete("EXPERIMENTAL")]
-		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+		///// <summary>
+		///// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		///// All subscriptions made to this stream share the same hot observable.<br/>
+		///// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		///// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		///// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		///// </summary>
+		///// <param name="request">the GraphQL request for this subscription</param>
+		///// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		///// <returns>an observable stream for the specified subscription</returns>
+		//[Obsolete("EXPERIMENTAL")]
+		//IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
 
-		/// <summary>
-		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		/// All subscriptions made to this stream share the same hot observable.<br/>
-		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
-		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
-		/// </summary>
-		/// <param name="request">the GraphQL request for this subscription</param>
-		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
-		/// <returns>an observable stream for the specified subscription</returns>
-		[Obsolete("EXPERIMENTAL")]
-		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
+		///// <summary>
+		///// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		///// All subscriptions made to this stream share the same hot observable.<br/>
+		///// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+		///// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		///// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+		///// </summary>
+		///// <param name="request">the GraphQL request for this subscription</param>
+		///// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+		///// <returns>an observable stream for the specified subscription</returns>
+		//[Obsolete("EXPERIMENTAL")]
+		//IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index 7bcf8522..1569176d 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -55,12 +55,12 @@ public ObservableTester(IObservable<T> observable)
 		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
 		/// </summary>
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
+		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null, TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_updateReceived.Wait(Timeout))
-					Assert.True(false, "no update received!");
+				if (!_updateReceived.Wait(timeout ?? Timeout))
+					Assert.True(false, $"no update received within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertPayload?.Invoke(LastPayload);
 			}
@@ -74,11 +74,12 @@ public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
 		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
+		public void ShouldNotHaveReceivedUpdate(TimeSpan? timeout = null)
 		{
+			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
 			try
 			{
-				if (_updateReceived.Wait(100))
+				if (_updateReceived.Wait(timeout.Value))
 					Assert.True(false, "update was inadvertently pushed!");
 			}
 			finally
@@ -90,12 +91,12 @@ public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
 		/// <summary>
 		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveCompleted()
+		public void ShouldHaveCompleted(TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_completed.Wait(Timeout))
-					Assert.True(false, "subscription did not complete!");
+				if (!_completed.Wait(timeout ?? Timeout))
+					Assert.True(false, $"subscription did not complete within {(timeout ?? Timeout).TotalSeconds} s!");
 			}
 			finally
 			{
@@ -106,12 +107,12 @@ public void ShouldHaveCompleted()
 		/// <summary>
 		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveThrownError(Action<Exception> assertError = null)
+		public void ShouldHaveThrownError(Action<Exception> assertError = null, TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_error.Wait(Timeout))
-					Assert.True(false, "subscription did not throw an error!");
+				if (!_error.Wait(timeout ?? Timeout))
+					Assert.True(false, $"subscription did not throw an error within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertError?.Invoke(Error);
 			}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 3b404f23..fa0dd4d9 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -45,7 +45,7 @@ private GraphQLHttpClient GetGraphQLClient(int port)
 		[Fact]
 		public async void AssertTestingHarness()
 		{
-			var port = 5001;
+			var port = 5002;
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -71,7 +71,7 @@ public async void AssertTestingHarness()
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
-			var port = 5002;
+			var port = 5003;
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -107,7 +107,7 @@ public async void CanCreateObservableSubscription()
 		[Fact]
 		public async void CanReconnectWithSameObservable()
 		{
-			var port = 5003;
+			var port = 5004;
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -127,6 +127,7 @@ public async void CanReconnectWithSameObservable()
 				});
 				Debug.WriteLine("disposing subscription...");
 				tester.Dispose();
+				await Task.Delay(TimeSpan.FromSeconds(10));
 
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
@@ -136,7 +137,7 @@ public async void CanReconnectWithSameObservable()
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-				});
+				}, TimeSpan.FromSeconds(10));
 
 				// disposing the client should complete the subscription
 				client.Dispose();

From ae491f2106058c1875a9f407fb7978c93dfb5ec6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 15:48:41 +0100
Subject: [PATCH 13/49] fix subscription test, cleanup code

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  86 ++++--
 .../Http/GraphQLHttpObservableSubscription.cs | 254 ------------------
 .../Http/GraphQLSubscriptionException.cs      |  32 +++
 .../SubscriptionsTest.cs                      |  24 +-
 4 files changed, 113 insertions(+), 283 deletions(-)
 delete mode 100644 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
 create mode 100644 src/GraphQL.Client/Http/GraphQLSubscriptionException.cs

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 67fd0661..2756e71e 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,12 +1,17 @@
 using System;
+using System.Diagnostics;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
+using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
+using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http {
 
@@ -149,31 +154,66 @@ private Uri _getWebSocketUri()
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(graphQlHttpWebSocket, request);
-			return observable;
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse>(async observer =>
+				{
+					var startRequest = new GraphQLWebSocketRequest
+					{
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var closeRequest = new GraphQLWebSocketRequest
+					{
+						Id = startRequest.Id,
+						Type = GQLWebSocketMessageType.GQL_STOP
+					};
+
+					var disposable = new CompositeDisposable(
+						Disposable.Create(async () =>
+						{
+							try
+							{
+								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+							}
+							catch (OperationCanceledException) { }
+						}),
+						// subscribe to result stream
+						graphQlHttpWebSocket.ResponseStream
+							.Where(response => response.Id == startRequest.Id)
+							.SelectMany(response =>
+							{
+								switch (response.Type)
+								{
+									case GQLWebSocketMessageType.GQL_COMPLETE:
+										Debug.WriteLine(
+											$"received 'complete' message on subscription {startRequest.Id}");
+										return Observable.Empty<GraphQLResponse>();
+									case GQLWebSocketMessageType.GQL_ERROR:
+										Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
+										return Observable.Throw<GraphQLResponse>(
+											new GraphQLSubscriptionException(response.Payload));
+									default:
+										Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+										return Observable.Return(((JObject)response?.Payload)
+											?.ToObject<GraphQLResponse>());
+								}
+							})
+							.Subscribe(observer)
+					);
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+
+					return disposable;
+				})
+			)
+			// transform to hot observable and auto-connect
+			.Publish().RefCount();
 		}
 
-		///// <inheritdoc />
-		//[Obsolete("EXPERIMENTAL API")]
-		//public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
-		//{
-		//	return CreateSubscriptionStream(request, e =>
-		//	{
-		//		if (e is WebSocketException webSocketException)
-		//			webSocketExceptionHandler(webSocketException);
-		//		else
-		//			throw e;
-		//	});
-		//}
-
-		///// <inheritdoc />
-		//[Obsolete("EXPERIMENTAL API")]
-		//public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
-		//{
-		//	var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(graphQlHttpWebSocket, request, _cancellationTokenSource.Token, exceptionHandler);
-		//	return observable;
-		//}
-
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
deleted file mode 100644
index 128f316c..00000000
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ /dev/null
@@ -1,254 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Net.WebSockets;
-using System.Reactive.Disposables;
-using System.Reactive.Linq;
-using System.Reactive.Threading.Tasks;
-using System.Runtime.Serialization;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using GraphQL.Common;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace GraphQL.Client.Http {
-
-	/// <summary>
-	/// Represents the result of a subscription query
-	/// </summary>
-	[Obsolete("EXPERIMENTAL API")]
-	public class GraphQLHttpObservableSubscription : IDisposable {
-
-		private readonly ClientWebSocket clientWebSocket = new ClientWebSocket();
-		private readonly Uri webSocketUri;
-		private readonly GraphQLRequest graphQLRequest;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-		private readonly ArraySegment<byte> arraySegment;
-		private readonly CancellationTokenSource _cancellationTokenSource;
-
-		private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default) {
-			_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-			_cancellationTokenSource.Token.Register(Dispose);
-			this.webSocketUri = webSocketUri;
-			this.graphQLRequest = graphQLRequest;
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-
-			arraySegment = new ArraySegment<byte>(buffer);
-		}
-
-		public async Task ConnectAsync(CancellationToken token)
-		{
-			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
-			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
-		}
-
-		public async Task<GraphQLResponse> ReceiveResultAsync()
-		{
-			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
-			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
-			switch (webSocketResponse.Type)
-			{
-				case GQLWebSocketMessageType.GQL_COMPLETE:
-					Debug.WriteLine($"received 'complete' message on subscription {this.GetHashCode()}");
-					Dispose();
-					break;
-				case GQLWebSocketMessageType.GQL_ERROR:
-					Debug.WriteLine($"received 'error' message on subscription {this.GetHashCode()}");
-					throw new GQLSubscriptionException(webSocketResponse.Payload);
-				default:
-					Debug.WriteLine($"received payload on subscription {this.GetHashCode()}");
-					break;
-			}
-
-			return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
-		}
-
-		public async Task CloseAsync(CancellationToken cancellationToken = default)
-		{
-			// don't attempt to close the websocket if it is in a failed state
-			if (this.clientWebSocket.State != WebSocketState.Open &&
-			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
-			    this.clientWebSocket.State != WebSocketState.CloseSent)
-				return;
-
-			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
-			if (this.clientWebSocket.State == WebSocketState.Open) {
-				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
-			}
-			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
-		}
-
-		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLWebSocketRequest
-			{
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_START,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLWebSocketRequest
-			{
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_STOP,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendGraphQLSubscriptionRequest(GraphQLWebSocketRequest graphQlWebSocketRequest, CancellationToken cancellationToken = default)
-		{
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQlWebSocketRequest);
-			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
-		}
-
-		#region IDisposable
-		public Task Disposed { get; private set; }
-		private object _disposedLocker = new object();
-		public void Dispose()
-		{
-			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-			lock (_disposedLocker)
-			{
-				if (Disposed == null) Disposed = DisposeAsync();
-			}
-		}
-
-		private async Task DisposeAsync()
-		{
-			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
-			if(!_cancellationTokenSource.IsCancellationRequested)
-				_cancellationTokenSource.Cancel();
-			await CloseAsync().ConfigureAwait(false);
-			clientWebSocket?.Dispose();
-			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
-		}
-
-		#endregion
-
-		#region Static Factories
-
-		internal static IObservable<GraphQLResponse> GetSubscriptionStream(
-			GraphQLHttpWebSocket webSocket,
-			GraphQLRequest graphQLRequest)
-		{
-			return Observable.Defer(() =>
-				Observable.Create<GraphQLResponse>(async observer =>
-				{
-					var startRequest = new GraphQLWebSocketRequest
-					{
-						Id = Guid.NewGuid().ToString("N"),
-						Type = GQLWebSocketMessageType.GQL_START,
-						Payload = graphQLRequest
-					};
-					var closeRequest = new GraphQLWebSocketRequest
-					{
-						Id = startRequest.Id,
-						Type = GQLWebSocketMessageType.GQL_STOP
-					};
-
-					var disposable = new CompositeDisposable(
-						Disposable.Create(async () =>
-						{
-							Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-							await webSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
-						}),
-						// subscribe to result stream
-						webSocket.ResponseStream
-							.Where(response => response.Id == startRequest.Id)
-							.SelectMany(response =>
-							{
-								switch (response.Type)
-								{
-									case GQLWebSocketMessageType.GQL_COMPLETE:
-										Debug.WriteLine(
-											$"received 'complete' message on subscription {startRequest.Id}");
-										return Observable.Empty<GraphQLResponse>();
-									case GQLWebSocketMessageType.GQL_ERROR:
-										Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
-										return Observable.Throw<GraphQLResponse>(
-											new GQLSubscriptionException(response.Payload));
-									default:
-										Debug.WriteLine($"received payload on subscription {startRequest.Id}");
-										return Observable.Return(((JObject) response?.Payload)
-											?.ToObject<GraphQLResponse>());
-								}
-							})
-							.Subscribe(observer)
-					);
-
-					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
-					// send subscription request
-					await webSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
-
-					return disposable;
-				})
-			)
-			// transform to hot observable and auto-connect
-			.Publish().RefCount();
-		}
-
-		/// <summary>
-		/// The back-off strategy for automatic reconnects. Calculates the delay before the next connection attempt is made.<br/>
-		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
-		/// </summary>
-		public static Func<int, TimeSpan> BackOffStrategy = n =>
-		{
-			var rnd = new Random();
-			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
-		};
-
-		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
-		{
-			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
-			return Task.FromResult(subscription);
-		}
-
-		private static async Task<IObservable<GraphQLResponse>> InitializeSubscription(GraphQLHttpObservableSubscription observableSubscription, CancellationToken cancelToken)
-		{
-			await observableSubscription.ConnectAsync(cancelToken).ConfigureAwait(false);
-			await observableSubscription.SendInitialMessageAsync(cancelToken).ConfigureAwait(false);
-			return Observable.Defer(() => observableSubscription.ReceiveResultAsync().ToObservable()).Repeat();
-		}
-
-		#endregion
-
-		[Serializable]
-		public class GQLSubscriptionException : Exception
-		{
-			//
-			// For guidelines regarding the creation of new exception types, see
-			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
-			// and
-			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
-			//
-
-			public GQLSubscriptionException()
-			{
-			}
-
-			public GQLSubscriptionException(object error) : base(error.ToString())
-			{
-			}
-
-			protected GQLSubscriptionException(
-				SerializationInfo info,
-				StreamingContext context) : base(info, context)
-			{
-			}
-		}
-	}
-}
diff --git a/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
new file mode 100644
index 00000000..7aad64f0
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace GraphQL.Client.Http
+{
+	[Serializable]
+	public class GraphQLSubscriptionException : Exception
+	{
+		//
+		// For guidelines regarding the creation of new exception types, see
+		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+		// and
+		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+		//
+
+		public GraphQLSubscriptionException()
+		{
+		}
+
+		public GraphQLSubscriptionException(object error) : base(error.ToString())
+		{
+		}
+
+		protected GraphQLSubscriptionException(
+			SerializationInfo info,
+			StreamingContext context) : base(info, context)
+		{
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index fa0dd4d9..8006469d 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -117,27 +117,39 @@ public async void CanReconnectWithSameObservable()
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
-				const string message1 = "Hello World";
 
+				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
 				Assert.Equal(message1, (string)response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
+
+				const string message2 = "How are you?";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
 				Debug.WriteLine("disposing subscription...");
 				tester.Dispose();
-				await Task.Delay(TimeSpan.FromSeconds(10));
 
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
-				const string message2 = "lorem ipsum dolor si amet";
-				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-				}, TimeSpan.FromSeconds(10));
+				}, TimeSpan.FromSeconds(3));
+				const string message3 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
+				Assert.Equal(message3, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
 
 				// disposing the client should complete the subscription
 				client.Dispose();

From 98190e9919fd85e7de56775dea6c96bc76940dd2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 15:49:09 +0100
Subject: [PATCH 14/49] more code cleanup

---
 src/GraphQL.Client/IGraphQLClient.cs | 26 --------------------------
 1 file changed, 26 deletions(-)

diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index b2fa9308..34fc72ec 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -46,32 +46,6 @@ public interface IGraphQLClient : IDisposable {
 		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
-
-		///// <summary>
-		///// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		///// All subscriptions made to this stream share the same hot observable.<br/>
-		///// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
-		///// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		///// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
-		///// </summary>
-		///// <param name="request">the GraphQL request for this subscription</param>
-		///// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
-		///// <returns>an observable stream for the specified subscription</returns>
-		//[Obsolete("EXPERIMENTAL")]
-		//IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
-
-		///// <summary>
-		///// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		///// All subscriptions made to this stream share the same hot observable.<br/>
-		///// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
-		///// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		///// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
-		///// </summary>
-		///// <param name="request">the GraphQL request for this subscription</param>
-		///// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
-		///// <returns>an observable stream for the specified subscription</returns>
-		//[Obsolete("EXPERIMENTAL")]
-		//IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }

From 9aec685d647e9a2d59876076c8f7feefebddcb99 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 16:01:23 +0100
Subject: [PATCH 15/49] add test CanConnectMultipleSubscriptionsSimultaneously

---
 .../GraphQLClientExtensions.cs                |  2 +-
 .../SubscriptionsTest.cs                      | 99 ++++++++++++++++---
 2 files changed, 89 insertions(+), 12 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index e8b4babf..c7dd0568 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -22,7 +22,7 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 				{
 					input = new
 					{
-						fromId = "me",
+						fromId = "2",
 						content = message,
 						sentAt = DateTime.Now
 					}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 8006469d..b20facde 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -36,7 +36,8 @@ public static IWebHost CreateServer(int port)
 		private readonly IWebHost _server;
 
 		public SubscriptionsTest()
-		{}
+		{
+		}
 
 		private GraphQLHttpClient GetGraphQLClient(int port)
 			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
@@ -53,7 +54,7 @@ public async void AssertTestingHarness()
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
-				Assert.Equal(message, (string)response.Data.addMessage.content);
+				Assert.Equal(message, (string) response.Data.addMessage.content);
 			}
 		}
 
@@ -63,6 +64,7 @@ public async void AssertTestingHarness()
 			    content
 			  }
 			}";
+
 		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
 		{
 			Query = SubscriptionQuery
@@ -92,10 +94,10 @@ public async void CanCreateObservableSubscription()
 
 				const string message2 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				Assert.Equal(message2, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
 				// disposing the client should throw a TaskCanceledException on the subscription
@@ -120,18 +122,18 @@ public async void CanReconnectWithSameObservable()
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				Assert.Equal(message1, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				Assert.Equal(message2, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
 				Debug.WriteLine("disposing subscription...");
@@ -139,21 +141,96 @@ public async void CanReconnectWithSameObservable()
 
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
+				tester.ShouldHaveReceivedUpdate(
+					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value); },
+					TimeSpan.FromSeconds(3));
+				const string message3 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
+				Assert.Equal(message3, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message3, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester.ShouldHaveCompleted();
+			}
+		}
+
+		private const string SubscriptionQuery2 = @"
+			subscription {
+			  messageAdded{
+			    content
+				from {
+				  displayName
+				}
+			  }
+			}";
+
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest
+		{
+			Query = SubscriptionQuery2
+		};
+
+		[Fact]
+		public async void CanConnectMultipleSubscriptionsSimultaneously()
+		{
+			var port = 5005;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest);
+
+				Debug.WriteLine("subscribing...");
+				var tester = subscription1.SubscribeTester();
+
+				const string message1 = "Hello World";
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2);
+				var tester2 = subscription2.SubscribeTester();
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
 				}, TimeSpan.FromSeconds(3));
+
+				const string message2 = "How are you?";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+				});
+
+				Debug.WriteLine("disposing subscription...");
+				tester.Dispose();
+
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
 				});
 
 				// disposing the client should complete the subscription
 				client.Dispose();
-				tester.ShouldHaveCompleted();
+				tester2.ShouldHaveCompleted();
 			}
 		}
 	}

From 24be6a5fa890beda2f7d20a980278f1a8f901f95 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 16:03:48 +0100
Subject: [PATCH 16/49] dynamically find free ports for integration test

---
 .../GraphQL.Integration.Tests/NetworkHelpers.cs | 17 +++++++++++++++++
 .../SubscriptionsTest.cs                        |  8 ++++----
 2 files changed, 21 insertions(+), 4 deletions(-)
 create mode 100644 tests/GraphQL.Integration.Tests/NetworkHelpers.cs

diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
new file mode 100644
index 00000000..1462767e
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
@@ -0,0 +1,17 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class NetworkHelpers
+	{
+		public static int GetFreeTcpPortNumber()
+		{
+			var l = new TcpListener(IPAddress.Loopback, 0);
+			l.Start();
+			var port = ((IPEndPoint)l.LocalEndpoint).Port;
+			l.Stop();
+			return port;
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index b20facde..4dc1b2b9 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -46,7 +46,7 @@ private GraphQLHttpClient GetGraphQLClient(int port)
 		[Fact]
 		public async void AssertTestingHarness()
 		{
-			var port = 5002;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -73,7 +73,7 @@ public async void AssertTestingHarness()
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
-			var port = 5003;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -109,7 +109,7 @@ public async void CanCreateObservableSubscription()
 		[Fact]
 		public async void CanReconnectWithSameObservable()
 		{
-			var port = 5004;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -176,7 +176,7 @@ public async void CanReconnectWithSameObservable()
 		[Fact]
 		public async void CanConnectMultipleSubscriptionsSimultaneously()
 		{
-			var port = 5005;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);

From 4189799bd6464da5e3c0a757630d9a9f0a1cd8ac Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 16:14:49 +0100
Subject: [PATCH 17/49] add WebSocketExceptionHandler to clientOptions

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs   |  6 +++---
 .../Http/GraphQLHttpClientOptions.cs           | 18 ++++++++++++++++++
 .../Http/GraphQLHttpWebSocket.cs               | 11 ++++-------
 3 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 2756e71e..99581029 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -82,7 +82,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
 		}
 
 		/// <summary>
@@ -97,7 +97,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
 		}
 
 		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
@@ -108,7 +108,7 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 73a00430..f2fbfe37 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
@@ -39,6 +40,23 @@ public class GraphQLHttpClientOptions {
 		/// </summary>
 		public MediaTypeHeaderValue MediaType { get; set; } = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
 
+		/// <summary>
+		/// The exception handler for the websocket connection.
+		/// <see cref="Exception"/>s thrown in this handler will bubble down through the reactive websocket stream and cause it to fail.
+		/// All other exceptions will cause the websocket to be closed and to attempt a reconnection.
+		/// </summary>
+		public Action<Exception> WebSocketExceptionHandler { get; set; } =
+			exception =>
+			{
+				if (exception is WebSocketException webSocketException)
+				{
+					Console.Error.WriteLine(webSocketException.ToString());
+				}
+				else
+				{
+					throw exception;
+				}
+			};
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 43e41c3a..f7abdeb8 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -16,6 +16,7 @@ namespace GraphQL.Client.Http
 	internal class GraphQLHttpWebSocket: IDisposable
 	{
 		private readonly Uri webSocketUri;
+		private readonly Action<Exception> _webSocketExceptionHandler;
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
@@ -23,9 +24,10 @@ internal class GraphQLHttpWebSocket: IDisposable
 
 		private ClientWebSocket clientWebSocket = null;
 
-		public GraphQLHttpWebSocket(Uri webSocketUri)
+		public GraphQLHttpWebSocket(Uri webSocketUri, Action<Exception> webSocketExceptionHandler)
 		{
 			this.webSocketUri = webSocketUri;
+			_webSocketExceptionHandler = webSocketExceptionHandler;
 			arraySegment = new ArraySegment<byte>(buffer);
 			ResponseStream = _createResponseStream();
 		}
@@ -74,7 +76,7 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 					try
 					{
 						// exceptions thrown by the handler will propagate to OnError()
-						_handleExceptions(e);
+						_webSocketExceptionHandler?.Invoke(e);
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return _cancellationTokenSource.Token.IsCancellationRequested
@@ -107,11 +109,6 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 				.Publish().RefCount();
 		}
 
-		private void _handleExceptions(Exception e)
-		{
-
-		}
-
 		private Task _initializeWebSocketTask;
 		private Task _initializeWebSocket()
 		{

From 492c440affa359a374f5379149e46dcd6f6cb4a3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 7 Dec 2018 10:15:07 +0100
Subject: [PATCH 18/49] move reconnect-logic into subscriptions

---
 root.props                                    |   2 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  90 ++++--------
 .../Http/GraphQLHttpClientOptions.cs          |  10 ++
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 128 ++++++++++++++++++
 .../Http/GraphQLHttpWebSocket.cs              |  45 +-----
 .../CallbackTester.cs                         |  81 +++++++++++
 .../SubscriptionsTest.cs                      |  48 ++++++-
 7 files changed, 293 insertions(+), 111 deletions(-)
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
 create mode 100644 tests/GraphQL.Integration.Tests/CallbackTester.cs

diff --git a/root.props b/root.props
index 20595010..5758bed1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.7</Version>
+		<Version>2.0.0-alpha.subscriptions-api.8</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 99581029..36c12118 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,17 +1,11 @@
 using System;
-using System.Diagnostics;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Net.WebSockets;
-using System.Reactive.Disposables;
-using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
-using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
-using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http {
 
@@ -82,7 +76,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		/// <summary>
@@ -97,7 +91,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
@@ -108,7 +102,7 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
@@ -154,64 +148,11 @@ private Uri _getWebSocketUri()
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			return Observable.Defer(() =>
-				Observable.Create<GraphQLResponse>(async observer =>
-				{
-					var startRequest = new GraphQLWebSocketRequest
-					{
-						Id = Guid.NewGuid().ToString("N"),
-						Type = GQLWebSocketMessageType.GQL_START,
-						Payload = request
-					};
-					var closeRequest = new GraphQLWebSocketRequest
-					{
-						Id = startRequest.Id,
-						Type = GQLWebSocketMessageType.GQL_STOP
-					};
-
-					var disposable = new CompositeDisposable(
-						Disposable.Create(async () =>
-						{
-							try
-							{
-								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
-							}
-							catch (OperationCanceledException) { }
-						}),
-						// subscribe to result stream
-						graphQlHttpWebSocket.ResponseStream
-							.Where(response => response.Id == startRequest.Id)
-							.SelectMany(response =>
-							{
-								switch (response.Type)
-								{
-									case GQLWebSocketMessageType.GQL_COMPLETE:
-										Debug.WriteLine(
-											$"received 'complete' message on subscription {startRequest.Id}");
-										return Observable.Empty<GraphQLResponse>();
-									case GQLWebSocketMessageType.GQL_ERROR:
-										Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
-										return Observable.Throw<GraphQLResponse>(
-											new GraphQLSubscriptionException(response.Payload));
-									default:
-										Debug.WriteLine($"received payload on subscription {startRequest.Id}");
-										return Observable.Return(((JObject)response?.Payload)
-											?.ToObject<GraphQLResponse>());
-								}
-							})
-							.Subscribe(observer)
-					);
-
-					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
-					// send subscription request
-					await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
-
-					return disposable;
-				})
-			)
-			// transform to hot observable and auto-connect
-			.Publish().RefCount();
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
+				Options, _cancellationTokenSource.Token);
 		}
 
 		/// <summary>
@@ -219,6 +160,21 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		/// </summary>
 		public void Dispose()
 		{
+			lock (_disposeLocker)
+			{
+				if (!_disposed)
+				{
+					_dispose();
+				}
+			}
+		}
+
+		private bool _disposed = false;
+		private object _disposeLocker = new object();
+
+		private void _dispose()
+		{
+			_disposed = true;
 			this.graphQLHttpHandler.Dispose();
 			this.graphQlHttpWebSocket.Dispose();
 			_cancellationTokenSource.Cancel();
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index f2fbfe37..a99c0b46 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -57,6 +57,16 @@ public class GraphQLHttpClientOptions {
 					throw exception;
 				}
 			};
+
+		/// <summary>
+		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
+		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+		/// </summary>
+		public Func<int, TimeSpan> BackOffStrategy = n =>
+		{
+			var rnd = new Random();
+			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+		};
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
new file mode 100644
index 00000000..5e1febed
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -0,0 +1,128 @@
+using System;
+using System.Diagnostics;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Threading;
+using GraphQL.Common;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Http
+{
+	public static class GraphQLHttpSubscriptionHelpers
+	{
+		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+			GraphQLRequest request,
+			GraphQLHttpWebSocket graphQlHttpWebSocket,
+			GraphQLHttpClientOptions options,
+			CancellationToken cancellationToken = default)
+		{
+			int connectionAttempt = 0;
+
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse>(async observer =>
+				{
+					var startRequest = new GraphQLWebSocketRequest
+					{
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var closeRequest = new GraphQLWebSocketRequest
+					{
+						Id = startRequest.Id,
+						Type = GQLWebSocketMessageType.GQL_STOP
+					};
+
+
+					var observable = graphQlHttpWebSocket.ResponseStream
+						.Where(response => response.Id == startRequest.Id)
+						.SelectMany(response =>
+						{
+							switch (response.Type)
+							{
+								case GQLWebSocketMessageType.GQL_COMPLETE:
+									Debug.WriteLine(
+										$"received 'complete' message on subscription {startRequest.Id}");
+									return Observable.Empty<GraphQLResponse>();
+								case GQLWebSocketMessageType.GQL_ERROR:
+									Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
+									return Observable.Throw<GraphQLResponse>(
+										new GraphQLSubscriptionException(response.Payload));
+								default:
+									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+									return Observable.Return(((JObject) response?.Payload)
+										?.ToObject<GraphQLResponse>());
+							}
+						});
+
+					Debug.WriteLine($"subscription connection attempt #{connectionAttempt}");
+					observable = (++connectionAttempt == 1)
+						? observable
+						: observable.DelaySubscription(options.BackOffStrategy(connectionAttempt - 1));
+
+					var disposable = new CompositeDisposable(
+						Disposable.Create(async () =>
+						{
+							connectionAttempt = 0;
+							try
+							{
+								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+							}
+							catch (OperationCanceledException) { }
+						}),
+						// subscribe to result stream
+						observable.Subscribe(observer)
+					);
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+
+					return disposable;
+				}))
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+				.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLResponse>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+				{
+					try
+					{
+						// exceptions thrown by the handler will propagate to OnError()
+						options.WebSocketExceptionHandler?.Invoke(e);
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						return cancellationToken.IsCancellationRequested
+							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
+							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
+					}
+					catch (Exception exception)
+					{
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the websocket for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t =>
+				{
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLResponse>(t.Item2);
+
+					connectionAttempt = 1;
+					return t.Item1 == null
+						? Observable.Empty<GraphQLResponse>()
+						: Observable.Return(t.Item1);
+				})
+				// transform to hot observable and auto-connect
+				.Publish().RefCount();
+		}
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index f7abdeb8..2b7a6ae8 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -16,7 +16,7 @@ namespace GraphQL.Client.Http
 	internal class GraphQLHttpWebSocket: IDisposable
 	{
 		private readonly Uri webSocketUri;
-		private readonly Action<Exception> _webSocketExceptionHandler;
+		private readonly GraphQLHttpClientOptions _options;
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
@@ -24,10 +24,10 @@ internal class GraphQLHttpWebSocket: IDisposable
 
 		private ClientWebSocket clientWebSocket = null;
 
-		public GraphQLHttpWebSocket(Uri webSocketUri, Action<Exception> webSocketExceptionHandler)
+		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
 			this.webSocketUri = webSocketUri;
-			_webSocketExceptionHandler = webSocketExceptionHandler;
+			_options = options;
 			arraySegment = new ArraySegment<byte>(buffer);
 			ResponseStream = _createResponseStream();
 		}
@@ -62,49 +62,12 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 					// when reconnecting, apply the delay computed by the BackOffStrategy
 					observable = (++reconnectionAttempt == 1)
 						? observable
-						: observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1));
+						: observable.DelaySubscription(_options.BackOffStrategy(reconnectionAttempt - 1));
 					return observable.Subscribe(observer);
 				})
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
 					Observable.Empty<GraphQLWebSocketResponse>())
-				// wrap results
-				.Select(response => new Tuple<GraphQLWebSocketResponse, Exception>(response, null))
-				// do exception handling
-				.Catch<Tuple<GraphQLWebSocketResponse, Exception>, Exception>(e =>
-				{
-					try
-					{
-						// exceptions thrown by the handler will propagate to OnError()
-						_webSocketExceptionHandler?.Invoke(e);
-
-						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-						return _cancellationTokenSource.Token.IsCancellationRequested
-							? Observable.Empty<Tuple<GraphQLWebSocketResponse, Exception>>()
-							: Observable.Throw<Tuple<GraphQLWebSocketResponse, Exception>>(e);
-					}
-					catch (Exception exception)
-					{
-						// wrap all other exceptions to be propagated behind retry
-						return Observable.Return(new Tuple<GraphQLWebSocketResponse, Exception>(null, exception));
-					}
-				})
-				// attempt to recreate the subscription stream for rethrown exceptions
-				.Retry()
-				// unwrap and push results or throw wrapped exceptions
-				.SelectMany(t =>
-				{
-					// if the result contains an exception, throw it on the observable
-					if (t.Item2 != null)
-						return Observable.Throw<GraphQLWebSocketResponse>(t.Item2);
-
-					// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
-					reconnectionAttempt = 1;
-
-					return t.Item1 == null
-						? Observable.Empty<GraphQLWebSocketResponse>()
-						: Observable.Return(t.Item1);
-				})
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/CallbackTester.cs
new file mode 100644
index 00000000..bf214d73
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/CallbackTester.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace GraphQL.Integration.Tests
+{
+	public class CallbackTester<T>
+	{
+		private ManualResetEventSlim _callbackInvoked { get; } = new ManualResetEventSlim();
+
+		/// <summary>
+		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+		/// </summary>
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// </summary>
+		public bool CallbackInvoked => _callbackInvoked.IsSet;
+		/// <summary>
+		/// The last payload which was received.
+		/// </summary>
+		public T LastPayload { get; private set; }
+
+		public void Callback(T param)
+		{
+			LastPayload = param;
+			_callbackInvoked.Set();
+		}
+
+		/// <summary>
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// </summary>
+		/// <param name="assertPayload">action to assert the contents of the payload</param>
+		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null)
+		{
+			try
+			{
+				if (!_callbackInvoked.Wait(timeout ?? Timeout))
+					Assert.True(false, $"callback not invoked within {(timeout ?? Timeout).TotalSeconds} s!");
+
+				assertPayload?.Invoke(LastPayload);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
+		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null)
+		{
+			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
+			try
+			{
+				if (_callbackInvoked.Wait(timeout.Value))
+					Assert.True(false, "callback was inadvertently invoked pushed!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Resets the tester class. Should be called before triggering the potential update
+		/// </summary>
+		public void Reset()
+		{
+			LastPayload = default(T);
+			_callbackInvoked.Reset();
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 4dc1b2b9..a5266d98 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
@@ -39,8 +41,12 @@ public SubscriptionsTest()
 		{
 		}
 
-		private GraphQLHttpClient GetGraphQLClient(int port)
-			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
+		private GraphQLHttpClient GetGraphQLClient(int port, Action<Exception> webSocketErrorHandler = null)
+			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
+			{
+				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+				WebSocketExceptionHandler = webSocketErrorHandler
+			} );
 
 
 		[Fact]
@@ -233,5 +239,43 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				tester2.ShouldHaveCompleted();
 			}
 		}
+
+		[Fact]
+		public async void CanHandleConnectionTimeout()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			var server = CreateServer(port);
+			var callbackTester = new CallbackTester<Exception>();
+
+			var client = GetGraphQLClient(port, callbackTester.Callback);
+			Debug.WriteLine("creating subscription stream");
+			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+
+			Debug.WriteLine("subscribing...");
+			var tester = observable.SubscribeTester();
+			const string message1 = "Hello World";
+
+			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+			Assert.Equal(message1, (string)response.Data.addMessage.content);
+
+			tester.ShouldHaveReceivedUpdate(gqlResponse =>
+			{
+				Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+			});
+
+			Debug.WriteLine("stopping web host...");
+			await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
+			Debug.WriteLine("web host stopped...");
+
+			callbackTester.CallbackShouldHaveBeenInvoked(exception =>
+			{
+				Assert.IsType<WebSocketException>(exception);
+			}, TimeSpan.FromSeconds(10));
+
+			// disposing the client should complete the subscription
+			client.Dispose();
+			tester.ShouldHaveCompleted();
+			server.Dispose();
+		}
 	}
 }

From 293c3512b42a56bf262db5f9428312dcf4bed7f5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 7 Dec 2018 10:35:30 +0100
Subject: [PATCH 19/49] move external exception handler declaration to
 CreateSubscriptionStream overloads

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 24 ++++++++++++++++-
 .../Http/GraphQLHttpClientOptions.cs          | 18 -------------
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  6 ++++-
 src/GraphQL.Client/IGraphQLClient.cs          | 26 +++++++++++++++++++
 .../SubscriptionsTest.cs                      |  7 +++--
 5 files changed, 57 insertions(+), 24 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 36c12118..90209d40 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -152,7 +153,28 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
 			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
-				Options, _cancellationTokenSource.Token);
+				Options, cancellationToken: _cancellationTokenSource.Token);
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+		{
+			return CreateSubscriptionStream(request, e =>
+			{
+				if (e is WebSocketException webSocketException)
+					webSocketExceptionHandler(webSocketException);
+				else
+					throw e;
+			});
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
+		{
+			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
+			return observable;
 		}
 
 		/// <summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index a99c0b46..38008421 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -40,24 +40,6 @@ public class GraphQLHttpClientOptions {
 		/// </summary>
 		public MediaTypeHeaderValue MediaType { get; set; } = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
 
-		/// <summary>
-		/// The exception handler for the websocket connection.
-		/// <see cref="Exception"/>s thrown in this handler will bubble down through the reactive websocket stream and cause it to fail.
-		/// All other exceptions will cause the websocket to be closed and to attempt a reconnection.
-		/// </summary>
-		public Action<Exception> WebSocketExceptionHandler { get; set; } =
-			exception =>
-			{
-				if (exception is WebSocketException webSocketException)
-				{
-					Console.Error.WriteLine(webSocketException.ToString());
-				}
-				else
-				{
-					throw exception;
-				}
-			};
-
 		/// <summary>
 		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
 		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 5e1febed..8d4a71af 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -16,6 +16,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 			GraphQLRequest request,
 			GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLHttpClientOptions options,
+			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
 		{
 			int connectionAttempt = 0;
@@ -93,8 +94,11 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				{
 					try
 					{
+						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
+						if (exceptionHandler == null) throw e;
+
 						// exceptions thrown by the handler will propagate to OnError()
-						options.WebSocketExceptionHandler?.Invoke(e);
+						exceptionHandler?.Invoke(e);
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return cancellationToken.IsCancellationRequested
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 34fc72ec..60af36ab 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -46,6 +46,32 @@ public interface IGraphQLClient : IDisposable {
 		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index a5266d98..8acbf6f4 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -41,11 +41,10 @@ public SubscriptionsTest()
 		{
 		}
 
-		private GraphQLHttpClient GetGraphQLClient(int port, Action<Exception> webSocketErrorHandler = null)
+		private GraphQLHttpClient GetGraphQLClient(int port)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
-				WebSocketExceptionHandler = webSocketErrorHandler
 			} );
 
 
@@ -247,9 +246,9 @@ public async void CanHandleConnectionTimeout()
 			var server = CreateServer(port);
 			var callbackTester = new CallbackTester<Exception>();
 
-			var client = GetGraphQLClient(port, callbackTester.Callback);
+			var client = GetGraphQLClient(port);
 			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
 
 			Debug.WriteLine("subscribing...");
 			var tester = observable.SubscribeTester();

From e6c469a48d54da6dd21a92f9abcbcf8166b5434c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 7 Dec 2018 10:51:13 +0100
Subject: [PATCH 20/49] fix exception on disposing disconnected subscription

---
 root.props                                               | 2 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs               | 4 ++++
 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs     | 9 +++++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 5758bed1..d00301d1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.8</Version>
+		<Version>2.0.0-alpha.subscriptions-api.10</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 8d4a71af..b4829f04 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
@@ -72,7 +73,10 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
 								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
 							}
+							// do not break on disposing
 							catch (OperationCanceledException) { }
+							// do not break with missing connection on Retry()
+							catch (WebSocketException) { }
 						}),
 						// subscribe to result stream
 						observable.Subscribe(observer)
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 8acbf6f4..bd9f52d7 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -271,6 +271,15 @@ public async void CanHandleConnectionTimeout()
 				Assert.IsType<WebSocketException>(exception);
 			}, TimeSpan.FromSeconds(10));
 
+			try
+			{
+				server.Start();
+			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+			}
+
 			// disposing the client should complete the subscription
 			client.Dispose();
 			tester.ShouldHaveCompleted();

From 7bcf0e4d79eeac2a79b869c432c65da81361ab1c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 10 Dec 2018 10:08:32 +0100
Subject: [PATCH 21/49] fix tests, add console app for testing reconnect after
 server restart

---
 GraphQL.Client.sln                            |   9 +-
 .../Program.cs                                |  44 ++++++
 ...iptionIntegrationTest.ConsoleClient.csproj |  13 ++
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  44 +++---
 .../Http/GraphQLHttpWebSocket.cs              | 125 ++++++++++++------
 .../SubscriptionsTest.cs                      |  12 +-
 6 files changed, 180 insertions(+), 67 deletions(-)
 create mode 100644 SubscriptionIntegrationTest.ConsoleClient/Program.cs
 create mode 100644 SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 722a7d85..aa9d13e0 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -1,4 +1,4 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
 VisualStudioVersion = 15.0.27130.2010
@@ -49,6 +49,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SubscriptionIntegrationTest.ConsoleClient", "SubscriptionIntegrationTest.ConsoleClient\SubscriptionIntegrationTest.ConsoleClient.csproj", "{D588BC10-6B17-477F-9546-F8D1CE02EACB}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -83,6 +85,10 @@ Global
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -97,6 +103,7 @@ Global
 		{B21E97C3-F328-473F-A054-A4BF272B63F0} = {9413EC62-CDDE-4E77-9784-E1136EA5D1EE}
 		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
new file mode 100644
index 00000000..a891236a
--- /dev/null
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -0,0 +1,44 @@
+using System;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+
+namespace SubsccriptionIntegrationTest.ConsoleClient
+{
+	class Program
+	{
+		static void Main(string[] args)
+		{
+			Console.WriteLine("configuring client ...");
+			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
+			{
+#pragma warning disable 618
+				var stream = client.CreateSubscriptionStream(new GraphQLRequest
+					{
+						Query = @"
+							subscription {
+							  messageAdded{
+							    content
+								from {
+								  displayName
+								}
+							  }
+							}"
+					},
+					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+#pragma warning restore 618
+
+				Console.WriteLine("subscribing to message stream ...");
+				using (var subscription = stream.Subscribe(
+					response => Console.WriteLine($"new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
+					exception => Console.WriteLine($"message subscription stream failed: {exception}"),
+					() => Console.WriteLine($"message subscription stream completed")))
+				{
+					Console.WriteLine("client setup complete");
+					Console.WriteLine("press any key to exit");
+					Console.Read();
+					Console.WriteLine("shutting down ...");
+				}
+			}
+		}
+	}
+}
diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
new file mode 100644
index 00000000..21901c2f
--- /dev/null
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\GraphQL.Client\GraphQL.Client.csproj" />
+    <ProjectReference Include="..\src\GraphQL.Common\GraphQL.Common.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index b4829f04..512dc443 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -4,6 +4,7 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
@@ -20,8 +21,6 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
 		{
-			int connectionAttempt = 0;
-
 			return Observable.Defer(() =>
 				Observable.Create<GraphQLResponse>(async observer =>
 				{
@@ -36,8 +35,6 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Id = startRequest.Id,
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
-
-
 					var observable = graphQlHttpWebSocket.ResponseStream
 						.Where(response => response.Id == startRequest.Id)
 						.SelectMany(response =>
@@ -45,8 +42,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 							switch (response.Type)
 							{
 								case GQLWebSocketMessageType.GQL_COMPLETE:
-									Debug.WriteLine(
-										$"received 'complete' message on subscription {startRequest.Id}");
+									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
 									return Observable.Empty<GraphQLResponse>();
 								case GQLWebSocketMessageType.GQL_ERROR:
 									Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
@@ -59,15 +55,24 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 							}
 						});
 
-					Debug.WriteLine($"subscription connection attempt #{connectionAttempt}");
-					observable = (++connectionAttempt == 1)
-						? observable
-						: observable.DelaySubscription(options.BackOffStrategy(connectionAttempt - 1));
+					try
+					{
+						// intialize websocket (completes immediately if socket is already open)
+						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+					}
+					catch (Exception e)
+					{
+						// subscribe observer to failed observable
+						return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+					}
 
 					var disposable = new CompositeDisposable(
+						observable.Subscribe(observer),
 						Disposable.Create(async () =>
 						{
-							connectionAttempt = 0;
+							// only try to send close request on open websocket
+							if (graphQlHttpWebSocket.WebSocketState != WebSocketState.Open) return;
+
 							try
 							{
 								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
@@ -75,16 +80,20 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 							}
 							// do not break on disposing
 							catch (OperationCanceledException) { }
-							// do not break with missing connection on Retry()
-							catch (WebSocketException) { }
-						}),
-						// subscribe to result stream
-						observable.Subscribe(observer)
+						})
 					);
 
 					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
 					// send subscription request
-					await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+					try
+					{
+						await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+					}
+					catch (Exception e)
+					{
+						Console.WriteLine(e);
+						throw;
+					}
 
 					return disposable;
 				}))
@@ -124,7 +133,6 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 					if (t.Item2 != null)
 						return Observable.Throw<GraphQLResponse>(t.Item2);
 
-					connectionAttempt = 1;
 					return t.Item1 == null
 						? Observable.Empty<GraphQLResponse>()
 						: Observable.Return(t.Item1);
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 2b7a6ae8..c5e2d349 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -3,6 +3,7 @@
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
+using System.Reactive.Subjects;
 using System.Reactive.Threading.Tasks;
 using System.Text;
 using System.Threading;
@@ -20,9 +21,13 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
-		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+
+		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+
+		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
 		private ClientWebSocket clientWebSocket = null;
+		private int _connectionAttempt = 0;
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
@@ -32,58 +37,43 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 			ResponseStream = _createResponseStream();
 		}
 
+		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+
+
 		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
-			await _initializeWebSocket().ConfigureAwait(false);
+			await InitializeWebSocket().ConfigureAwait(false);
 			var webSocketRequestString = JsonConvert.SerializeObject(request);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
 			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
 		}
 
-		/// <summary>
-		/// The back-off strategy for automatic reconnects. Calculates the delay before the next connection attempt is made.<br/>
-		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
-		/// </summary>
-		public static Func<int, TimeSpan> BackOffStrategy = n =>
-		{
-			var rnd = new Random();
-			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
-		};
+		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
 
 		#region Private Methods
 
-		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		private Task _backOff()
 		{
-			int reconnectionAttempt = 0;
+			_connectionAttempt++;
 
-			return Observable.Create<GraphQLWebSocketResponse>(observer =>
-				{
-					var observable = _getReceiveResultStream().GetAwaiter().GetResult();
-					// when reconnecting, apply the delay computed by the BackOffStrategy
-					observable = (++reconnectionAttempt == 1)
-						? observable
-						: observable.DelaySubscription(_options.BackOffStrategy(reconnectionAttempt - 1));
-					return observable.Subscribe(observer);
-				})
-				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLWebSocketResponse>())
-				// transform to hot observable and auto-connect
-				.Publish().RefCount();
+			if(_connectionAttempt == 1) return Task.CompletedTask;
+
+			var delay = _options.BackOffStrategy(_connectionAttempt - 1);
+			Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
+			return Task.Delay(delay);
 		}
 
-		private Task _initializeWebSocketTask;
-		private Task _initializeWebSocket()
+		public Task InitializeWebSocket()
 		{
 			// do not attempt to initialize if cancellation is requested
 			if(_disposed != null)
 				throw new OperationCanceledException();
 
 			// if an initialization task is already running, return that
-			if(_initializeWebSocketTask != null &&
-			   !_initializeWebSocketTask.IsFaulted &&
-			   !_initializeWebSocketTask.IsCompleted)
-				return _initializeWebSocketTask;
+			if(InitializeWebSocketTask != null &&
+			   !InitializeWebSocketTask.IsFaulted &&
+			   !InitializeWebSocketTask.IsCompleted)
+				return InitializeWebSocketTask;
 
 			// if the websocket is open, return a completed task
 			if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
@@ -93,28 +83,73 @@ private Task _initializeWebSocket()
 			clientWebSocket?.Dispose();
 			clientWebSocket = new ClientWebSocket();
 			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-			return _initializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+		}
+
+		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		{
+			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
+				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLWebSocketResponse>());
+		}
+
+		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
+		{
+			var observable = await _getReceiveResultStream().ConfigureAwait(false);
+			return new CompositeDisposable
+			(
+				observable.Subscribe(observer),
+				Disposable.Create(() =>
+				{
+					Debug.WriteLine("response stream disposed");
+				})
+			);
 		}
 
 		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
 		{
-			await _initializeWebSocket().ConfigureAwait(false);
-			return Observable.Defer(() => _receiveResultAsync().ToObservable()).Repeat();
+			await InitializeWebSocket().ConfigureAwait(false);
+			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
 		}
 
 		private async Task _connectAsync(CancellationToken token)
 		{
-			Debug.WriteLine($"opening websocket {this.GetHashCode()}");
+			await _backOff().ConfigureAwait(false);
+			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on websocket {this.GetHashCode()}");
+			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+			_connectionAttempt = 1;
+		}
+
+
+		private Task<GraphQLWebSocketResponse> _receiveAsyncTask = null;
+		private object _receiveTaskLocker = new object();
+		/// <summary>
+		/// wrapper method to pick up the existing request task if already running
+		/// </summary>
+		/// <returns></returns>
+		private Task<GraphQLWebSocketResponse> _getReceiveTask()
+		{
+			lock (_receiveTaskLocker)
+			{
+				if (_receiveAsyncTask == null ||
+				    _receiveAsyncTask.IsFaulted ||
+				    _receiveAsyncTask.IsCompleted)
+					_receiveAsyncTask = _receiveResultAsync();
+			}
+
+			return _receiveAsyncTask;
 		}
 
 		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
 			try
 			{
+				Debug.WriteLine("receiving websocket data ...");
 				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
+				var webSocketReceiveResult =
+					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
 				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
 				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
 				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
@@ -124,6 +159,10 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 				Console.WriteLine(e);
 				throw;
 			}
+			finally
+			{
+				Debug.WriteLine("websocket data received");
+			}
 		}
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)
@@ -136,11 +175,11 @@ private async Task _closeAsync(CancellationToken cancellationToken = default)
 			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
 			    this.clientWebSocket.State != WebSocketState.CloseSent)
 			{
-				Debug.WriteLine($"websocket {this.GetHashCode()} state = {this.clientWebSocket.State}");
+				Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
 				return;
 			}
 
-			Debug.WriteLine($"closing websocket {this.GetHashCode()}");
+			Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
 			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
 		}
 
@@ -161,13 +200,13 @@ public void Dispose()
 
 		private async Task DisposeAsync()
 		{
-			Debug.WriteLine($"disposing websocket {this.GetHashCode()}...");
+			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
 			if (!_cancellationTokenSource.IsCancellationRequested)
 				_cancellationTokenSource.Cancel();
 			await _closeAsync().ConfigureAwait(false);
 			clientWebSocket?.Dispose();
 			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"websocket {this.GetHashCode()} disposed");
+			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
 		}
 		#endregion
 	}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index bd9f52d7..36804c95 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -148,7 +148,7 @@ public async void CanReconnectWithSameObservable()
 				tester = observable.SubscribeTester();
 				tester.ShouldHaveReceivedUpdate(
 					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value); },
-					TimeSpan.FromSeconds(3));
+					TimeSpan.FromSeconds(10));
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string) response.Data.addMessage.content);
@@ -182,12 +182,14 @@ public async void CanReconnectWithSameObservable()
 		public async void CanConnectMultipleSubscriptionsSimultaneously()
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			var callbackTester = new CallbackTester<Exception>();
+			var callbackTester2 = new CallbackTester<Exception>();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest);
+				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
 
 				Debug.WriteLine("subscribing...");
 				var tester = subscription1.SubscribeTester();
@@ -200,13 +202,13 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2);
+				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
 				var tester2 = subscription2.SubscribeTester();
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
-				}, TimeSpan.FromSeconds(3));
+				}, TimeSpan.FromSeconds(10));
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
@@ -282,7 +284,7 @@ public async void CanHandleConnectionTimeout()
 
 			// disposing the client should complete the subscription
 			client.Dispose();
-			tester.ShouldHaveCompleted();
+			tester.ShouldHaveCompleted(TimeSpan.FromSeconds(5));
 			server.Dispose();
 		}
 	}

From 424f561a7444083d1da404675bffc78c0d5b0154 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 11 Dec 2018 21:51:40 +0100
Subject: [PATCH 22/49] Use single websocket for all subscriptions (#84)

* add StringEnumConverter to JsonSerializerSettings

* fix dependencies

* change version

* fix version

* fix CloseAsync

* lock dispose

* implement external exception handling for subscription streams

* fix doc comment

* add back-off delay for automatic reconnects

* create GraphQLHttpWebSocket class

* get single socket working

* fix subscription test, cleanup code

* more code cleanup

* add test CanConnectMultipleSubscriptionsSimultaneously

* dynamically find free ports for integration test

* add WebSocketExceptionHandler to clientOptions

* move reconnect-logic into subscriptions

* move external exception handler declaration to CreateSubscriptionStream overloads

* fix exception on disposing disconnected subscription

* fix tests, add console app for testing reconnect after server restart
---
 GraphQL.Client.sln                            |   9 +-
 .../Program.cs                                |  44 +++
 ...iptionIntegrationTest.ConsoleClient.csproj |  13 +
 root.props                                    |   2 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |   6 +
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  49 +++-
 .../Http/GraphQLHttpClientOptions.cs          |  18 +-
 .../Http/GraphQLHttpObservableSubscription.cs | 268 ------------------
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 144 ++++++++++
 .../Http/GraphQLHttpSubscriptionResult.cs     |  98 +------
 .../Http/GraphQLHttpWebSocket.cs              | 213 ++++++++++++++
 .../Http/GraphQLSubscriptionException.cs      |  32 +++
 src/GraphQL.Client/IGraphQLClient.cs          |  34 +++
 src/GraphQL.Common/GQLWebSocketMessageType.cs |  93 ++++++
 ...nRequest.cs => GraphQLWebSocketRequest.cs} |  10 +-
 ...esponse.cs => GraphQLWebSocketResponse.cs} |  10 +-
 .../CallbackTester.cs                         |  81 ++++++
 .../GraphQLClientExtensions.cs                |   2 +-
 .../NetworkHelpers.cs                         |  17 ++
 .../ObservableTester.cs                       |  49 ++--
 .../SubscriptionsTest.cs                      | 225 +++++++++++++--
 21 files changed, 993 insertions(+), 424 deletions(-)
 create mode 100644 SubscriptionIntegrationTest.ConsoleClient/Program.cs
 create mode 100644 SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
 delete mode 100644 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
 create mode 100644 src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
 create mode 100644 src/GraphQL.Common/GQLWebSocketMessageType.cs
 rename src/GraphQL.Common/Request/{GraphQLSubscriptionRequest.cs => GraphQLWebSocketRequest.cs} (73%)
 rename src/GraphQL.Common/Response/{GraphQLSubscriptionResponse.cs => GraphQLWebSocketResponse.cs} (72%)
 create mode 100644 tests/GraphQL.Integration.Tests/CallbackTester.cs
 create mode 100644 tests/GraphQL.Integration.Tests/NetworkHelpers.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 722a7d85..aa9d13e0 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -1,4 +1,4 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
 VisualStudioVersion = 15.0.27130.2010
@@ -49,6 +49,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SubscriptionIntegrationTest.ConsoleClient", "SubscriptionIntegrationTest.ConsoleClient\SubscriptionIntegrationTest.ConsoleClient.csproj", "{D588BC10-6B17-477F-9546-F8D1CE02EACB}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -83,6 +85,10 @@ Global
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -97,6 +103,7 @@ Global
 		{B21E97C3-F328-473F-A054-A4BF272B63F0} = {9413EC62-CDDE-4E77-9784-E1136EA5D1EE}
 		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
new file mode 100644
index 00000000..a891236a
--- /dev/null
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -0,0 +1,44 @@
+using System;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+
+namespace SubsccriptionIntegrationTest.ConsoleClient
+{
+	class Program
+	{
+		static void Main(string[] args)
+		{
+			Console.WriteLine("configuring client ...");
+			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
+			{
+#pragma warning disable 618
+				var stream = client.CreateSubscriptionStream(new GraphQLRequest
+					{
+						Query = @"
+							subscription {
+							  messageAdded{
+							    content
+								from {
+								  displayName
+								}
+							  }
+							}"
+					},
+					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+#pragma warning restore 618
+
+				Console.WriteLine("subscribing to message stream ...");
+				using (var subscription = stream.Subscribe(
+					response => Console.WriteLine($"new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
+					exception => Console.WriteLine($"message subscription stream failed: {exception}"),
+					() => Console.WriteLine($"message subscription stream completed")))
+				{
+					Console.WriteLine("client setup complete");
+					Console.WriteLine("press any key to exit");
+					Console.Read();
+					Console.WriteLine("shutting down ...");
+				}
+			}
+		}
+	}
+}
diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
new file mode 100644
index 00000000..21901c2f
--- /dev/null
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\GraphQL.Client\GraphQL.Client.csproj" />
+    <ProjectReference Include="..\src\GraphQL.Common\GraphQL.Common.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/root.props b/root.props
index e2fc2d0c..d00301d1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.3</Version>
+		<Version>2.0.0-alpha.subscriptions-api.10</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 200758df..97a78f0e 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -17,6 +17,12 @@
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <Reference Include="System.Reactive">
+	    <HintPath>C:\Users\arose\.nuget\packages\system.reactive\4.1.2\lib\netstandard2.0\System.Reactive.dll</HintPath>
+	  </Reference>
+	</ItemGroup>
+
 	<!-- Allow method ReadAsAsync<T>
 	<ItemGroup>
 		<PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.4" />
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index fe8f4710..90209d40 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Reactive.Linq;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -41,6 +41,7 @@ public GraphQLHttpClientOptions Options {
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
+		internal readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		/// <summary>
@@ -76,6 +77,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		/// <summary>
@@ -90,6 +92,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
@@ -100,6 +103,7 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
@@ -141,10 +145,35 @@ private Uri _getWebSocketUri()
 			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
 		}
 
+		/// <inheritdoc />
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token);
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
+				Options, cancellationToken: _cancellationTokenSource.Token);
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+		{
+			return CreateSubscriptionStream(request, e =>
+			{
+				if (e is WebSocketException webSocketException)
+					webSocketExceptionHandler(webSocketException);
+				else
+					throw e;
+			});
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
+		{
+			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
 			return observable;
 		}
 
@@ -153,7 +182,23 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		/// </summary>
 		public void Dispose()
 		{
+			lock (_disposeLocker)
+			{
+				if (!_disposed)
+				{
+					_dispose();
+				}
+			}
+		}
+
+		private bool _disposed = false;
+		private object _disposeLocker = new object();
+
+		private void _dispose()
+		{
+			_disposed = true;
 			this.graphQLHttpHandler.Dispose();
+			this.graphQlHttpWebSocket.Dispose();
 			_cancellationTokenSource.Cancel();
 			_cancellationTokenSource.Dispose();
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 9ff6b091..38008421 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -1,7 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.Http {
@@ -20,7 +23,11 @@ public class GraphQLHttpClientOptions {
 		/// The <see cref="Newtonsoft.Json.JsonSerializerSettings"/> that is going to be used
 		/// </summary>
 		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver()
+			ContractResolver = new CamelCasePropertyNamesContractResolver(),
+			Converters = new List<JsonConverter>
+			{
+				new StringEnumConverter()
+			}
 		};
 
 		/// <summary>
@@ -33,6 +40,15 @@ public class GraphQLHttpClientOptions {
 		/// </summary>
 		public MediaTypeHeaderValue MediaType { get; set; } = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
 
+		/// <summary>
+		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
+		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+		/// </summary>
+		public Func<int, TimeSpan> BackOffStrategy = n =>
+		{
+			var rnd = new Random();
+			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+		};
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
deleted file mode 100644
index d3f71990..00000000
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ /dev/null
@@ -1,268 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Net.WebSockets;
-using System.Reactive.Linq;
-using System.Reactive.Threading.Tasks;
-using System.Runtime.Serialization;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace GraphQL.Client.Http {
-
-	/// <summary>
-	/// Represents the result of a subscription query
-	/// </summary>
-	[Obsolete("EXPERIMENTAL API")]
-	public class GraphQLHttpObservableSubscription : IDisposable {
-
-		private readonly ClientWebSocket clientWebSocket = new ClientWebSocket();
-		private readonly Uri webSocketUri;
-		private readonly GraphQLRequest graphQLRequest;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-		private readonly ArraySegment<byte> arraySegment;
-		private readonly CancellationTokenSource _cancellationTokenSource;
-
-		private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default) {
-			_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-			_cancellationTokenSource.Token.Register(Dispose);
-			this.webSocketUri = webSocketUri;
-			this.graphQLRequest = graphQLRequest;
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-			arraySegment = new ArraySegment<byte>(buffer);
-		}
-
-		public async Task ConnectAsync(CancellationToken token)
-		{
-			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
-			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
-		}
-
-		public async Task<GraphQLResponse> ReceiveResultAsync()
-		{
-			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
-			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
-			switch (webSocketResponse.Type)
-			{
-				case GQLWebSocketMessageType.GQL_COMPLETE:
-					Debug.WriteLine($"received 'complete' message on subscription {this.GetHashCode()}");
-					Dispose();
-					break;
-				case GQLWebSocketMessageType.GQL_ERROR:
-					Debug.WriteLine($"received 'error' message on subscription {this.GetHashCode()}");
-					throw new GQLSubscriptionException(webSocketResponse.Payload);
-				default:
-					Debug.WriteLine($"received payload on subscription {this.GetHashCode()}");
-					break;
-			}
-
-			return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
-		}
-
-		public async Task CloseAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
-			if (this.clientWebSocket.State == WebSocketState.Open) {
-				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
-			}
-			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
-		}
-
-		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLSubscriptionRequest
-			{
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_START,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLSubscriptionRequest
-			{
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_STOP,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default)
-		{
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
-			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
-		}
-
-		#region IDisposable
-
-		public void Dispose()
-		{
-			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-			if(Disposed == null) Disposed = DisposeAsync();
-		}
-
-		public Task Disposed { get; private set; }
-
-		private async Task DisposeAsync()
-		{
-			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
-			if(!_cancellationTokenSource.IsCancellationRequested)
-				_cancellationTokenSource.Cancel();
-			await CloseAsync().ConfigureAwait(false);
-			clientWebSocket?.Dispose();
-			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
-		}
-
-		#endregion
-
-		#region Static Factories
-
-		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
-		{
-			return Observable.Using(
-				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
-				InitializeSubscription
-				).Publish().RefCount();
-		}
-
-
-		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
-		{
-			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
-			return Task.FromResult(subscription);
-		}
-
-		private static async Task<IObservable<GraphQLResponse>> InitializeSubscription(GraphQLHttpObservableSubscription observableSubscription, CancellationToken cancelToken)
-		{
-			await observableSubscription.ConnectAsync(cancelToken).ConfigureAwait(false);
-			await observableSubscription.SendInitialMessageAsync(cancelToken).ConfigureAwait(false);
-			return Observable.Defer(() => observableSubscription.ReceiveResultAsync().ToObservable()).Repeat();
-		}
-
-		#endregion
-
-		[Serializable]
-		public class GQLSubscriptionException : Exception
-		{
-			//
-			// For guidelines regarding the creation of new exception types, see
-			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
-			// and
-			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
-			//
-
-			public GQLSubscriptionException()
-			{
-			}
-
-			public GQLSubscriptionException(object error) : base(error.ToString())
-			{
-			}
-
-			protected GQLSubscriptionException(
-				SerializationInfo info,
-				StreamingContext context) : base(info, context)
-			{
-			}
-		}
-
-		public static class GQLWebSocketMessageType
-		{
-
-			/// <summary>
-			///     Client sends this message after plain websocket connection to start the communication with the server
-			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-			///     to this message.
-			///     payload: Object : optional parameters that the client specifies in connectionParams
-			/// </summary>
-			public const string GQL_CONNECTION_INIT = "connection_init";
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-			///     the connection.
-			/// </summary>
-			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-			///     the connection.
-			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-			///     client, just ignore the message).
-			///     payload: Object: the server side error
-			/// </summary>
-			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
-
-			/// <summary>
-			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-			///     client connection alive.
-			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-			///     server.
-			///     <remarks>
-			///         NOTE: This one here don't follow the standard due to connection optimization
-			///     </remarks>
-			/// </summary>
-			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
-
-			/// <summary>
-			///     Client sends this message to execute GraphQL operation
-			///     id: string : The id of the GraphQL operation to start
-			///     payload: Object:
-			///     query: string : GraphQL operation as string or parsed GraphQL document node
-			///     variables?: Object : Object with GraphQL variables
-			///     operationName?: string : GraphQL operation name
-			/// </summary>
-			public const string GQL_START = "start";
-
-			/// <summary>
-			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-			///     is a response for GQL_START message.
-			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-			///     id: string : ID of the operation that was successfully set up
-			///     payload: Object :
-			///     data: any: Execution result
-			///     errors?: Error[] : Array of resolvers errors
-			/// </summary>
-			public const string GQL_DATA = "data"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-			///     payload: Error : payload with the error attributed to the operation failing on the server
-			///     id: string : operation ID of the operation that failed on the server
-			/// </summary>
-			public const string GQL_ERROR = "error"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-			///     specific operation.
-			///     id: string : operation ID of the operation that completed
-			/// </summary>
-			public const string GQL_COMPLETE = "complete"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_STOP = "stop"; // Client -> Server
-		}
-	}
-}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
new file mode 100644
index 00000000..512dc443
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -0,0 +1,144 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Http
+{
+	public static class GraphQLHttpSubscriptionHelpers
+	{
+		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+			GraphQLRequest request,
+			GraphQLHttpWebSocket graphQlHttpWebSocket,
+			GraphQLHttpClientOptions options,
+			Action<Exception> exceptionHandler = null,
+			CancellationToken cancellationToken = default)
+		{
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse>(async observer =>
+				{
+					var startRequest = new GraphQLWebSocketRequest
+					{
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var closeRequest = new GraphQLWebSocketRequest
+					{
+						Id = startRequest.Id,
+						Type = GQLWebSocketMessageType.GQL_STOP
+					};
+					var observable = graphQlHttpWebSocket.ResponseStream
+						.Where(response => response.Id == startRequest.Id)
+						.SelectMany(response =>
+						{
+							switch (response.Type)
+							{
+								case GQLWebSocketMessageType.GQL_COMPLETE:
+									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+									return Observable.Empty<GraphQLResponse>();
+								case GQLWebSocketMessageType.GQL_ERROR:
+									Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
+									return Observable.Throw<GraphQLResponse>(
+										new GraphQLSubscriptionException(response.Payload));
+								default:
+									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+									return Observable.Return(((JObject) response?.Payload)
+										?.ToObject<GraphQLResponse>());
+							}
+						});
+
+					try
+					{
+						// intialize websocket (completes immediately if socket is already open)
+						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+					}
+					catch (Exception e)
+					{
+						// subscribe observer to failed observable
+						return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+					}
+
+					var disposable = new CompositeDisposable(
+						observable.Subscribe(observer),
+						Disposable.Create(async () =>
+						{
+							// only try to send close request on open websocket
+							if (graphQlHttpWebSocket.WebSocketState != WebSocketState.Open) return;
+
+							try
+							{
+								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+							}
+							// do not break on disposing
+							catch (OperationCanceledException) { }
+						})
+					);
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					try
+					{
+						await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+					}
+					catch (Exception e)
+					{
+						Console.WriteLine(e);
+						throw;
+					}
+
+					return disposable;
+				}))
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+				.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLResponse>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+				{
+					try
+					{
+						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
+						if (exceptionHandler == null) throw e;
+
+						// exceptions thrown by the handler will propagate to OnError()
+						exceptionHandler?.Invoke(e);
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						return cancellationToken.IsCancellationRequested
+							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
+							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
+					}
+					catch (Exception exception)
+					{
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the websocket for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t =>
+				{
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLResponse>(t.Item2);
+
+					return t.Item1 == null
+						? Observable.Empty<GraphQLResponse>()
+						: Observable.Return(t.Item1);
+				})
+				// transform to hot observable and auto-connect
+				.Publish().RefCount();
+		}
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
index e0c2dc6d..34ab6f0a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
@@ -3,6 +3,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
@@ -38,7 +39,7 @@ public async void StartAsync(CancellationToken cancellationToken = default) {
 				while (this.clientWebSocket.State == WebSocketState.Open) {
 					var webSocketReceiveResult = await this.clientWebSocket.ReceiveAsync(arraySegment, cancellationToken);
 					var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 					if (webSocketResponse != null)
 					{
 						var response = (GraphQLResponse) webSocketResponse.Payload;
@@ -62,7 +63,7 @@ public void Dispose() {
 		}
 
 		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLSubscriptionRequest {
+			var webSocketRequest = new GraphQLWebSocketRequest {
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_START,
 				Payload = this.graphQLRequest
@@ -71,7 +72,7 @@ private Task SendInitialMessageAsync(CancellationToken cancellationToken = defau
 		}
 
 		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLSubscriptionRequest {
+			var webSocketRequest = new GraphQLWebSocketRequest {
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_STOP,
 				Payload = this.graphQLRequest
@@ -79,98 +80,11 @@ private Task SendCloseMessageAsync(CancellationToken cancellationToken = default
 			return this.SendGraphQLSubscriptionRequest(webSocketRequest);
 		}
 
-		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default) {
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+		private Task SendGraphQLSubscriptionRequest(GraphQLWebSocketRequest graphQlWebSocketRequest, CancellationToken cancellationToken = default) {
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQlWebSocketRequest);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
 			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
 		}
-
-		private static class GQLWebSocketMessageType {
-
-			/// <summary>
-			///     Client sends this message after plain websocket connection to start the communication with the server
-			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-			///     to this message.
-			///     payload: Object : optional parameters that the client specifies in connectionParams
-			/// </summary>
-			public const string GQL_CONNECTION_INIT = "connection_init";
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-			///     the connection.
-			/// </summary>
-			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-			///     the connection.
-			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-			///     client, just ignore the message).
-			///     payload: Object: the server side error
-			/// </summary>
-			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
-
-			/// <summary>
-			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-			///     client connection alive.
-			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-			///     server.
-			///     <remarks>
-			///         NOTE: This one here don't follow the standard due to connection optimization
-			///     </remarks>
-			/// </summary>
-			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
-
-			/// <summary>
-			///     Client sends this message to execute GraphQL operation
-			///     id: string : The id of the GraphQL operation to start
-			///     payload: Object:
-			///     query: string : GraphQL operation as string or parsed GraphQL document node
-			///     variables?: Object : Object with GraphQL variables
-			///     operationName?: string : GraphQL operation name
-			/// </summary>
-			public const string GQL_START = "start";
-
-			/// <summary>
-			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-			///     is a response for GQL_START message.
-			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-			///     id: string : ID of the operation that was successfully set up
-			///     payload: Object :
-			///     data: any: Execution result
-			///     errors?: Error[] : Array of resolvers errors
-			/// </summary>
-			public const string GQL_DATA = "data"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-			///     payload: Error : payload with the error attributed to the operation failing on the server
-			///     id: string : operation ID of the operation that failed on the server
-			/// </summary>
-			public const string GQL_ERROR = "error"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-			///     specific operation.
-			///     id: string : operation ID of the operation that completed
-			/// </summary>
-			public const string GQL_COMPLETE = "complete"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_STOP = "stop"; // Client -> Server
-
-		}
-
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
new file mode 100644
index 00000000..c5e2d349
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -0,0 +1,213 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Reactive.Threading.Tasks;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json;
+
+namespace GraphQL.Client.Http
+{
+	internal class GraphQLHttpWebSocket: IDisposable
+	{
+		private readonly Uri webSocketUri;
+		private readonly GraphQLHttpClientOptions _options;
+		private readonly byte[] buffer = new byte[1024 * 1024];
+		private readonly ArraySegment<byte> arraySegment;
+		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+
+		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+
+		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
+
+		private ClientWebSocket clientWebSocket = null;
+		private int _connectionAttempt = 0;
+
+		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
+		{
+			this.webSocketUri = webSocketUri;
+			_options = options;
+			arraySegment = new ArraySegment<byte>(buffer);
+			ResponseStream = _createResponseStream();
+		}
+
+		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+
+
+		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		{
+			await InitializeWebSocket().ConfigureAwait(false);
+			var webSocketRequestString = JsonConvert.SerializeObject(request);
+			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+		}
+
+		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
+
+		#region Private Methods
+
+		private Task _backOff()
+		{
+			_connectionAttempt++;
+
+			if(_connectionAttempt == 1) return Task.CompletedTask;
+
+			var delay = _options.BackOffStrategy(_connectionAttempt - 1);
+			Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
+			return Task.Delay(delay);
+		}
+
+		public Task InitializeWebSocket()
+		{
+			// do not attempt to initialize if cancellation is requested
+			if(_disposed != null)
+				throw new OperationCanceledException();
+
+			// if an initialization task is already running, return that
+			if(InitializeWebSocketTask != null &&
+			   !InitializeWebSocketTask.IsFaulted &&
+			   !InitializeWebSocketTask.IsCompleted)
+				return InitializeWebSocketTask;
+
+			// if the websocket is open, return a completed task
+			if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
+				return Task.CompletedTask;
+
+			// else (re-)create websocket and connect
+			clientWebSocket?.Dispose();
+			clientWebSocket = new ClientWebSocket();
+			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+		}
+
+		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		{
+			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
+				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLWebSocketResponse>());
+		}
+
+		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
+		{
+			var observable = await _getReceiveResultStream().ConfigureAwait(false);
+			return new CompositeDisposable
+			(
+				observable.Subscribe(observer),
+				Disposable.Create(() =>
+				{
+					Debug.WriteLine("response stream disposed");
+				})
+			);
+		}
+
+		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
+		{
+			await InitializeWebSocket().ConfigureAwait(false);
+			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
+		}
+
+		private async Task _connectAsync(CancellationToken token)
+		{
+			await _backOff().ConfigureAwait(false);
+			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
+			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+			_connectionAttempt = 1;
+		}
+
+
+		private Task<GraphQLWebSocketResponse> _receiveAsyncTask = null;
+		private object _receiveTaskLocker = new object();
+		/// <summary>
+		/// wrapper method to pick up the existing request task if already running
+		/// </summary>
+		/// <returns></returns>
+		private Task<GraphQLWebSocketResponse> _getReceiveTask()
+		{
+			lock (_receiveTaskLocker)
+			{
+				if (_receiveAsyncTask == null ||
+				    _receiveAsyncTask.IsFaulted ||
+				    _receiveAsyncTask.IsCompleted)
+					_receiveAsyncTask = _receiveResultAsync();
+			}
+
+			return _receiveAsyncTask;
+		}
+
+		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
+		{
+			try
+			{
+				Debug.WriteLine("receiving websocket data ...");
+				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+				var webSocketReceiveResult =
+					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
+				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+				throw;
+			}
+			finally
+			{
+				Debug.WriteLine("websocket data received");
+			}
+		}
+
+		private async Task _closeAsync(CancellationToken cancellationToken = default)
+		{
+			if(clientWebSocket == null)
+				return;
+
+			// don't attempt to close the websocket if it is in a failed state
+			if (this.clientWebSocket.State != WebSocketState.Open &&
+			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
+			    this.clientWebSocket.State != WebSocketState.CloseSent)
+			{
+				Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
+				return;
+			}
+
+			Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
+			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
+		}
+
+		#endregion
+
+		#region IDisposable
+
+		private Task _disposed;
+		private object _disposedLocker = new object();
+		public void Dispose()
+		{
+			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+			lock (_disposedLocker)
+			{
+				if (_disposed == null) _disposed = DisposeAsync();
+			}
+		}
+
+		private async Task DisposeAsync()
+		{
+			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
+			if (!_cancellationTokenSource.IsCancellationRequested)
+				_cancellationTokenSource.Cancel();
+			await _closeAsync().ConfigureAwait(false);
+			clientWebSocket?.Dispose();
+			_cancellationTokenSource.Dispose();
+			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
+		}
+		#endregion
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
new file mode 100644
index 00000000..7aad64f0
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace GraphQL.Client.Http
+{
+	[Serializable]
+	public class GraphQLSubscriptionException : Exception
+	{
+		//
+		// For guidelines regarding the creation of new exception types, see
+		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+		// and
+		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+		//
+
+		public GraphQLSubscriptionException()
+		{
+		}
+
+		public GraphQLSubscriptionException(object error) : base(error.ToString())
+		{
+		}
+
+		protected GraphQLSubscriptionException(
+			SerializationInfo info,
+			StreamingContext context) : base(info, context)
+		{
+		}
+	}
+}
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 3343da14..60af36ab 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Common.Request;
@@ -36,8 +37,41 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
 
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// The stream must be recreated completely after an error has occured within its logic (i.e. a <see cref="WebSocketException"/>)
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }
diff --git a/src/GraphQL.Common/GQLWebSocketMessageType.cs b/src/GraphQL.Common/GQLWebSocketMessageType.cs
new file mode 100644
index 00000000..1e2fff76
--- /dev/null
+++ b/src/GraphQL.Common/GQLWebSocketMessageType.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL.Common
+{
+	public static class GQLWebSocketMessageType
+	{
+
+		/// <summary>
+		///     Client sends this message after plain websocket connection to start the communication with the server
+		///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+		///     to this message.
+		///     payload: Object : optional parameters that the client specifies in connectionParams
+		/// </summary>
+		public const string GQL_CONNECTION_INIT = "connection_init";
+
+		/// <summary>
+		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+		///     the connection.
+		/// </summary>
+		public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+
+		/// <summary>
+		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+		///     the connection.
+		///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+		///     client, just ignore the message).
+		///     payload: Object: the server side error
+		/// </summary>
+		public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+
+		/// <summary>
+		///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+		///     client connection alive.
+		///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+		///     server.
+		///     <remarks>
+		///         NOTE: This one here don't follow the standard due to connection optimization
+		///     </remarks>
+		/// </summary>
+		public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+
+		/// <summary>
+		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+		///     id: string : operation id
+		/// </summary>
+		public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+
+		/// <summary>
+		///     Client sends this message to execute GraphQL operation
+		///     id: string : The id of the GraphQL operation to start
+		///     payload: Object:
+		///     query: string : GraphQL operation as string or parsed GraphQL document node
+		///     variables?: Object : Object with GraphQL variables
+		///     operationName?: string : GraphQL operation name
+		/// </summary>
+		public const string GQL_START = "start";
+
+		/// <summary>
+		///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+		///     is a response for GQL_START message.
+		///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+		///     id: string : ID of the operation that was successfully set up
+		///     payload: Object :
+		///     data: any: Execution result
+		///     errors?: Error[] : Array of resolvers errors
+		/// </summary>
+		public const string GQL_DATA = "data"; // Server -> Client
+
+		/// <summary>
+		///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+		///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+		///     payload: Error : payload with the error attributed to the operation failing on the server
+		///     id: string : operation ID of the operation that failed on the server
+		/// </summary>
+		public const string GQL_ERROR = "error"; // Server -> Client
+
+		/// <summary>
+		///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+		///     specific operation.
+		///     id: string : operation ID of the operation that completed
+		/// </summary>
+		public const string GQL_COMPLETE = "complete"; // Server -> Client
+
+		/// <summary>
+		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+		///     id: string : operation id
+		/// </summary>
+		public const string GQL_STOP = "stop"; // Client -> Server
+
+	}
+}
diff --git a/src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
similarity index 73%
rename from src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs
rename to src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
index a468a0b3..46e14dce 100644
--- a/src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Common.Request {
 	/// A Subscription Request
 	/// </summary>
 	[Obsolete("EXPERIMENTAL")]
-	public class GraphQLSubscriptionRequest : IEquatable<GraphQLSubscriptionRequest> {
+	public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 
 		/// <summary>
 		/// The Identifier of the Response
@@ -25,10 +25,10 @@ public class GraphQLSubscriptionRequest : IEquatable<GraphQLSubscriptionRequest>
 		public GraphQLRequest Payload { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionRequest);
+		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLSubscriptionRequest other) {
+		public bool Equals(GraphQLWebSocketRequest other) {
 			if (other == null) {
 				return false;
 			}
@@ -57,10 +57,10 @@ public override int GetHashCode() {
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLSubscriptionRequest request1, GraphQLSubscriptionRequest request2) => EqualityComparer<GraphQLSubscriptionRequest>.Default.Equals(request1, request2);
+		public static bool operator ==(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => EqualityComparer<GraphQLWebSocketRequest>.Default.Equals(request1, request2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLSubscriptionRequest request1, GraphQLSubscriptionRequest request2) => !(request1 == request2);
+		public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
 
 	}
 
diff --git a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs b/src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
similarity index 72%
rename from src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
rename to src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
index 71c47c72..cd3fb2f4 100644
--- a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
+++ b/src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Common.Response {
 	/// A Subscription Response
 	/// </summary>
 	[Obsolete("EXPERIMENTAL")]
-	public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionResponse> {
+	public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse> {
 
 		/// <summary>
 		/// The Identifier of the Response
@@ -25,10 +25,10 @@ public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionRespons
 		public dynamic Payload { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionResponse);
+		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketResponse);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLSubscriptionResponse other) {
+		public bool Equals(GraphQLWebSocketResponse other) {
 			if (other == null) {
 				return false;
 			}
@@ -57,10 +57,10 @@ public override int GetHashCode() {
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLSubscriptionResponse response1, GraphQLSubscriptionResponse response2) => EqualityComparer<GraphQLSubscriptionResponse>.Default.Equals(response1, response2);
+		public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLSubscriptionResponse response1, GraphQLSubscriptionResponse response2) => !(response1 == response2);
+		public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => !(response1 == response2);
 
 	}
 
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/CallbackTester.cs
new file mode 100644
index 00000000..bf214d73
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/CallbackTester.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace GraphQL.Integration.Tests
+{
+	public class CallbackTester<T>
+	{
+		private ManualResetEventSlim _callbackInvoked { get; } = new ManualResetEventSlim();
+
+		/// <summary>
+		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+		/// </summary>
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// </summary>
+		public bool CallbackInvoked => _callbackInvoked.IsSet;
+		/// <summary>
+		/// The last payload which was received.
+		/// </summary>
+		public T LastPayload { get; private set; }
+
+		public void Callback(T param)
+		{
+			LastPayload = param;
+			_callbackInvoked.Set();
+		}
+
+		/// <summary>
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// </summary>
+		/// <param name="assertPayload">action to assert the contents of the payload</param>
+		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null)
+		{
+			try
+			{
+				if (!_callbackInvoked.Wait(timeout ?? Timeout))
+					Assert.True(false, $"callback not invoked within {(timeout ?? Timeout).TotalSeconds} s!");
+
+				assertPayload?.Invoke(LastPayload);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
+		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null)
+		{
+			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
+			try
+			{
+				if (_callbackInvoked.Wait(timeout.Value))
+					Assert.True(false, "callback was inadvertently invoked pushed!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Resets the tester class. Should be called before triggering the potential update
+		/// </summary>
+		public void Reset()
+		{
+			LastPayload = default(T);
+			_callbackInvoked.Reset();
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index e8b4babf..c7dd0568 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -22,7 +22,7 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 				{
 					input = new
 					{
-						fromId = "me",
+						fromId = "2",
 						content = message,
 						sentAt = DateTime.Now
 					}
diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
new file mode 100644
index 00000000..1462767e
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
@@ -0,0 +1,17 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class NetworkHelpers
+	{
+		public static int GetFreeTcpPortNumber()
+		{
+			var l = new TcpListener(IPAddress.Loopback, 0);
+			l.Start();
+			var port = ((IPEndPoint)l.LocalEndpoint).Port;
+			l.Stop();
+			return port;
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index e7993a36..1569176d 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -20,7 +20,7 @@ public class ObservableTester<T> : IDisposable
 		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
 
 		/// <summary>
-		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// Indicates that an update has been received since the last <see cref="_reset"/>
 		/// </summary>
 		public bool UpdateReceived => _updateReceived.IsSet;
 		/// <summary>
@@ -51,84 +51,85 @@ public ObservableTester(IObservable<T> observable)
 		}
 
 		/// <summary>
-		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>.
 		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
 		/// </summary>
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
+		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null, TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_updateReceived.Wait(Timeout))
-					Assert.True(false, "no update received!");
+				if (!_updateReceived.Wait(timeout ?? Timeout))
+					Assert.True(false, $"no update received within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertPayload?.Invoke(LastPayload);
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
+		public void ShouldNotHaveReceivedUpdate(TimeSpan? timeout = null)
 		{
+			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
 			try
 			{
-				if (_updateReceived.Wait(100))
+				if (_updateReceived.Wait(timeout.Value))
 					Assert.True(false, "update was inadvertently pushed!");
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveCompleted()
+		public void ShouldHaveCompleted(TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_completed.Wait(Timeout))
-					Assert.True(false, "subscription did not complete!");
+				if (!_completed.Wait(timeout ?? Timeout))
+					Assert.True(false, $"subscription did not complete within {(timeout ?? Timeout).TotalSeconds} s!");
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveThrownError(Action<Exception> assertError = null)
+		public void ShouldHaveThrownError(Action<Exception> assertError = null, TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_error.Wait(Timeout))
-					Assert.True(false, "subscription did not throw an error!");
+				if (!_error.Wait(timeout ?? Timeout))
+					Assert.True(false, $"subscription did not throw an error within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertError?.Invoke(Error);
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
 		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
-		public void Reset()
+		private void _reset()
 		{
-			if (_completed.IsSet)
-				throw new InvalidOperationException(
-					"the subscription sequence has completed. this tester instance cannot be reused");
+			//if (_completed.IsSet)
+			//	throw new InvalidOperationException(
+			//		"the subscription sequence has completed. this tester instance cannot be reused");
 
 			LastPayload = default(T);
 			_updateReceived.Reset();
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index f8a66760..36804c95 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
@@ -36,16 +38,20 @@ public static IWebHost CreateServer(int port)
 		private readonly IWebHost _server;
 
 		public SubscriptionsTest()
-		{}
+		{
+		}
 
 		private GraphQLHttpClient GetGraphQLClient(int port)
-			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
+			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
+			{
+				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+			} );
 
 
 		[Fact]
 		public async void AssertTestingHarness()
 		{
-			var port = 5001;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -53,29 +59,31 @@ public async void AssertTestingHarness()
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
-				Assert.Equal(message, (string)response.Data.addMessage.content);
+				Assert.Equal(message, (string) response.Data.addMessage.content);
 			}
 		}
 
+		private const string SubscriptionQuery = @"
+			subscription {
+			  messageAdded{
+			    content
+			  }
+			}";
+
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
+		{
+			Query = SubscriptionQuery
+		};
+
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
-			var port = 5002;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
-				var graphQLRequest = new GraphQLRequest
-				{
-					Query = @"
-					subscription {
-					  messageAdded{
-					    content
-					  }
-					}"
-				};
-
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -89,26 +97,195 @@ public async void CanCreateObservableSubscription()
 					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				tester.Reset();
-
 				const string message2 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string) response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				// disposing the client should throw a TaskCanceledException on the subscription
+				client.Dispose();
+				tester.ShouldHaveCompleted();
+			}
+		}
+
+		[Fact]
+		public async void CanReconnectWithSameObservable()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+
+				const string message1 = "Hello World";
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string) response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				const string message2 = "How are you?";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string) response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				Debug.WriteLine("disposing subscription...");
+				tester.Dispose();
+
+				Debug.WriteLine("creating new subscription...");
+				tester = observable.SubscribeTester();
+				tester.ShouldHaveReceivedUpdate(
+					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value); },
+					TimeSpan.FromSeconds(10));
+				const string message3 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
+				Assert.Equal(message3, (string) response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message3, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester.ShouldHaveCompleted();
+			}
+		}
+
+		private const string SubscriptionQuery2 = @"
+			subscription {
+			  messageAdded{
+			    content
+				from {
+				  displayName
+				}
+			  }
+			}";
+
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest
+		{
+			Query = SubscriptionQuery2
+		};
+
+		[Fact]
+		public async void CanConnectMultipleSubscriptionsSimultaneously()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			var callbackTester = new CallbackTester<Exception>();
+			var callbackTester2 = new CallbackTester<Exception>();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+
+				Debug.WriteLine("subscribing...");
+				var tester = subscription1.SubscribeTester();
+
+				const string message1 = "Hello World";
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
+				var tester2 = subscription2.SubscribeTester();
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+				}, TimeSpan.FromSeconds(10));
+
+				const string message2 = "How are you?";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
 				Assert.Equal(message2, (string)response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+				});
 
-				tester.Reset();
+				Debug.WriteLine("disposing subscription...");
+				tester.Dispose();
 
-				// disposing the client should throw a TaskCanceledException on the subscription
-				client.Dispose();
-				tester.ShouldHaveThrownError(exception =>
+				const string message3 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
+				Assert.Equal(message3, (string)response.Data.addMessage.content);
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.True(exception is TaskCanceledException,
-							$"exception is of unexpected type {exception.GetType().Name}");
+					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
 				});
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester2.ShouldHaveCompleted();
+			}
+		}
+
+		[Fact]
+		public async void CanHandleConnectionTimeout()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			var server = CreateServer(port);
+			var callbackTester = new CallbackTester<Exception>();
+
+			var client = GetGraphQLClient(port);
+			Debug.WriteLine("creating subscription stream");
+			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+
+			Debug.WriteLine("subscribing...");
+			var tester = observable.SubscribeTester();
+			const string message1 = "Hello World";
+
+			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+			Assert.Equal(message1, (string)response.Data.addMessage.content);
+
+			tester.ShouldHaveReceivedUpdate(gqlResponse =>
+			{
+				Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+			});
+
+			Debug.WriteLine("stopping web host...");
+			await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
+			Debug.WriteLine("web host stopped...");
+
+			callbackTester.CallbackShouldHaveBeenInvoked(exception =>
+			{
+				Assert.IsType<WebSocketException>(exception);
+			}, TimeSpan.FromSeconds(10));
+
+			try
+			{
+				server.Start();
 			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+			}
+
+			// disposing the client should complete the subscription
+			client.Dispose();
+			tester.ShouldHaveCompleted(TimeSpan.FromSeconds(5));
+			server.Dispose();
 		}
 	}
 }

From 16a9bd8ac69678f2714fcfed1fb8e1f9576e59f4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Dec 2018 08:33:05 +0100
Subject: [PATCH 23/49] create "queue" for requests so that only one send
 operation is performed at a time

---
 .../Http/GraphQLHttpWebSocket.cs              | 34 ++++++++++++++++---
 .../Request/GraphQLWebSocketRequest.cs        | 25 ++++++++++++++
 2 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index c5e2d349..fec75db2 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
+using System.Reactive;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
@@ -23,6 +24,8 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private IDisposable _requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
@@ -35,17 +38,38 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 			_options = options;
 			arraySegment = new ArraySegment<byte>(buffer);
 			ResponseStream = _createResponseStream();
+
+			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
 		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
 
+		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		{
+			_requestSubject.OnNext(request);
+			return request.SendTask();
+		}
 
-		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
-			await InitializeWebSocket().ConfigureAwait(false);
-			var webSocketRequestString = JsonConvert.SerializeObject(request);
-			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+			try
+			{
+				if (_cancellationTokenSource.Token.IsCancellationRequested)
+				{
+					request.SendCanceled();
+					return;
+				}
+
+				await InitializeWebSocket().ConfigureAwait(false);
+				var webSocketRequestString = JsonConvert.SerializeObject(request);
+				var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+				await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+				request.SendCompleted();
+			}
+			catch (Exception e)
+			{
+				request.SendFailed(e);
+			}
 		}
 
 		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
diff --git a/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
index 46e14dce..d805efc4 100644
--- a/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace GraphQL.Common.Request {
 
@@ -24,6 +25,30 @@ public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 		/// </summary>
 		public GraphQLRequest Payload { get; set; }
 
+		private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
+
+		/// <summary>
+		/// Task used to await the actual send operation and to convey potential exceptions
+		/// </summary>
+		/// <returns></returns>
+		public Task SendTask() => _tcs.Task;
+
+		/// <summary>
+		/// gets called when the send operation for this request has completed sucessfully
+		/// </summary>
+		public void SendCompleted() => _tcs.SetResult(true);
+
+		/// <summary>
+		/// gets called when an exception occurs during the send operation
+		/// </summary>
+		/// <param name="e"></param>
+		public void SendFailed(Exception e) => _tcs.SetException(e);
+
+		/// <summary>
+		/// gets called when the GraphQLHttpWebSocket has been disposed before the send operation for this request has started
+		/// </summary>
+		public void SendCanceled() => _tcs.SetCanceled();
+
 		/// <inheritdoc />
 		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
 

From c37fe83d0cc6ec54f68dbf1c60a39babe42144f8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Dec 2018 12:33:01 +0100
Subject: [PATCH 24/49] fix websockets on win 7

---
 root.props                                    |  2 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |  2 ++
 .../Http/GraphQLHttpWebSocket.cs              | 20 ++++++++++++++++---
 3 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/root.props b/root.props
index d00301d1..00258eb1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.10</Version>
+		<Version>2.0.0-alpha.subscriptions-api.12</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 97a78f0e..d0e912eb 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -14,7 +14,9 @@
 
 	<ItemGroup>
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
+		<PackageReference Include="WebSocket4Net" Version="0.15.2" />
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index fec75db2..297ec288 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -29,7 +29,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
-		private ClientWebSocket clientWebSocket = null;
+		private WebSocket clientWebSocket = null;
 		private int _connectionAttempt = 0;
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
@@ -105,8 +105,22 @@ public Task InitializeWebSocket()
 
 			// else (re-)create websocket and connect
 			clientWebSocket?.Dispose();
-			clientWebSocket = new ClientWebSocket();
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+
+			// fix websocket not supported on win 7 using
+			// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
+			clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+			switch (clientWebSocket)
+			{
+				case ClientWebSocket nativeWebSocket:
+					nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+					break;
+				case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
+					managedWebSocket.Options.AddSubProtocol("graphql-ws");
+					break;
+				default:
+					throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
+			}
+
 			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 		}
 

From 0562eb8e8ad44f84b0b1f3c5a7ed18221158446a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Dec 2018 12:37:49 +0100
Subject: [PATCH 25/49] remove websockets4net dependency

---
 root.props                               | 2 +-
 src/GraphQL.Client/GraphQL.Client.csproj | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/root.props b/root.props
index 00258eb1..0749001b 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.12</Version>
+		<Version>2.0.0-alpha.subscriptions-api.13</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index d0e912eb..8043bf35 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -16,7 +16,6 @@
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
 		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
-		<PackageReference Include="WebSocket4Net" Version="0.15.2" />
 	</ItemGroup>
 
 	<ItemGroup>

From bd9bf5e2f0feb8a2835b5d1dac7121b2a54ec726 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 13:56:31 +0100
Subject: [PATCH 26/49] fix suff for dotnet core 3.0

---
 .../Program.cs                                | 22 +++++++++----------
 .../GraphQL.Common.Benchmark.csproj           |  4 ++++
 root.props                                    |  2 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  1 -
 .../GraphQLClientExtensions.cs                |  7 +++---
 .../SubscriptionsTest.cs                      | 12 ++--------
 6 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index a891236a..961ad1d3 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -12,18 +12,16 @@ static void Main(string[] args)
 			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
 			{
 #pragma warning disable 618
-				var stream = client.CreateSubscriptionStream(new GraphQLRequest
-					{
-						Query = @"
-							subscription {
-							  messageAdded{
-							    content
-								from {
-								  displayName
-								}
-							  }
-							}"
-					},
+				var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+						subscription {
+							messageAdded{
+							content
+							from {
+								displayName
+							}
+							}
+						}"
+					),
 					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
 #pragma warning restore 618
 
diff --git a/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
index 2591eaad..d5ccaa33 100644
--- a/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
+++ b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
@@ -8,5 +8,9 @@
 	<ItemGroup>
 		<PackageReference Include="BenchmarkDotNet" Version="0.11.3" />
 	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
+	</ItemGroup>
 	
 </Project>
diff --git a/root.props b/root.props
index 9f8c24b7..91fe5186 100644
--- a/root.props
+++ b/root.props
@@ -8,7 +8,7 @@
 		<GenerateDocumentationFile>True</GenerateDocumentationFile>
 		<LangVersion>8.0</LangVersion>
 		<NeutralLanguage>en-US</NeutralLanguage>
-		<NoWarn>CS0618;CS1591;CS1701</NoWarn>
+		<NoWarn>CS0618;CS1591;CS1701;NU5105;NU5125</NoWarn>
 		<PackageIconUrl>https://raw.githubusercontent.com/graphql-dotnet/graphql-client/master/assets/logo.64x64.png</PackageIconUrl>
 		<PackageLicenseUrl>https://raw.githubusercontent.com/graphql-dotnet/graphql-client/master/LICENSE.txt</PackageLicenseUrl>
 		<PackageProjectUrl>https://github.com/graphql-dotnet/graphql-client</PackageProjectUrl>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 512dc443..f48364ec 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -4,7 +4,6 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index c7dd0568..065b4a5c 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -10,14 +10,13 @@ public static class GraphQLClientExtensions
 	{
 		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
 		{
-			var graphQLRequest = new GraphQLRequest
-			{
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				mutation($input: MessageInputType){
 				  addMessage(message: $input){
 				    content
 				  }
-				}",
+				}")
+			{
 				Variables = new
 				{
 					input = new
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 36804c95..b1e4ca93 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -2,7 +2,6 @@
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
@@ -11,7 +10,6 @@
 using Microsoft.Extensions.Logging;
 using Xunit;
 
-
 namespace GraphQL.Integration.Tests
 {
 	public class SubscriptionsTest
@@ -70,10 +68,7 @@ public async void AssertTestingHarness()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
-		{
-			Query = SubscriptionQuery
-		};
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
 
 		[Fact]
 		public async void CanCreateObservableSubscription()
@@ -173,10 +168,7 @@ public async void CanReconnectWithSameObservable()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest
-		{
-			Query = SubscriptionQuery2
-		};
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 		[Fact]
 		public async void CanConnectMultipleSubscriptionsSimultaneously()

From 72ba90d882e8ae267fc5eab7423e099323449dac Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 14:08:12 +0100
Subject: [PATCH 27/49] check response for 'null' in where clause

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs              | 6 ++++++
 src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs | 2 +-
 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs           | 2 +-
 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs      | 2 +-
 4 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 2bb4c689..255b3d6e 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -160,6 +160,9 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
 		{
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
 			return CreateSubscriptionStream(request, e =>
 			{
 				if (e is WebSocketException webSocketException)
@@ -173,6 +176,9 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
 		{
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
 			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
 			return observable;
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index f48364ec..10b2e501 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -35,7 +35,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
 					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => response.Id == startRequest.Id)
+						.Where(response => response != null && response.Id == startRequest.Id)
 						.SelectMany(response =>
 						{
 							switch (response.Type)
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 297ec288..4ed3d5ee 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -194,7 +194,7 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 			}
 			catch (Exception e)
 			{
-				Console.WriteLine(e);
+				Debug.WriteLine(e);
 				throw;
 			}
 			finally
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index b1e4ca93..8b17d1fa 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -43,7 +43,7 @@ private GraphQLHttpClient GetGraphQLClient(int port)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
-			} );
+			});
 
 
 		[Fact]

From f8e18651dc5921de1d5e7b208dc782650722cd70 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 14:25:57 +0100
Subject: [PATCH 28/49] add obsolete parameterless constructor to
 GraphQLRequest

---
 root.props                                   | 2 +-
 src/GraphQL.Common/Request/GraphQLRequest.cs | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 91fe5186..6d2e4399 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4</Version>
+		<Version>2.0.0-alpha.4.subscription-api.2</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index 244672f8..18d9f16b 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -33,6 +33,11 @@ public GraphQLRequest(string query){
 			this.Query = query;
 		}
 
+		[Obsolete("this constructor will be removed in a future version!")]
+		public GraphQLRequest() {
+			this.Query = string.Empty;
+		}
+
 		/// <inheritdoc />
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest);
 

From 632a45d5dc18a34d070ec657eecc5f76d57114e5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 15:03:00 +0100
Subject: [PATCH 29/49] add debug output in websocket receive

---
 root.props                                      | 2 +-
 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs | 7 ++-----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/root.props b/root.props
index 6d2e4399..055ec330 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.2</Version>
+		<Version>2.0.0-alpha.4.subscription-api.3</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 4ed3d5ee..9ab2d3f2 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -190,17 +190,14 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
 				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
 				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+				Debug.WriteLine($"websocket data received: {stringResult}");
 				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 			}
 			catch (Exception e)
 			{
-				Debug.WriteLine(e);
+				Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
 				throw;
 			}
-			finally
-			{
-				Debug.WriteLine("websocket data received");
-			}
 		}
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)

From f8021af51c591d6cc4fcbc8f6600b12a42fc3d27 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 16:47:16 +0100
Subject: [PATCH 30/49] reuse observables for identical requests

---
 .../Program.cs                                | 59 ++++++++++++++-----
 ...iptionIntegrationTest.ConsoleClient.csproj |  7 ++-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 16 ++++-
 src/GraphQL.Common/Request/GraphQLRequest.cs  | 13 +++-
 .../IntegrationTestServer.csproj              |  8 +--
 5 files changed, 79 insertions(+), 24 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 961ad1d3..dcea2a98 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Reactive.Disposables;
+using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 
@@ -6,13 +8,45 @@ namespace SubsccriptionIntegrationTest.ConsoleClient
 {
 	class Program
 	{
-		static void Main(string[] args)
+		static async Task Main(string[] args)
 		{
 			Console.WriteLine("configuring client ...");
 			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
 			{
+
+				Console.WriteLine("subscribing to message stream ...");
+
+				var subscriptions = new CompositeDisposable();
+
+				subscriptions.Add(CreateSubscription("1", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("2", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("3", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("4", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("5", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("6", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("7", client));
+				//await Task.Delay(1000);
+
+				using (subscriptions)
+				{
+					Console.WriteLine("client setup complete");
+					Console.WriteLine("press any key to exit");
+					Console.Read();
+					Console.WriteLine("shutting down ...");
+				}
+			}
+		}
+
+		private static IDisposable CreateSubscription(string id, GraphQLHttpClient client)
+		{
 #pragma warning disable 618
-				var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
 						subscription {
 							messageAdded{
 							content
@@ -21,22 +55,15 @@ static void Main(string[] args)
 							}
 							}
 						}"
-					),
-					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+				),
+				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
 #pragma warning restore 618
 
-				Console.WriteLine("subscribing to message stream ...");
-				using (var subscription = stream.Subscribe(
-					response => Console.WriteLine($"new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
-					exception => Console.WriteLine($"message subscription stream failed: {exception}"),
-					() => Console.WriteLine($"message subscription stream completed")))
-				{
-					Console.WriteLine("client setup complete");
-					Console.WriteLine("press any key to exit");
-					Console.Read();
-					Console.WriteLine("shutting down ...");
-				}
-			}
+			return stream.Subscribe(
+				response => Console.WriteLine($"{id}: new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
+				exception => Console.WriteLine($"{id}: message subscription stream failed: {exception}"),
+				() => Console.WriteLine($"{id}: message subscription stream completed"));
+			
 		}
 	}
 }
diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
index 21901c2f..83d4884b 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -2,9 +2,14 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFrameworks>netcoreapp3.0;net461</TargetFrameworks>
+	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\src\GraphQL.Client\GraphQL.Client.csproj" />
     <ProjectReference Include="..\src\GraphQL.Common\GraphQL.Common.csproj" />
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 255b3d6e..bbd003b2 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
@@ -152,8 +153,13 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
+			if (subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
+			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
 				Options, cancellationToken: _cancellationTokenSource.Token);
+			subscriptionStreams.Add(request, observable);
+			return observable;
 		}
 
 		/// <inheritdoc />
@@ -162,7 +168,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		{
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
+					   
 			return CreateSubscriptionStream(request, e =>
 			{
 				if (e is WebSocketException webSocketException)
@@ -179,10 +185,16 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
+			if(subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
 			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
+			subscriptionStreams.Add(request, observable);
 			return observable;
 		}
 
+		private Dictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new Dictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index 18d9f16b..2a1bddc0 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -52,7 +52,18 @@ public bool Equals(GraphQLRequest? other) {
 		}
 
 		/// <inheritdoc />
-		public override int GetHashCode() => EqualityComparer<GraphQLRequest>.Default.GetHashCode(this);
+		//public override int GetHashCode() => EqualityComparer<GraphQLRequest>.Default.GetHashCode(this);
+
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				var hashCode = EqualityComparer<string?>.Default.GetHashCode(Query);
+				hashCode = (hashCode * 397) ^ EqualityComparer<string?>.Default.GetHashCode(OperationName);
+				hashCode = (hashCode * 397) ^ EqualityComparer<dynamic?>.Default.GetHashCode(Variables);
+				return hashCode;
+			}
+		}
 
 		/// <inheritdoc />
 		public static bool operator ==(GraphQLRequest? request1, GraphQLRequest? request2) => EqualityComparer<GraphQLRequest?>.Default.Equals(request1, request2);
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 179554ff..3a733458 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -9,10 +9,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
     <PackageReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
     <PackageReference Include="System.Reactive" Version="4.1.2" />

From 95d33193b7b2fdbe828d5ab380a666fb3d07f6c8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 23 Jan 2019 11:33:58 +0100
Subject: [PATCH 31/49] store changes to consoleapp

---
 .../Program.cs                                | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index dcea2a98..5d96b32b 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Reactive.Disposables;
+using System.Reactive.Linq;
 using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
@@ -19,19 +20,19 @@ static async Task Main(string[] args)
 				var subscriptions = new CompositeDisposable();
 
 				subscriptions.Add(CreateSubscription("1", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("2", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("3", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("4", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("5", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("6", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("7", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 
 				using (subscriptions)
 				{
@@ -55,7 +56,9 @@ private static IDisposable CreateSubscription(string id, GraphQLHttpClient clien
 							}
 							}
 						}"
-				),
+				)
+			//{ Variables = new { id } }
+			,
 				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
 #pragma warning restore 618
 

From abd9cafdc6d31a7391273030d2360cb4a5fd1c50 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 23 Jan 2019 11:36:07 +0100
Subject: [PATCH 32/49] fix StackOverflowException in
 GraphQLRequest.GetHashCode()

---
 src/GraphQL.Common/Request/GraphQLRequest.cs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index 244672f8..d60065ac 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -47,7 +47,16 @@ public bool Equals(GraphQLRequest? other) {
 		}
 
 		/// <inheritdoc />
-		public override int GetHashCode() => EqualityComparer<GraphQLRequest>.Default.GetHashCode(this);
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				var hashCode = EqualityComparer<string?>.Default.GetHashCode(Query);
+				hashCode = (hashCode * 397) ^ EqualityComparer<string?>.Default.GetHashCode(OperationName);
+				hashCode = (hashCode * 397) ^ EqualityComparer<dynamic?>.Default.GetHashCode(Variables);
+				return hashCode;
+			}
+		}
 
 		/// <inheritdoc />
 		public static bool operator ==(GraphQLRequest? request1, GraphQLRequest? request2) => EqualityComparer<GraphQLRequest?>.Default.Equals(request1, request2);

From 93fae18e4098d675372c992acbff66775fd803e3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 24 Jan 2019 14:46:48 +0100
Subject: [PATCH 33/49] fix receiving long messages via websocket

---
 .../Program.cs                                | 12 +++---
 .../Http/GraphQLHttpWebSocket.cs              | 43 ++++++++++++++-----
 .../IntegrationTestServer.csproj              |  1 +
 tests/IntegrationTestServer/Startup.cs        |  5 +++
 4 files changed, 45 insertions(+), 16 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 5d96b32b..87c557df 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -48,16 +48,16 @@ private static IDisposable CreateSubscription(string id, GraphQLHttpClient clien
 		{
 #pragma warning disable 618
 			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
-						subscription {
-							messageAdded{
-							content
+					subscription {
+						messageAdded{
+						content
 							from {
 								displayName
 							}
-							}
-						}"
+						}
+					}"
 				)
-			//{ Variables = new { id } }
+			{ Variables = new { id } }
 			,
 				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
 #pragma warning restore 618
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 9ab2d3f2..76135bc5 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Net.WebSockets;
 using System.Reactive;
 using System.Reactive.Disposables;
@@ -19,8 +21,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 	{
 		private readonly Uri webSocketUri;
 		private readonly GraphQLHttpClientOptions _options;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-		private readonly ArraySegment<byte> arraySegment;
+		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
@@ -36,7 +37,7 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
 			this.webSocketUri = webSocketUri;
 			_options = options;
-			arraySegment = new ArraySegment<byte>(buffer);
+			buffer = new ArraySegment<byte>(new byte[8192]);
 			ResponseStream = _createResponseStream();
 
 			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
@@ -185,13 +186,35 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 			try
 			{
 				Debug.WriteLine("receiving websocket data ...");
-				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var webSocketReceiveResult =
-					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
-				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-				Debug.WriteLine($"websocket data received: {stringResult}");
-				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+				WebSocketReceiveResult webSocketReceiveResult = null;
+
+				using (var ms = new MemoryStream())
+				{
+					do
+					{
+						_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
+						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
+					}
+					while (!webSocketReceiveResult.EndOfMessage);
+
+					_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+					ms.Seek(0, SeekOrigin.Begin);
+
+					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
+					{
+						using (var reader = new StreamReader(ms, Encoding.UTF8))
+						{
+							var stringResult = await reader.ReadToEndAsync();
+							Debug.WriteLine($"websocket data received: {stringResult}");
+							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+						}
+					}
+					else
+					{
+						throw new NotSupportedException("binary websocket messages are not supported");
+					}
+				}				
 			}
 			catch (Exception e)
 			{
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 3a733458..6d78ae48 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -12,6 +12,7 @@
     <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
     <PackageReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 0161c739..166bf202 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,6 +1,7 @@
 using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Voyager;
+using GraphQL.Server.Ui.Playground;
 using IntegrationTestServer.ChatSchema;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -63,6 +64,10 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 				GraphQLEndPoint = "/graphql",
 				Path = "/ui/voyager"
 			});
+			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions
+			{
+				Path = "/ui/playground"
+			});
 			app.UseMvc();
 		}
 	}

From 34db7a4f3acad2dc90df6462ba2f2c747293bbc6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 24 Jan 2019 15:01:50 +0100
Subject: [PATCH 34/49] add obsolete constructor

---
 src/GraphQL.Common/Request/GraphQLRequest.cs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index d60065ac..d04f1992 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -33,6 +33,15 @@ public GraphQLRequest(string query){
 			this.Query = query;
 		}
 
+		/// <summary>
+		/// Initialize a new GraphQLRequest
+		/// </summary>
+		[Obsolete("Pass query as parameter! This constructor will be removed in a future version!")]
+		public GraphQLRequest()
+		{
+			this.Query = string.Empty;
+		}
+
 		/// <inheritdoc />
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest);
 

From ca4216d08b398c059ae4997c5df2992d8a0ef737 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 25 Jan 2019 11:50:42 +0100
Subject: [PATCH 35/49] make ReceiveResultStream observable Hot

---
 .../Program.cs                                | 47 ++++++++++++++-----
 root.props                                    |  2 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  4 +-
 .../Http/GraphQLHttpWebSocket.cs              | 15 +++---
 .../SubscriptionsTest.cs                      | 31 ++++++------
 .../ChatSchema/ChatSubscriptions.cs           | 10 +++-
 .../IntegrationTestServer.csproj              |  3 +-
 tests/IntegrationTestServer/Program.cs        |  4 +-
 8 files changed, 77 insertions(+), 39 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 87c557df..28ade711 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -20,19 +20,12 @@ static async Task Main(string[] args)
 				var subscriptions = new CompositeDisposable();
 
 				subscriptions.Add(CreateSubscription("1", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("2", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("3", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("4", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("5", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("6", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("7", client));
-				await Task.Delay(1000);
+				//subscriptions.Add(CreateSubscription2("2", client));
+				//subscriptions.Add(CreateSubscription("3", client));
+				//subscriptions.Add(CreateSubscription("4", client));
+				//subscriptions.Add(CreateSubscription("5", client));
+				//subscriptions.Add(CreateSubscription("6", client));
+				//subscriptions.Add(CreateSubscription("7", client));
 
 				using (subscriptions)
 				{
@@ -41,7 +34,9 @@ static async Task Main(string[] args)
 					Console.Read();
 					Console.WriteLine("shutting down ...");
 				}
+				Console.WriteLine("subscriptions disposed ...");
 			}
+			Console.WriteLine("client disposed ...");
 		}
 
 		private static IDisposable CreateSubscription(string id, GraphQLHttpClient client)
@@ -68,5 +63,31 @@ private static IDisposable CreateSubscription(string id, GraphQLHttpClient clien
 				() => Console.WriteLine($"{id}: message subscription stream completed"));
 			
 		}
+
+
+		private static IDisposable CreateSubscription2(string id, GraphQLHttpClient client)
+		{
+#pragma warning disable 618
+			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+					subscription {
+						contentAdded{
+						content
+							from {
+								displayName
+							}
+						}
+					}"
+				)
+			{ Variables = new { id } }
+			,
+				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+#pragma warning restore 618
+
+			return stream.Subscribe(
+				response => Console.WriteLine($"{id}: new content from \"{response.Data.contentAdded.from.displayName.Value}\": {response.Data.contentAdded.content.Value}"),
+				exception => Console.WriteLine($"{id}: content subscription stream failed: {exception}"),
+				() => Console.WriteLine($"{id}: content subscription stream completed"));
+
+		}
 	}
 }
diff --git a/root.props b/root.props
index 055ec330..7f52c061 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.3</Version>
+		<Version>2.0.0-alpha.4.subscription-api.5</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 10b2e501..03a57dc1 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -35,7 +35,9 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
 					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => response != null && response.Id == startRequest.Id)
+						.Where(response => {
+							return response != null && response.Id == startRequest.Id;
+						})
 						.SelectMany(response =>
 						{
 							switch (response.Type)
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 76135bc5..ae747161 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -1,9 +1,7 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Net.WebSockets;
-using System.Reactive;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
@@ -63,8 +61,11 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
 
 				await InitializeWebSocket().ConfigureAwait(false);
 				var webSocketRequestString = JsonConvert.SerializeObject(request);
-				var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-				await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+				await this.clientWebSocket.SendAsync(
+					new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString)),
+					WebSocketMessageType.Text,
+					true,
+					_cancellationTokenSource.Token).ConfigureAwait(false);
 				request.SendCompleted();
 			}
 			catch (Exception e)
@@ -149,7 +150,7 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
 		{
 			await InitializeWebSocket().ConfigureAwait(false);
-			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
+			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat().Publish().RefCount();
 		}
 
 		private async Task _connectAsync(CancellationToken token)
@@ -185,7 +186,7 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
 			try
 			{
-				Debug.WriteLine("receiving websocket data ...");
+				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");
 				WebSocketReceiveResult webSocketReceiveResult = null;
 
 				using (var ms = new MemoryStream())
@@ -206,7 +207,7 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 						using (var reader = new StreamReader(ms, Encoding.UTF8))
 						{
 							var stringResult = await reader.ReadToEndAsync();
-							Debug.WriteLine($"websocket data received: {stringResult}");
+							Debug.WriteLine($"data received on websocket {clientWebSocket.GetHashCode()}: {stringResult}");
 							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 						}
 					}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 8b17d1fa..6a896479 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -22,7 +22,10 @@ public static IWebHost CreateServer(int port)
 			config["server.urls"] = $"http://localhost:{port}";
 
 			var host = new WebHostBuilder()
-				.ConfigureLogging((ctx, logging) => logging.AddDebug())
+				.ConfigureLogging((ctx, logging) =>
+				{
+					logging.AddDebug();
+				})
 				.UseConfiguration(config)
 				.UseKestrel()
 				.UseStartup<IntegrationTestServer.Startup>()
@@ -160,7 +163,7 @@ public async void CanReconnectWithSameObservable()
 
 		private const string SubscriptionQuery2 = @"
 			subscription {
-			  messageAdded{
+			  contentAdded{
 			    content
 				from {
 				  displayName
@@ -171,7 +174,7 @@ public async void CanReconnectWithSameObservable()
 		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 		[Fact]
-		public async void CanConnectMultipleSubscriptionsSimultaneously()
+		public async void CanConnectTwoSubscriptionsSimultaneously()
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var callbackTester = new CallbackTester<Exception>();
@@ -181,10 +184,10 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse> observable1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
 
 				Debug.WriteLine("subscribing...");
-				var tester = subscription1.SubscribeTester();
+				var tester = observable1.SubscribeTester();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
@@ -194,13 +197,13 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
-				var tester2 = subscription2.SubscribeTester();
+				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
+				var tester2 = observable2.SubscribeTester();
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
-				}, TimeSpan.FromSeconds(10));
+					Assert.Equal(message1, (string)gqlResponse.Data.contentAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
+				});
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
@@ -211,8 +214,8 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				});
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+					Assert.Equal(message2, (string)gqlResponse.Data.contentAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
 				});
 
 				Debug.WriteLine("disposing subscription...");
@@ -223,8 +226,8 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+					Assert.Equal(message3, (string)gqlResponse.Data.contentAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
 				});
 
 				// disposing the client should complete the subscription
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 3c8c9624..5a081515 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -25,7 +25,15 @@ public ChatSubscriptions(IChat chat)
                 Subscriber = new EventStreamResolver<Message>(Subscribe)
             });
 
-            AddField(new EventStreamFieldType
+			AddField(new EventStreamFieldType
+			{
+				Name = "contentAdded",
+				Type = typeof(MessageType),
+				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+				Subscriber = new EventStreamResolver<Message>(Subscribe)
+			});
+
+			AddField(new EventStreamFieldType
             {
                 Name = "messageAddedByUser",
                 Arguments = new QueryArguments(
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 6d78ae48..e0f21c49 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -10,7 +10,8 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.1-1.multiple-subscriptions.2" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index fd8448a8..9b0392b7 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Logging;
 
 namespace IntegrationTestServer
 {
@@ -12,6 +13,7 @@ public static void Main(string[] args)
 
 		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
 			WebHost.CreateDefaultBuilder(args)
-				.UseStartup<Startup>();
+				.UseStartup<Startup>()
+			    .ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
 	}
 }

From acb36a1b7f483ba142ff7433e63b81c4be55b555 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 25 Jan 2019 13:23:37 +0100
Subject: [PATCH 36/49] fix multiple subscriptions by using subject in
 GraphQLHttpWebSocket

---
 .../Program.cs                                | 12 ++++-----
 .../Http/GraphQLHttpWebSocket.cs              | 27 ++++++++++++++-----
 2 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 28ade711..758797d4 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -20,12 +20,12 @@ static async Task Main(string[] args)
 				var subscriptions = new CompositeDisposable();
 
 				subscriptions.Add(CreateSubscription("1", client));
-				//subscriptions.Add(CreateSubscription2("2", client));
-				//subscriptions.Add(CreateSubscription("3", client));
-				//subscriptions.Add(CreateSubscription("4", client));
-				//subscriptions.Add(CreateSubscription("5", client));
-				//subscriptions.Add(CreateSubscription("6", client));
-				//subscriptions.Add(CreateSubscription("7", client));
+				subscriptions.Add(CreateSubscription2("2", client));
+				subscriptions.Add(CreateSubscription("3", client));
+				subscriptions.Add(CreateSubscription("4", client));
+				subscriptions.Add(CreateSubscription("5", client));
+				subscriptions.Add(CreateSubscription("6", client));
+				subscriptions.Add(CreateSubscription("7", client));
 
 				using (subscriptions)
 				{
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index ae747161..f8190e94 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -22,7 +22,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
-		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+		private Subject<GraphQLWebSocketResponse> _responseSubject;
 		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
 		private IDisposable _requestSubscription;
 
@@ -36,12 +36,14 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 			this.webSocketUri = webSocketUri;
 			_options = options;
 			buffer = new ArraySegment<byte>(new byte[8192]);
-			ResponseStream = _createResponseStream();
+			_responseStream = _createResponseStream();
 
 			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
-		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+		public IObservable<GraphQLWebSocketResponse> ResponseStream => _responseStream;
+		public IObservable<GraphQLWebSocketResponse> _responseStream;
+		//private IDisposable _responseStreamConnection;
 
 		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
@@ -106,6 +108,7 @@ public Task InitializeWebSocket()
 				return Task.CompletedTask;
 
 			// else (re-)create websocket and connect
+			//_responseStreamConnection?.Dispose();
 			clientWebSocket?.Dispose();
 
 			// fix websocket not supported on win 7 using
@@ -125,7 +128,7 @@ public Task InitializeWebSocket()
 
 			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 		}
-
+		
 		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 		{
 			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
@@ -136,10 +139,19 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 
 		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
 		{
-			var observable = await _getReceiveResultStream().ConfigureAwait(false);
+			if (_responseSubject == null || _responseSubject.IsDisposed)
+			{
+				_responseSubject = new Subject<GraphQLWebSocketResponse>();
+				var observable = await _getReceiveResultStream().ConfigureAwait(false);
+				observable.Subscribe(_responseSubject);
+			}
+					   
 			return new CompositeDisposable
 			(
-				observable.Subscribe(observer),
+				_responseSubject.Finally(() => {
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				}).Subscribe(observer),
 				Disposable.Create(() =>
 				{
 					Debug.WriteLine("response stream disposed");
@@ -150,7 +162,7 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
 		{
 			await InitializeWebSocket().ConfigureAwait(false);
-			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat().Publish().RefCount();
+			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
 		}
 
 		private async Task _connectAsync(CancellationToken token)
@@ -159,6 +171,7 @@ private async Task _connectAsync(CancellationToken token)
 			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
 			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+			//_responseStreamConnection = _responseStream.Connect();
 			_connectionAttempt = 1;
 		}
 

From e70f7a40d7a862cc2a4b6395fc58829126cc035d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 25 Jan 2019 13:31:09 +0100
Subject: [PATCH 37/49] fix overlapping subscriptions

---
 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index f8190e94..d7e88bac 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -144,14 +144,21 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 				_responseSubject = new Subject<GraphQLWebSocketResponse>();
 				var observable = await _getReceiveResultStream().ConfigureAwait(false);
 				observable.Subscribe(_responseSubject);
+
+				_responseSubject.Subscribe(_ => { }, ex =>
+				{
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				},
+				() => {
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				});
 			}
 					   
 			return new CompositeDisposable
 			(
-				_responseSubject.Finally(() => {
-					_responseSubject?.Dispose();
-					_responseSubject = null;
-				}).Subscribe(observer),
+				_responseSubject.Subscribe(observer),
 				Disposable.Create(() =>
 				{
 					Debug.WriteLine("response stream disposed");

From 2fbd83d0e43e1abe8b61d121fc28f4e90babf94d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 10:11:22 +0100
Subject: [PATCH 38/49] fix subscription test to work arround
 https://github.com/graphql-dotnet/server/pull/199

---
 root.props                                    |  2 +-
 .../GraphQLClientExtensions.cs                | 18 ++++++++
 .../SubscriptionsTest.cs                      | 44 +++++++------------
 .../ChatSchema/ChatMutation.cs                | 13 +++++-
 .../ChatSchema/ChatSubscriptions.cs           | 10 ++++-
 .../IntegrationTestServer/ChatSchema/IChat.cs | 43 +++++++++++++++---
 .../IntegrationTestServer.csproj              |  2 +-
 7 files changed, 95 insertions(+), 37 deletions(-)

diff --git a/root.props b/root.props
index 7f52c061..5059adb1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.5</Version>
+		<Version>2.0.0-alpha.4.subscription-api.6</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index 065b4a5c..ff71ee6d 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -29,5 +29,23 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 			};
 			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
 		}
+
+		public static async Task<GraphQLResponse> JoinDeveloperUser(this GraphQLHttpClient client)
+		{
+			var graphQLRequest = new GraphQLRequest(@"
+				mutation($userId: String){
+				  join(userId: $userId){
+				    displayName
+				    id
+				  }
+				}")
+			{
+				Variables = new
+				{
+					userId = "1"
+				}
+			};
+			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 6a896479..635a0d1c 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -2,6 +2,7 @@
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Threading;
+using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
@@ -163,11 +164,9 @@ public async void CanReconnectWithSameObservable()
 
 		private const string SubscriptionQuery2 = @"
 			subscription {
-			  contentAdded{
-			    content
-				from {
-				  displayName
-				}
+			  userJoined{
+				displayName
+				id
 			  }
 			}";
 
@@ -185,9 +184,11 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse> observable1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable1.SubscribeTester();
+				var tester2 = observable2.SubscribeTester();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
@@ -197,42 +198,31 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
-				var tester2 = observable2.SubscribeTester();
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
-					Assert.Equal(message1, (string)gqlResponse.Data.contentAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
-				});
+				await Task.Delay(500); // ToDo: can be removed after https://github.com/graphql-dotnet/server/pull/199 was merged and released
+
+				response = await client.JoinDeveloperUser().ConfigureAwait(false);
+				Assert.Equal("developer", (string)response.Data.join.displayName.Value);
 
-				const string message2 = "How are you?";
-				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-				});
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.contentAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
+					Assert.Equal("1", (string)gqlResponse.Data.userJoined.id.Value);
+					Assert.Equal("developer", (string)gqlResponse.Data.userJoined.displayName.Value);
 				});
-
+				
 				Debug.WriteLine("disposing subscription...");
-				tester.Dispose();
+				tester2.Dispose();
 
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message3, (string)gqlResponse.Data.contentAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
+					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
 				// disposing the client should complete the subscription
 				client.Dispose();
-				tester2.ShouldHaveCompleted();
+				tester.ShouldHaveCompleted();
 			}
 		}
 
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
index 7c2a2333..0ca1dfbd 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -16,7 +16,18 @@ public ChatMutation(IChat chat)
                     var message = chat.AddMessage(receivedMessage);
                     return message;
                 });
-        }
+
+			Field<MessageFromType>("join",
+				arguments: new QueryArguments(
+					new QueryArgument<StringGraphType> { Name = "userId" }
+				),
+				resolve: context =>
+				{
+					var userId = context.GetArgument<string>("userId");
+					var userJoined = chat.Join(userId);
+					return userJoined;
+				});
+		}
     }
 
     public class MessageInputType : InputObjectGraphType
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 5a081515..0ceb77a5 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -43,7 +43,15 @@ public ChatSubscriptions(IChat chat)
                 Resolver = new FuncFieldResolver<Message>(ResolveMessage),
                 Subscriber = new EventStreamResolver<Message>(SubscribeById)
             });
-        }
+
+			AddField(new EventStreamFieldType
+			{
+				Name = "userJoined",
+				Type = typeof(MessageFromType),
+				Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
+				Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
+			});
+		}
 
         private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
         {
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
index 68c8e86b..e52c0432 100644
--- a/tests/IntegrationTestServer/ChatSchema/IChat.cs
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -11,16 +11,20 @@ public interface IChat
 
         Message AddMessage(Message message);
 
-        IObservable<Message> Messages(string user);
+		MessageFrom Join(string userId);
 
-        Message AddMessage(ReceivedMessage message);
+		IObservable<Message> Messages(string user);
+		IObservable<MessageFrom> UserJoined();
+
+		Message AddMessage(ReceivedMessage message);
     }
 
     public class Chat : IChat
     {
         private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+		private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
 
-        public Chat()
+		public Chat()
         {
             AllMessages = new ConcurrentStack<Message>();
             Users = new ConcurrentDictionary<string, string>
@@ -58,9 +62,25 @@ public Message AddMessage(Message message)
             AllMessages.Push(message);
             _messageStream.OnNext(message);
             return message;
-        }
+		}
+
+		public MessageFrom Join(string userId)
+		{
+			if (!Users.TryGetValue(userId, out var displayName))
+			{
+				displayName = "(unknown)";
+			}
+
+			var joinedUser = new MessageFrom {
+				Id = userId,
+				DisplayName = displayName
+			};
 
-        public IObservable<Message> Messages(string user)
+			_userJoined.OnNext(joinedUser);
+			return joinedUser;
+		}
+
+		public IObservable<Message> Messages(string user)
         {
             return _messageStream
                 .Select(message =>
@@ -75,5 +95,16 @@ public void AddError(Exception exception)
         {
             _messageStream.OnError(exception);
         }
-    }
+
+		public IObservable<MessageFrom> UserJoined()
+		{
+			return _userJoined.AsObservable();
+		}
+	}
+
+	public class User
+	{
+		public string Id { get; set; }
+		public string Name { get; set; }
+	}
 }
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index e0f21c49..cfba48cd 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -11,7 +11,7 @@
   <ItemGroup>
     <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.1-1.multiple-subscriptions.2" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />

From e1ba20a5c91cfa5a24c3264ad6f16eb6249eb75f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 10:25:58 +0100
Subject: [PATCH 39/49] add an observable which publishes all websocket
 exceptions

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs    |  4 ++++
 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs | 11 ++++++++++-
 src/GraphQL.Client/IGraphQLClient.cs            |  6 ++++++
 3 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index bbd003b2..f522003c 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -39,6 +39,10 @@ public GraphQLHttpClientOptions Options {
 			set => this.graphQLHttpHandler.Options = value;
 		}
 
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL")]
+		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
+
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index d7e88bac..d6426f64 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -24,6 +24,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 
 		private Subject<GraphQLWebSocketResponse> _responseSubject;
 		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private Subject<Exception> _exceptionSubject = new Subject<Exception>();
 		private IDisposable _requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
@@ -41,6 +42,8 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
+		public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
+
 		public IObservable<GraphQLWebSocketResponse> ResponseStream => _responseStream;
 		public IObservable<GraphQLWebSocketResponse> _responseStream;
 		//private IDisposable _responseStreamConnection;
@@ -134,7 +137,13 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
 				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLWebSocketResponse>());
+					Observable.Empty<GraphQLWebSocketResponse>())
+				.Catch<GraphQLWebSocketResponse, Exception>(e =>
+					{
+						// post all exceptions in this stream to the exception subject, so they can be received on the outside
+						_exceptionSubject.OnNext(e);
+						return Observable.Throw<GraphQLWebSocketResponse>(e);
+					});
 		}
 
 		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 60af36ab..098d0524 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -72,6 +72,12 @@ public interface IGraphQLClient : IDisposable {
 		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
+
+		/// <summary>
+		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
+		/// </summary>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<Exception> WebSocketReceiveErrors { get; }
 	}
 
 }

From 7984248b91f1bb292f877b941498dbcf1e7872d6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 10:43:05 +0100
Subject: [PATCH 40/49] fix OnNext calls of exceptionSubject

---
 .../Program.cs                                | 16 ++++++----
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 15 ++++++----
 .../Http/GraphQLHttpWebSocket.cs              | 29 ++++++++++---------
 3 files changed, 36 insertions(+), 24 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 758797d4..d7391d06 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
@@ -19,6 +20,13 @@ static async Task Main(string[] args)
 
 				var subscriptions = new CompositeDisposable();
 
+				subscriptions.Add(client.WebSocketReceiveErrors.Subscribe(e => {
+					if(e is WebSocketException we)
+						Console.WriteLine($"WebSocketException: {we.Message} (WebSocketError {we.WebSocketErrorCode}, ErrorCode {we.ErrorCode}, NativeErrorCode {we.NativeErrorCode}");
+					else
+						Console.WriteLine($"Exception in websocket receive stream: {e.ToString()}");
+				}));
+
 				subscriptions.Add(CreateSubscription("1", client));
 				subscriptions.Add(CreateSubscription2("2", client));
 				subscriptions.Add(CreateSubscription("3", client));
@@ -52,9 +60,7 @@ private static IDisposable CreateSubscription(string id, GraphQLHttpClient clien
 						}
 					}"
 				)
-			{ Variables = new { id } }
-			,
-				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+			{ Variables = new { id } });
 #pragma warning restore 618
 
 			return stream.Subscribe(
@@ -78,9 +84,7 @@ private static IDisposable CreateSubscription2(string id, GraphQLHttpClient clie
 						}
 					}"
 				)
-			{ Variables = new { id } }
-			,
-				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+			{ Variables = new { id } });
 #pragma warning restore 618
 
 			return stream.Subscribe(
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 03a57dc1..d6d98ee0 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -108,11 +108,16 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				{
 					try
 					{
-						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
-						if (exceptionHandler == null) throw e;
-
-						// exceptions thrown by the handler will propagate to OnError()
-						exceptionHandler?.Invoke(e);
+						if (exceptionHandler == null) {
+							// if the external handler is not set, propagate all exceptions except WebSocketExceptions
+							// this will ensure that the client tries to re-establish subscriptions on connection loss
+							if (!(e is WebSocketException)) throw e;
+						}
+						else
+						{
+							// exceptions thrown by the handler will propagate to OnError()
+							exceptionHandler?.Invoke(e);
+						}
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return cancellationToken.IsCancellationRequested
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index d6426f64..90caf737 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -137,13 +137,7 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
 				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLWebSocketResponse>())
-				.Catch<GraphQLWebSocketResponse, Exception>(e =>
-					{
-						// post all exceptions in this stream to the exception subject, so they can be received on the outside
-						_exceptionSubject.OnNext(e);
-						return Observable.Throw<GraphQLWebSocketResponse>(e);
-					});
+					Observable.Empty<GraphQLWebSocketResponse>());
 		}
 
 		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
@@ -156,6 +150,7 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 
 				_responseSubject.Subscribe(_ => { }, ex =>
 				{
+					_exceptionSubject.OnNext(ex);
 					_responseSubject?.Dispose();
 					_responseSubject = null;
 				},
@@ -183,12 +178,20 @@ private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStrea
 
 		private async Task _connectAsync(CancellationToken token)
 		{
-			await _backOff().ConfigureAwait(false);
-			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
-			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
-			//_responseStreamConnection = _responseStream.Connect();
-			_connectionAttempt = 1;
+			try
+			{
+				await _backOff().ConfigureAwait(false);
+				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
+				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+				//_responseStreamConnection = _responseStream.Connect();
+				_connectionAttempt = 1;
+			}
+			catch (Exception e)
+			{
+				_exceptionSubject.OnNext(e);
+				throw;
+			}
 		}
 
 

From ef37543dc285fdcfef274316d5a59174753cf37f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 11:14:52 +0100
Subject: [PATCH 41/49] fix GraphQLHttpClient(Uri endPoint,
 GraphQLHttpClientOptions options) constructor

---
 .../Program.cs                                |  6 ++
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 27 ++++---
 .../Http/GraphQLHttpClientOptions.cs          |  5 ++
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 73 ++++++++++++++++++-
 4 files changed, 101 insertions(+), 10 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index d7391d06..51cd62ae 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -28,11 +28,17 @@ static async Task Main(string[] args)
 				}));
 
 				subscriptions.Add(CreateSubscription("1", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription2("2", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("3", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("4", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("5", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("6", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("7", client));
 
 				using (subscriptions)
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index f522003c..e6a76359 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -74,13 +74,14 @@ public GraphQLHttpClient(string endPoint, GraphQLHttpClientOptions options) : th
 		/// <param name="endPoint">The EndPoint to be used</param>
 		/// <param name="options">The Options to be used</param>
 		public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
+
+			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
+
 			if (options == null) { throw new ArgumentNullException(nameof(options)); }
-			if (options.EndPoint == null) { throw new ArgumentNullException(nameof(options.EndPoint)); }
 			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
 			if (options.HttpMessageHandler == null) { throw new ArgumentNullException(nameof(options.HttpMessageHandler)); }
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
-			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
@@ -114,14 +115,22 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
 			this.SendQueryAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-			this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		}
 
 		public Task<GraphQLResponse> SendMutationAsync(string query, CancellationToken cancellationToken = default) =>
 			this.SendMutationAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-			this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		}
 
 		[Obsolete("EXPERIMENTAL API")]
 		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, CancellationToken cancellationToken = default) =>
@@ -160,8 +169,8 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (subscriptionStreams.ContainsKey(request))
 				return subscriptionStreams[request];
 
-			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
-				Options, cancellationToken: _cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
+
 			subscriptionStreams.Add(request, observable);
 			return observable;
 		}
@@ -192,7 +201,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if(subscriptionStreams.ContainsKey(request))
 				return subscriptionStreams[request];
 
-			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
 			subscriptionStreams.Add(request, observable);
 			return observable;
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 38008421..ddce13c7 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -49,6 +49,11 @@ public class GraphQLHttpClientOptions {
 			var rnd = new Random();
 			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
 		};
+
+		/// <summary>
+		/// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
+		/// </summary>
+		public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index d6d98ee0..f57cb741 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -4,6 +4,7 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
@@ -14,8 +15,8 @@ namespace GraphQL.Client.Http
 	public static class GraphQLHttpSubscriptionHelpers
 	{
 		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
-			GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLHttpClientOptions options,
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
@@ -146,5 +147,75 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
+
+		internal static async Task<GraphQLResponse> Request(
+			this GraphQLHttpWebSocket graphQlHttpWebSocket,
+			GraphQLRequest request,
+			CancellationToken cancellationToken = default)
+		{
+			return await Observable.Create<GraphQLResponse>(async observer =>
+			{
+				var websocketRequest = new GraphQLWebSocketRequest
+				{
+					Id = Guid.NewGuid().ToString("N"),
+					Type = GQLWebSocketMessageType.GQL_START,
+					Payload = request
+				};
+				var observable = graphQlHttpWebSocket.ResponseStream
+					.Where(response => {
+						return response != null && response.Id == websocketRequest.Id;
+					})
+					.SelectMany(response =>
+					{
+						switch (response.Type)
+						{
+							case GQLWebSocketMessageType.GQL_COMPLETE:
+								Debug.WriteLine($"received 'complete' message on subscription {websocketRequest.Id}");
+								return Observable.Empty<GraphQLResponse>();
+							case GQLWebSocketMessageType.GQL_ERROR:
+								Debug.WriteLine($"received 'error' message on subscription {websocketRequest.Id}");
+								return Observable.Throw<GraphQLResponse>(
+									new GraphQLSubscriptionException(response.Payload));
+							default:
+								Debug.WriteLine($"received payload on subscription {websocketRequest.Id}");
+								return Observable.Return(((JObject)response?.Payload)
+									?.ToObject<GraphQLResponse>());
+						}
+					});
+
+				try
+				{
+					// intialize websocket (completes immediately if socket is already open)
+					await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+				}
+				catch (Exception e)
+				{
+					// subscribe observer to failed observable
+					return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+				}
+
+				var disposable = new CompositeDisposable(
+					observable.Subscribe(observer)
+				);
+
+				Debug.WriteLine($"sending initial message on subscription {websocketRequest.Id}");
+				// send subscription request
+				try
+				{
+					await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
+				}
+				catch (Exception e)
+				{
+					Console.WriteLine(e);
+					throw;
+				}
+
+				return disposable;
+			})
+			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+			.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+				Observable.Empty<GraphQLResponse>())
+			.FirstOrDefaultAsync();
+		}
 	}
 }

From 309a8e3e6308c9961012f022b8756cc83f889113 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 11:28:49 +0100
Subject: [PATCH 42/49] test requests via websockets

---
 .../Program.cs                                | 38 +++++++++++++++++--
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 10 ++---
 2 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 51cd62ae..95000512 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -13,7 +13,7 @@ class Program
 		static async Task Main(string[] args)
 		{
 			Console.WriteLine("configuring client ...");
-			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
+			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/", new GraphQLHttpClientOptions{ UseWebSocketForQueriesAndMutations = true }))
 			{
 
 				Console.WriteLine("subscribing to message stream ...");
@@ -44,8 +44,40 @@ static async Task Main(string[] args)
 				using (subscriptions)
 				{
 					Console.WriteLine("client setup complete");
-					Console.WriteLine("press any key to exit");
-					Console.Read();
+					var quit = false;
+					do
+					{
+						Console.WriteLine("write message and press enter...");
+						var message = Console.ReadLine();
+						var graphQLRequest = new GraphQLRequest(@"
+							mutation($input: MessageInputType){
+							  addMessage(message: $input){
+								content
+							  }
+							}")
+						{
+							Variables = new
+							{
+								input = new
+								{
+									fromId = "2",
+									content = message,
+									sentAt = DateTime.Now
+								}
+							}
+						};
+						var result = await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+
+						if(result.Errors != null && result.Errors.Length > 0)
+						{
+							Console.WriteLine($"request returned {result.Errors.Length} errors:");
+							foreach (var item in result.Errors)
+							{
+								Console.WriteLine($"{item.Message}");
+							}
+						}
+					}
+					while(!quit);
 					Console.WriteLine("shutting down ...");
 				}
 				Console.WriteLine("subscriptions disposed ...");
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index f57cb741..ef71a0ce 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -170,14 +170,14 @@ internal static async Task<GraphQLResponse> Request(
 						switch (response.Type)
 						{
 							case GQLWebSocketMessageType.GQL_COMPLETE:
-								Debug.WriteLine($"received 'complete' message on subscription {websocketRequest.Id}");
+								Debug.WriteLine($"received 'complete' message on request {websocketRequest.Id}");
 								return Observable.Empty<GraphQLResponse>();
 							case GQLWebSocketMessageType.GQL_ERROR:
-								Debug.WriteLine($"received 'error' message on subscription {websocketRequest.Id}");
+								Debug.WriteLine($"received 'error' message on request {websocketRequest.Id}");
 								return Observable.Throw<GraphQLResponse>(
 									new GraphQLSubscriptionException(response.Payload));
 							default:
-								Debug.WriteLine($"received payload on subscription {websocketRequest.Id}");
+								Debug.WriteLine($"received response for request {websocketRequest.Id}");
 								return Observable.Return(((JObject)response?.Payload)
 									?.ToObject<GraphQLResponse>());
 						}
@@ -198,8 +198,8 @@ internal static async Task<GraphQLResponse> Request(
 					observable.Subscribe(observer)
 				);
 
-				Debug.WriteLine($"sending initial message on subscription {websocketRequest.Id}");
-				// send subscription request
+				Debug.WriteLine($"submitting request {websocketRequest.Id}");
+				// send request
 				try
 				{
 					await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);

From b9c1443c7d9f9410352026e05e4ae01ab9f26778 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 11:30:33 +0100
Subject: [PATCH 43/49] bump pre-release version

---
 root.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 5059adb1..b32dba6a 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.6</Version>
+		<Version>2.0.0-alpha.4.subscription-api.7</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 

From 3ee031af026ad3adda920c2631a274842e26ce95 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 29 Jan 2019 20:43:37 +0100
Subject: [PATCH 44/49] Subscriptions API (#92)

* add StringEnumConverter to JsonSerializerSettings

* fix dependencies

* change version

* fix version

* fix CloseAsync

* lock dispose

* implement external exception handling for subscription streams

* fix doc comment

* add back-off delay for automatic reconnects

* create GraphQLHttpWebSocket class

* get single socket working

* fix subscription test, cleanup code

* more code cleanup

* add test CanConnectMultipleSubscriptionsSimultaneously

* dynamically find free ports for integration test

* add WebSocketExceptionHandler to clientOptions

* move reconnect-logic into subscriptions

* move external exception handler declaration to CreateSubscriptionStream overloads

* fix exception on disposing disconnected subscription

* fix tests, add console app for testing reconnect after server restart

* Update GraphQL.Client.Tests.csproj

* Nullable check (#86)

* nonnullable

* fix some things

* other fix

* netstandard2.0

* Update README.md

* create "queue" for requests so that only one send operation is performed at a time

* fix websockets on win 7

* remove websockets4net dependency

* Update root.props

* Update config.yml

* IsTestProject

* Benchmar

* benchmark

* Update GraphQLLocation.cs

* new Spec

* fix suff for dotnet core 3.0

* check response for 'null' in where clause

* add obsolete parameterless constructor to GraphQLRequest

* add debug output in websocket receive

* reuse observables for identical requests

* store changes to consoleapp

* fix StackOverflowException in GraphQLRequest.GetHashCode()

* fix receiving long messages via websocket

* add obsolete constructor

* make ReceiveResultStream observable Hot

* fix multiple subscriptions by using subject in GraphQLHttpWebSocket

* fix overlapping subscriptions

* fix subscription test to work arround https://github.com/graphql-dotnet/server/pull/199

* add an observable which publishes all websocket exceptions

* fix OnNext calls of exceptionSubject

* fix GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) constructor

* test requests via websockets

* bump pre-release version
---
 .circleci/config.yml                          |   8 +-
 GraphQL.Client.sln                            |  13 +-
 README.md                                     |  40 ++--
 .../Program.cs                                | 137 +++++++++--
 ...iptionIntegrationTest.ConsoleClient.csproj |   7 +-
 .../GraphQL.Common.Benchmark.csproj           |  16 ++
 .../GraphQL.Common.Benchmark/Program.cs       |  36 +++
 .../Request/GraphQLRequestBenchmark.cs        |  57 +++++
 root.props                                    |   6 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |   1 +
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  55 ++++-
 .../Http/GraphQLHttpClientOptions.cs          |   5 +
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  91 +++++++-
 .../Http/GraphQLHttpWebSocket.cs              | 159 ++++++++++---
 src/GraphQL.Client/IGraphQLClient.cs          |   6 +
 .../Obsolete.GraphQLClient.Extensions.cs      |   4 +-
 src/GraphQL.Client/Obsolete.GraphQLClient.cs  |   4 +-
 src/GraphQL.Common/GraphQL.Common.csproj      |   4 +-
 src/GraphQL.Common/Request/GraphQLRequest.cs  |  67 +++---
 .../Request/GraphQLWebSocketRequest.cs        |  25 ++
 .../Response/GraphQLLocation.cs               |  34 +--
 .../GraphQL.Client.Tests.csproj               |   5 +-
 .../GraphQLClientGetTests.cs                  |  21 +-
 .../GraphQLClientPostTests.cs                 |  29 +--
 .../GraphQLHttpClientSendQueryAsyncTest.cs    |  41 ++--
 .../Http/HttpClientExtensionsTest.cs          |  20 +-
 .../IGraphQLClientTest.cs                     |  20 +-
 tests/GraphQL.Common.Tests/AssertGraphQL.cs   |   2 -
 .../GraphQL.Common.Tests.csproj               |   3 +-
 .../Request/GraphQLRequestConsts.cs           | 220 +++++++++---------
 .../Request/GraphQLRequestTests.cs            |  12 -
 .../GraphQLClientExtensions.cs                |  25 +-
 .../SubscriptionsTest.cs                      |  65 ++----
 .../ChatSchema/ChatMutation.cs                |  13 +-
 .../ChatSchema/ChatSubscriptions.cs           |  20 +-
 .../IntegrationTestServer/ChatSchema/IChat.cs |  43 +++-
 .../IntegrationTestServer.csproj              |  10 +-
 tests/IntegrationTestServer/Program.cs        |   4 +-
 tests/IntegrationTestServer/Startup.cs        |   5 +
 39 files changed, 900 insertions(+), 433 deletions(-)
 create mode 100644 benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
 create mode 100644 benchmarks/GraphQL.Common.Benchmark/Program.cs
 create mode 100644 benchmarks/GraphQL.Common.Benchmark/Request/GraphQLRequestBenchmark.cs

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 7e3c5054..8594df23 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -47,15 +47,15 @@ jobs:
       - run: dotnet build --configuration Release
       - run: dotnet pack --configuration Release
       - store_artifacts:
-          path: ./src/GraphQL.Common/bin/Release/GraphQL.Common.2.0.0-alpha.3.nupkg
+          path: ./src/GraphQL.Common/bin/Release/GraphQL.Common.2.0.0-alpha.4.nupkg
       - store_artifacts:
-          path: ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.3.nupkg
+          path: ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.4.nupkg
       - deploy:
           name: MyGet
           command: |
             if [ "${CIRCLE_BRANCH}" == "master" ]; then
-              dotnet nuget push ./src/GraphQL.Common/bin/Release/GraphQL.Common.2.0.0-alpha.3.nupkg --api-key $MY_GET_API_KEY --source $MY_GET_SOURCE
-              dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.3.nupkg --api-key $MY_GET_API_KEY --source $MY_GET_SOURCE
+              dotnet nuget push ./src/GraphQL.Common/bin/Release/GraphQL.Common.2.0.0-alpha.4.nupkg --api-key $MY_GET_API_KEY --source $MY_GET_SOURCE
+              dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.4.nupkg --api-key $MY_GET_API_KEY --source $MY_GET_SOURCE
             fi
 workflows:
   version: 2
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index aa9d13e0..4d28e424 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2010
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.28407.52
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{47C98B55-08F1-4428-863E-2C5C876DEEFE}"
 	ProjectSection(SolutionItems) = preProject
@@ -45,6 +45,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{9413
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Sample", "samples\GraphQL.Client.Sample\GraphQL.Client.Sample.csproj", "{B21E97C3-F328-473F-A054-A4BF272B63F0}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "benchmarks", "benchmarks", "{A2E950A3-BD50-40C0-8189-57B455FFBC62}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Common.Benchmark", "benchmarks\GraphQL.Common.Benchmark\GraphQL.Common.Benchmark.csproj", "{6A935C7C-7DD1-489D-9259-56C1A398D643}"
+EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests", "tests\GraphQL.Integration.Tests\GraphQL.Integration.Tests.csproj", "{86BC3878-6549-4EF1-9672-B7C15A3FDF46}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
@@ -89,6 +93,10 @@ Global
 		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6A935C7C-7DD1-489D-9259-56C1A398D643}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6A935C7C-7DD1-489D-9259-56C1A398D643}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6A935C7C-7DD1-489D-9259-56C1A398D643}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6A935C7C-7DD1-489D-9259-56C1A398D643}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -104,6 +112,7 @@ Global
 		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{D588BC10-6B17-477F-9546-F8D1CE02EACB} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{6A935C7C-7DD1-489D-9259-56C1A398D643} = {A2E950A3-BD50-40C0-8189-57B455FFBC62}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/README.md b/README.md
index f7bfc120..68c7b303 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@ A GraphQL Client for .NET Standard over HTTP.
 
 ## Specification:
 The Library will try to follow the following standards and documents:
-[GraphQL Specification](http://facebook.github.io/graphql/October2016/)
+[GraphQL Specification](https://facebook.github.io/graphql/June2018/)
 [GraphQL HomePage](http://graphql.org/learn/)
 
 ## Usage:
@@ -15,32 +15,30 @@ The Library will try to follow the following standards and documents:
 ### Create a GraphQLRequest:
 #### Simple Request:
 ```csharp
-var heroRequest = new GraphQLRequest {
-  Query = @"
+var heroRequest = new GraphQLRequest(@"
     {
-      hero {
-        name
-      }
+		hero {
+			name
+		}
     }"
-};
+);
 ```
 
 #### OperationName and Variables Request:
 ```csharp
-var heroAndFriendsRequest = new GraphQLRequest {
-  Query = @"
-    query HeroNameAndFriends($episode: Episode) {
-      hero(episode: $episode) {
-        name
-        friends {
-          name
-        }
-      }
-    }",
-  OperationName = "HeroNameAndFriends",
-  Variables = new {
-    episode = "JEDI"
-  }
+var heroAndFriendsRequest = new GraphQLRequest(@"
+	query HeroNameAndFriends($episode: Episode) {
+		hero(episode: $episode) {
+			name
+			friends {
+				name
+			}
+		}
+	}"){
+	OperationName = "HeroNameAndFriends",
+	Variables = new {
+		episode = "JEDI"
+	}
 };
 ```
 
diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index a891236a..95000512 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -1,4 +1,8 @@
 using System;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 
@@ -6,39 +10,126 @@ namespace SubsccriptionIntegrationTest.ConsoleClient
 {
 	class Program
 	{
-		static void Main(string[] args)
+		static async Task Main(string[] args)
 		{
 			Console.WriteLine("configuring client ...");
-			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
+			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/", new GraphQLHttpClientOptions{ UseWebSocketForQueriesAndMutations = true }))
 			{
-#pragma warning disable 618
-				var stream = client.CreateSubscriptionStream(new GraphQLRequest
-					{
-						Query = @"
-							subscription {
-							  messageAdded{
-							    content
-								from {
-								  displayName
-								}
-							  }
-							}"
-					},
-					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
-#pragma warning restore 618
 
 				Console.WriteLine("subscribing to message stream ...");
-				using (var subscription = stream.Subscribe(
-					response => Console.WriteLine($"new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
-					exception => Console.WriteLine($"message subscription stream failed: {exception}"),
-					() => Console.WriteLine($"message subscription stream completed")))
+
+				var subscriptions = new CompositeDisposable();
+
+				subscriptions.Add(client.WebSocketReceiveErrors.Subscribe(e => {
+					if(e is WebSocketException we)
+						Console.WriteLine($"WebSocketException: {we.Message} (WebSocketError {we.WebSocketErrorCode}, ErrorCode {we.ErrorCode}, NativeErrorCode {we.NativeErrorCode}");
+					else
+						Console.WriteLine($"Exception in websocket receive stream: {e.ToString()}");
+				}));
+
+				subscriptions.Add(CreateSubscription("1", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription2("2", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("3", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("4", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("5", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("6", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("7", client));
+
+				using (subscriptions)
 				{
 					Console.WriteLine("client setup complete");
-					Console.WriteLine("press any key to exit");
-					Console.Read();
+					var quit = false;
+					do
+					{
+						Console.WriteLine("write message and press enter...");
+						var message = Console.ReadLine();
+						var graphQLRequest = new GraphQLRequest(@"
+							mutation($input: MessageInputType){
+							  addMessage(message: $input){
+								content
+							  }
+							}")
+						{
+							Variables = new
+							{
+								input = new
+								{
+									fromId = "2",
+									content = message,
+									sentAt = DateTime.Now
+								}
+							}
+						};
+						var result = await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+
+						if(result.Errors != null && result.Errors.Length > 0)
+						{
+							Console.WriteLine($"request returned {result.Errors.Length} errors:");
+							foreach (var item in result.Errors)
+							{
+								Console.WriteLine($"{item.Message}");
+							}
+						}
+					}
+					while(!quit);
 					Console.WriteLine("shutting down ...");
 				}
+				Console.WriteLine("subscriptions disposed ...");
 			}
+			Console.WriteLine("client disposed ...");
+		}
+
+		private static IDisposable CreateSubscription(string id, GraphQLHttpClient client)
+		{
+#pragma warning disable 618
+			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+					subscription {
+						messageAdded{
+						content
+							from {
+								displayName
+							}
+						}
+					}"
+				)
+			{ Variables = new { id } });
+#pragma warning restore 618
+
+			return stream.Subscribe(
+				response => Console.WriteLine($"{id}: new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
+				exception => Console.WriteLine($"{id}: message subscription stream failed: {exception}"),
+				() => Console.WriteLine($"{id}: message subscription stream completed"));
+			
+		}
+
+
+		private static IDisposable CreateSubscription2(string id, GraphQLHttpClient client)
+		{
+#pragma warning disable 618
+			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+					subscription {
+						contentAdded{
+						content
+							from {
+								displayName
+							}
+						}
+					}"
+				)
+			{ Variables = new { id } });
+#pragma warning restore 618
+
+			return stream.Subscribe(
+				response => Console.WriteLine($"{id}: new content from \"{response.Data.contentAdded.from.displayName.Value}\": {response.Data.contentAdded.content.Value}"),
+				exception => Console.WriteLine($"{id}: content subscription stream failed: {exception}"),
+				() => Console.WriteLine($"{id}: content subscription stream completed"));
+
 		}
 	}
 }
diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
index 21901c2f..83d4884b 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -2,9 +2,14 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFrameworks>netcoreapp3.0;net461</TargetFrameworks>
+	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\src\GraphQL.Client\GraphQL.Client.csproj" />
     <ProjectReference Include="..\src\GraphQL.Common\GraphQL.Common.csproj" />
diff --git a/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
new file mode 100644
index 00000000..d5ccaa33
--- /dev/null
+++ b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<OutputType>Exe</OutputType>
+		<TargetFramework>netcoreapp2.2</TargetFramework>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="BenchmarkDotNet" Version="0.11.3" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
+	</ItemGroup>
+	
+</Project>
diff --git a/benchmarks/GraphQL.Common.Benchmark/Program.cs b/benchmarks/GraphQL.Common.Benchmark/Program.cs
new file mode 100644
index 00000000..cdbcfce2
--- /dev/null
+++ b/benchmarks/GraphQL.Common.Benchmark/Program.cs
@@ -0,0 +1,36 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Running;
+using System;
+using System.Security.Cryptography;
+
+namespace GraphQL.Common.Benchmark{
+
+	public class Md5VsSha256{
+
+		private const int N = 10000;
+		private readonly byte[] data;
+
+		private readonly SHA256 sha256 = SHA256.Create();
+		private readonly MD5 md5 = MD5.Create();
+
+		public Md5VsSha256(){
+			this.data = new byte[N];
+			new Random(42).NextBytes(this.data);
+		}
+
+		[Benchmark]
+		public byte[] Sha256() => this.sha256.ComputeHash(this.data);
+
+		[Benchmark]
+		public byte[] Md5() => this.md5.ComputeHash(this.data);
+	}
+
+	public class Program{
+
+		public static void Main(string[] args){
+			var summary = BenchmarkRunner.Run<Md5VsSha256>();
+		}
+
+	}
+
+}
diff --git a/benchmarks/GraphQL.Common.Benchmark/Request/GraphQLRequestBenchmark.cs b/benchmarks/GraphQL.Common.Benchmark/Request/GraphQLRequestBenchmark.cs
new file mode 100644
index 00000000..c6869149
--- /dev/null
+++ b/benchmarks/GraphQL.Common.Benchmark/Request/GraphQLRequestBenchmark.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Text;
+using BenchmarkDotNet.Attributes;
+using GraphQL.Common.Request;
+
+namespace GraphQL.Common.Benchmark.Request {
+
+	public class GraphQLRequestBenchmark {
+
+		private readonly string query;
+		private readonly string operationName;
+		private readonly dynamic variables;
+		private readonly GraphQLRequest graphQLRequest1 = Generate();
+		private readonly GraphQLRequest graphQLRequest2 = Generate();
+
+		public GraphQLRequestBenchmark() {
+			var random = new Random();
+			var data = new byte[1000];
+			random.NextBytes(data);
+			this.query = Encoding.Default.GetString(data);
+			random.NextBytes(data);
+			this.operationName = Encoding.Default.GetString(data);
+			this.variables = new {
+				objectA = random.NextDouble(),
+				objectB = random.Next()
+			};
+		}
+
+		[Benchmark]
+		public GraphQLRequest Constructor() => new GraphQLRequest(this.query) { OperationName = this.operationName, Variables = this.variables };
+
+		[Benchmark]
+		public bool Equality() => this.graphQLRequest1.Equals(this.graphQLRequest2);
+
+		[Benchmark]
+		public bool InEquality() => !this.graphQLRequest1.Equals(this.graphQLRequest2);
+
+		private static GraphQLRequest Generate() {
+			var random = new Random();
+			var data = new byte[1000];
+			random.NextBytes(data);
+			var query = Encoding.Default.GetString(data);
+			random.NextBytes(data);
+			var operationName = Encoding.Default.GetString(data);
+			var variables = new {
+				objectA = random.NextDouble(),
+				objectB = random.Next()
+			};
+			return new GraphQLRequest(query) {
+				OperationName = operationName,
+				Variables = variables
+			};
+		}
+
+	}
+
+}
diff --git a/root.props b/root.props
index d00301d1..b32dba6a 100644
--- a/root.props
+++ b/root.props
@@ -6,9 +6,9 @@
 		<Description>A GraphQL Client for .NET Standard</Description>
 		<GenerateAssemblyInfo>True</GenerateAssemblyInfo>
 		<GenerateDocumentationFile>True</GenerateDocumentationFile>
-		<LangVersion>latest</LangVersion>
+		<LangVersion>8.0</LangVersion>
 		<NeutralLanguage>en-US</NeutralLanguage>
-		<NoWarn>CS0618;CS1591;CS1701</NoWarn>
+		<NoWarn>CS0618;CS1591;CS1701;NU5105;NU5125</NoWarn>
 		<PackageIconUrl>https://raw.githubusercontent.com/graphql-dotnet/graphql-client/master/assets/logo.64x64.png</PackageIconUrl>
 		<PackageLicenseUrl>https://raw.githubusercontent.com/graphql-dotnet/graphql-client/master/LICENSE.txt</PackageLicenseUrl>
 		<PackageProjectUrl>https://github.com/graphql-dotnet/graphql-client</PackageProjectUrl>
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.10</Version>
+		<Version>2.0.0-alpha.4.subscription-api.7</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 97a78f0e..8043bf35 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -14,6 +14,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 90209d40..e6a76359 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
@@ -38,6 +39,10 @@ public GraphQLHttpClientOptions Options {
 			set => this.graphQLHttpHandler.Options = value;
 		}
 
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL")]
+		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
+
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
@@ -69,13 +74,14 @@ public GraphQLHttpClient(string endPoint, GraphQLHttpClientOptions options) : th
 		/// <param name="endPoint">The EndPoint to be used</param>
 		/// <param name="options">The Options to be used</param>
 		public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
+
+			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
+
 			if (options == null) { throw new ArgumentNullException(nameof(options)); }
-			if (options.EndPoint == null) { throw new ArgumentNullException(nameof(options.EndPoint)); }
 			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
 			if (options.HttpMessageHandler == null) { throw new ArgumentNullException(nameof(options.HttpMessageHandler)); }
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
-			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
@@ -107,20 +113,28 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendQueryAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.SendQueryAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-			this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		}
 
 		public Task<GraphQLResponse> SendMutationAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendMutationAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.SendMutationAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-			this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		}
 
 		[Obsolete("EXPERIMENTAL API")]
 		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendSubscribeAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.SendSubscribeAsync(new GraphQLRequest(query), cancellationToken);
 
 		[Obsolete("EXPERIMENTAL API")]
 		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
@@ -152,14 +166,22 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
-				Options, cancellationToken: _cancellationTokenSource.Token);
+			if (subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
+
+			subscriptionStreams.Add(request, observable);
+			return observable;
 		}
 
 		/// <inheritdoc />
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
 		{
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+					   
 			return CreateSubscriptionStream(request, e =>
 			{
 				if (e is WebSocketException webSocketException)
@@ -173,10 +195,19 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
 		{
-			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			if(subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
+			subscriptionStreams.Add(request, observable);
 			return observable;
 		}
 
+		private Dictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new Dictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 38008421..ddce13c7 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -49,6 +49,11 @@ public class GraphQLHttpClientOptions {
 			var rnd = new Random();
 			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
 		};
+
+		/// <summary>
+		/// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
+		/// </summary>
+		public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 512dc443..ef71a0ce 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -15,8 +15,8 @@ namespace GraphQL.Client.Http
 	public static class GraphQLHttpSubscriptionHelpers
 	{
 		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
-			GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLHttpClientOptions options,
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
@@ -36,7 +36,9 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
 					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => response.Id == startRequest.Id)
+						.Where(response => {
+							return response != null && response.Id == startRequest.Id;
+						})
 						.SelectMany(response =>
 						{
 							switch (response.Type)
@@ -107,11 +109,16 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				{
 					try
 					{
-						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
-						if (exceptionHandler == null) throw e;
-
-						// exceptions thrown by the handler will propagate to OnError()
-						exceptionHandler?.Invoke(e);
+						if (exceptionHandler == null) {
+							// if the external handler is not set, propagate all exceptions except WebSocketExceptions
+							// this will ensure that the client tries to re-establish subscriptions on connection loss
+							if (!(e is WebSocketException)) throw e;
+						}
+						else
+						{
+							// exceptions thrown by the handler will propagate to OnError()
+							exceptionHandler?.Invoke(e);
+						}
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return cancellationToken.IsCancellationRequested
@@ -140,5 +147,75 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
+
+		internal static async Task<GraphQLResponse> Request(
+			this GraphQLHttpWebSocket graphQlHttpWebSocket,
+			GraphQLRequest request,
+			CancellationToken cancellationToken = default)
+		{
+			return await Observable.Create<GraphQLResponse>(async observer =>
+			{
+				var websocketRequest = new GraphQLWebSocketRequest
+				{
+					Id = Guid.NewGuid().ToString("N"),
+					Type = GQLWebSocketMessageType.GQL_START,
+					Payload = request
+				};
+				var observable = graphQlHttpWebSocket.ResponseStream
+					.Where(response => {
+						return response != null && response.Id == websocketRequest.Id;
+					})
+					.SelectMany(response =>
+					{
+						switch (response.Type)
+						{
+							case GQLWebSocketMessageType.GQL_COMPLETE:
+								Debug.WriteLine($"received 'complete' message on request {websocketRequest.Id}");
+								return Observable.Empty<GraphQLResponse>();
+							case GQLWebSocketMessageType.GQL_ERROR:
+								Debug.WriteLine($"received 'error' message on request {websocketRequest.Id}");
+								return Observable.Throw<GraphQLResponse>(
+									new GraphQLSubscriptionException(response.Payload));
+							default:
+								Debug.WriteLine($"received response for request {websocketRequest.Id}");
+								return Observable.Return(((JObject)response?.Payload)
+									?.ToObject<GraphQLResponse>());
+						}
+					});
+
+				try
+				{
+					// intialize websocket (completes immediately if socket is already open)
+					await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+				}
+				catch (Exception e)
+				{
+					// subscribe observer to failed observable
+					return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+				}
+
+				var disposable = new CompositeDisposable(
+					observable.Subscribe(observer)
+				);
+
+				Debug.WriteLine($"submitting request {websocketRequest.Id}");
+				// send request
+				try
+				{
+					await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
+				}
+				catch (Exception e)
+				{
+					Console.WriteLine(e);
+					throw;
+				}
+
+				return disposable;
+			})
+			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+			.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+				Observable.Empty<GraphQLResponse>())
+			.FirstOrDefaultAsync();
+		}
 	}
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index c5e2d349..90caf737 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
@@ -18,34 +19,64 @@ internal class GraphQLHttpWebSocket: IDisposable
 	{
 		private readonly Uri webSocketUri;
 		private readonly GraphQLHttpClientOptions _options;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-		private readonly ArraySegment<byte> arraySegment;
+		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
-		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+		private Subject<GraphQLWebSocketResponse> _responseSubject;
+		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private Subject<Exception> _exceptionSubject = new Subject<Exception>();
+		private IDisposable _requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
-		private ClientWebSocket clientWebSocket = null;
+		private WebSocket clientWebSocket = null;
 		private int _connectionAttempt = 0;
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
 			this.webSocketUri = webSocketUri;
 			_options = options;
-			arraySegment = new ArraySegment<byte>(buffer);
-			ResponseStream = _createResponseStream();
+			buffer = new ArraySegment<byte>(new byte[8192]);
+			_responseStream = _createResponseStream();
+
+			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
-		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+		public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
 
+		public IObservable<GraphQLWebSocketResponse> ResponseStream => _responseStream;
+		public IObservable<GraphQLWebSocketResponse> _responseStream;
+		//private IDisposable _responseStreamConnection;
 
-		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
-			await InitializeWebSocket().ConfigureAwait(false);
-			var webSocketRequestString = JsonConvert.SerializeObject(request);
-			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+			_requestSubject.OnNext(request);
+			return request.SendTask();
+		}
+
+		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
+		{
+			try
+			{
+				if (_cancellationTokenSource.Token.IsCancellationRequested)
+				{
+					request.SendCanceled();
+					return;
+				}
+
+				await InitializeWebSocket().ConfigureAwait(false);
+				var webSocketRequestString = JsonConvert.SerializeObject(request);
+				await this.clientWebSocket.SendAsync(
+					new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString)),
+					WebSocketMessageType.Text,
+					true,
+					_cancellationTokenSource.Token).ConfigureAwait(false);
+				request.SendCompleted();
+			}
+			catch (Exception e)
+			{
+				request.SendFailed(e);
+			}
 		}
 
 		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
@@ -80,12 +111,27 @@ public Task InitializeWebSocket()
 				return Task.CompletedTask;
 
 			// else (re-)create websocket and connect
+			//_responseStreamConnection?.Dispose();
 			clientWebSocket?.Dispose();
-			clientWebSocket = new ClientWebSocket();
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+
+			// fix websocket not supported on win 7 using
+			// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
+			clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+			switch (clientWebSocket)
+			{
+				case ClientWebSocket nativeWebSocket:
+					nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+					break;
+				case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
+					managedWebSocket.Options.AddSubProtocol("graphql-ws");
+					break;
+				default:
+					throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
+			}
+
 			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 		}
-
+		
 		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 		{
 			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
@@ -96,10 +142,27 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 
 		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
 		{
-			var observable = await _getReceiveResultStream().ConfigureAwait(false);
+			if (_responseSubject == null || _responseSubject.IsDisposed)
+			{
+				_responseSubject = new Subject<GraphQLWebSocketResponse>();
+				var observable = await _getReceiveResultStream().ConfigureAwait(false);
+				observable.Subscribe(_responseSubject);
+
+				_responseSubject.Subscribe(_ => { }, ex =>
+				{
+					_exceptionSubject.OnNext(ex);
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				},
+				() => {
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				});
+			}
+					   
 			return new CompositeDisposable
 			(
-				observable.Subscribe(observer),
+				_responseSubject.Subscribe(observer),
 				Disposable.Create(() =>
 				{
 					Debug.WriteLine("response stream disposed");
@@ -115,11 +178,20 @@ private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStrea
 
 		private async Task _connectAsync(CancellationToken token)
 		{
-			await _backOff().ConfigureAwait(false);
-			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
-			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
-			_connectionAttempt = 1;
+			try
+			{
+				await _backOff().ConfigureAwait(false);
+				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
+				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+				//_responseStreamConnection = _responseStream.Connect();
+				_connectionAttempt = 1;
+			}
+			catch (Exception e)
+			{
+				_exceptionSubject.OnNext(e);
+				throw;
+			}
 		}
 
 
@@ -146,23 +218,42 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
 			try
 			{
-				Debug.WriteLine("receiving websocket data ...");
-				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var webSocketReceiveResult =
-					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
-				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");
+				WebSocketReceiveResult webSocketReceiveResult = null;
+
+				using (var ms = new MemoryStream())
+				{
+					do
+					{
+						_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
+						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
+					}
+					while (!webSocketReceiveResult.EndOfMessage);
+
+					_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+					ms.Seek(0, SeekOrigin.Begin);
+
+					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
+					{
+						using (var reader = new StreamReader(ms, Encoding.UTF8))
+						{
+							var stringResult = await reader.ReadToEndAsync();
+							Debug.WriteLine($"data received on websocket {clientWebSocket.GetHashCode()}: {stringResult}");
+							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+						}
+					}
+					else
+					{
+						throw new NotSupportedException("binary websocket messages are not supported");
+					}
+				}				
 			}
 			catch (Exception e)
 			{
-				Console.WriteLine(e);
+				Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
 				throw;
 			}
-			finally
-			{
-				Debug.WriteLine("websocket data received");
-			}
 		}
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 60af36ab..098d0524 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -72,6 +72,12 @@ public interface IGraphQLClient : IDisposable {
 		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
+
+		/// <summary>
+		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
+		/// </summary>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<Exception> WebSocketReceiveErrors { get; }
 	}
 
 }
diff --git a/src/GraphQL.Client/Obsolete.GraphQLClient.Extensions.cs b/src/GraphQL.Client/Obsolete.GraphQLClient.Extensions.cs
index a7b6dbfc..057e3c8a 100644
--- a/src/GraphQL.Client/Obsolete.GraphQLClient.Extensions.cs
+++ b/src/GraphQL.Client/Obsolete.GraphQLClient.Extensions.cs
@@ -99,8 +99,8 @@ fragment TypeRef on __Type {
 					}
 				}";
 
-		private static readonly GraphQLRequest IntrospectionGraphQLRequest = new GraphQLRequest {
-			Query = IntrospectionQuery.Replace("\t", "").Replace("\n", "").Replace("\r", ""),
+		private static readonly GraphQLRequest IntrospectionGraphQLRequest = new GraphQLRequest(
+			IntrospectionQuery.Replace("\t", "").Replace("\n", "").Replace("\r", "")){ 
 			Variables = null
 		};
 
diff --git a/src/GraphQL.Client/Obsolete.GraphQLClient.cs b/src/GraphQL.Client/Obsolete.GraphQLClient.cs
index 73f81450..922927bf 100644
--- a/src/GraphQL.Client/Obsolete.GraphQLClient.cs
+++ b/src/GraphQL.Client/Obsolete.GraphQLClient.cs
@@ -53,7 +53,7 @@ public GraphQLClient(GraphQLClientOptions options) : base(options) { }
 		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
 		/// <returns>The Response</returns>
 		public Task<GraphQLResponse> GetQueryAsync(string query, CancellationToken cancellationToken = default) =>
-			this.GetAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.GetAsync(new GraphQLRequest(query), cancellationToken);
 
 		/// <summary>
 		/// Send a <see cref="GraphQLRequest"/> via GET
@@ -71,7 +71,7 @@ public Task<GraphQLResponse> GetAsync(GraphQLRequest request, CancellationToken
 		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
 		/// <returns>The Response</returns>
 		public Task<GraphQLResponse> PostQueryAsync(string query, CancellationToken cancellationToken = default) =>
-			this.PostAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.PostAsync(new GraphQLRequest(query), cancellationToken);
 
 		/// <summary>
 		/// Send a <see cref="GraphQLRequest"/> via POST
diff --git a/src/GraphQL.Common/GraphQL.Common.csproj b/src/GraphQL.Common/GraphQL.Common.csproj
index ed75f9dd..116ff1b9 100644
--- a/src/GraphQL.Common/GraphQL.Common.csproj
+++ b/src/GraphQL.Common/GraphQL.Common.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../src.props" />
@@ -8,7 +8,7 @@
 	</PropertyGroup>
 
 	<PropertyGroup>
-		<TargetFrameworks>netstandard1.0;netstandard2.0</TargetFrameworks>
+		<TargetFramework>netstandard2.0</TargetFramework>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index 212a3642..d04f1992 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -1,3 +1,4 @@
+#nullable enable
 using System;
 using System.Collections.Generic;
 
@@ -7,7 +8,7 @@ namespace GraphQL.Common.Request {
 	/// Represents a Query that can be fetched to a GraphQL Server.
 	/// For more information <see href="http://graphql.org/learn/serving-over-http/#post-request"/>
 	/// </summary>
-	public class GraphQLRequest : IEquatable<GraphQLRequest> {
+	public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 
 		/// <summary>
 		/// The Query
@@ -17,50 +18,60 @@ public class GraphQLRequest : IEquatable<GraphQLRequest> {
 		/// <summary>
 		/// If the provided <see cref="Query"/> contains multiple named operations, this specifies which operation should be executed.
 		/// </summary>
-		public string OperationName { get; set; }
+		public string? OperationName { get; set; }
 
 		/// <summary>
 		/// The Variables
 		/// </summary>
-		public dynamic Variables { get; set; }
+		public dynamic? Variables { get; set; }
+
+		/// <summary>
+		/// Initialize a new GraphQLRequest
+		/// </summary>
+		/// <param name="query">The Query</param>
+		public GraphQLRequest(string query){
+			this.Query = query;
+		}
+
+		/// <summary>
+		/// Initialize a new GraphQLRequest
+		/// </summary>
+		[Obsolete("Pass query as parameter! This constructor will be removed in a future version!")]
+		public GraphQLRequest()
+		{
+			this.Query = string.Empty;
+		}
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLRequest);
+		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLRequest other) {
-			if (other == null) {
-				return false;
-			}
-			if (ReferenceEquals(this, other)) {
-				return true;
-			}
-			if (!Equals(this.Query, other.Query)) {
-				return false;
-			}
-			if (!Equals(this.OperationName, other.OperationName)) {
-				return false;
-			}
-			if (!Equals(this.Variables, other.Variables)) {
-				return false;
-			}
+		public bool Equals(GraphQLRequest? other) {
+			if (other == null) {return false;}
+			if (ReferenceEquals(this, other)) { return true; }
+			if (!EqualityComparer<string>.Default.Equals(this.Query, other.Query)) { return false; }
+			if (!EqualityComparer<string?>.Default.Equals(this.OperationName, other.OperationName)) { return false; }
+			if (!EqualityComparer<dynamic?>.Default.Equals(this.Variables, other.Variables)) { return false; }
 			return true;
 		}
 
 		/// <inheritdoc />
-		public override int GetHashCode() {
-			var hashCode = -689803966;
-			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Query);
-			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.OperationName);
-			hashCode = hashCode * -1521134295 + EqualityComparer<dynamic>.Default.GetHashCode(this.Variables);
-			return hashCode;
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				var hashCode = EqualityComparer<string?>.Default.GetHashCode(Query);
+				hashCode = (hashCode * 397) ^ EqualityComparer<string?>.Default.GetHashCode(OperationName);
+				hashCode = (hashCode * 397) ^ EqualityComparer<dynamic?>.Default.GetHashCode(Variables);
+				return hashCode;
+			}
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLRequest request1, GraphQLRequest request2) => EqualityComparer<GraphQLRequest>.Default.Equals(request1, request2);
+		public static bool operator ==(GraphQLRequest? request1, GraphQLRequest? request2) => EqualityComparer<GraphQLRequest?>.Default.Equals(request1, request2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLRequest request1, GraphQLRequest request2) => !(request1 == request2);
+		public static bool operator !=(GraphQLRequest? request1, GraphQLRequest? request2) => !(request1 == request2);
 
 	}
 
diff --git a/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
index 46e14dce..d805efc4 100644
--- a/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace GraphQL.Common.Request {
 
@@ -24,6 +25,30 @@ public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 		/// </summary>
 		public GraphQLRequest Payload { get; set; }
 
+		private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
+
+		/// <summary>
+		/// Task used to await the actual send operation and to convey potential exceptions
+		/// </summary>
+		/// <returns></returns>
+		public Task SendTask() => _tcs.Task;
+
+		/// <summary>
+		/// gets called when the send operation for this request has completed sucessfully
+		/// </summary>
+		public void SendCompleted() => _tcs.SetResult(true);
+
+		/// <summary>
+		/// gets called when an exception occurs during the send operation
+		/// </summary>
+		/// <param name="e"></param>
+		public void SendFailed(Exception e) => _tcs.SetException(e);
+
+		/// <summary>
+		/// gets called when the GraphQLHttpWebSocket has been disposed before the send operation for this request has started
+		/// </summary>
+		public void SendCanceled() => _tcs.SetCanceled();
+
 		/// <inheritdoc />
 		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
 
diff --git a/src/GraphQL.Common/Response/GraphQLLocation.cs b/src/GraphQL.Common/Response/GraphQLLocation.cs
index 913a7a44..c8eb8c5c 100644
--- a/src/GraphQL.Common/Response/GraphQLLocation.cs
+++ b/src/GraphQL.Common/Response/GraphQLLocation.cs
@@ -1,3 +1,4 @@
+#nullable enable
 using System;
 using System.Collections.Generic;
 
@@ -6,7 +7,7 @@ namespace GraphQL.Common.Response {
 	/// <summary>
 	/// Represents the location where the <see cref="GraphQLError"/> has been found
 	/// </summary>
-	public class GraphQLLocation : IEquatable<GraphQLLocation> {
+	public class GraphQLLocation : IEquatable<GraphQLLocation?> {
 
 		/// <summary>
 		/// The Column
@@ -19,38 +20,25 @@ public class GraphQLLocation : IEquatable<GraphQLLocation> {
 		public uint Line { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLLocation);
+		public override bool Equals(object? obj) => this.Equals(obj as GraphQLLocation);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLLocation other) {
-			if (other == null) {
-				return false;
-			}
-			if (ReferenceEquals(this, other)) {
-				return true;
-			}
-			if (!Equals(this.Column, other.Column)) {
-				return false;
-			}
-			if (!Equals(this.Line, other.Line)) {
-				return false;
-			}
+		public bool Equals(GraphQLLocation? other) {
+			if (other == null) { return false; }
+			if (ReferenceEquals(this, other)) { return true; }
+			if (!EqualityComparer<uint>.Default.Equals(this.Column, other.Column)) { return false; }
+			if (!EqualityComparer<uint>.Default.Equals(this.Line, other.Line)) { return false; }
 			return true;
 		}
 
 		/// <inheritdoc />
-		public override int GetHashCode() {
-			var hashCode = 412437926;
-			hashCode = hashCode * -1521134295 + this.Column.GetHashCode();
-			hashCode = hashCode * -1521134295 + this.Line.GetHashCode();
-			return hashCode;
-		}
+		public override int GetHashCode() => EqualityComparer<GraphQLLocation>.Default.GetHashCode(this);
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLLocation location1, GraphQLLocation location2) => EqualityComparer<GraphQLLocation>.Default.Equals(location1, location2);
+		public static bool operator ==(GraphQLLocation? location1, GraphQLLocation? location2) => EqualityComparer<GraphQLLocation?>.Default.Equals(location1, location2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLLocation location1, GraphQLLocation location2) => !(location1 == location2);
+		public static bool operator !=(GraphQLLocation? location1, GraphQLLocation? location2) => !(location1 == location2);
 
 	}
 
diff --git a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
index 660883af..1c9a24d9 100644
--- a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
+++ b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
@@ -4,16 +4,17 @@
 	<Import Project="../tests.props" />
 
 	<PropertyGroup>
+		<IsTestProject>true</IsTestProject>
 		<TargetFramework>netcoreapp3.0</TargetFramework>
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="1.1.2" />
+		<PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="1.1.2" />
 	</ItemGroup>
 
 	<ItemGroup>
 		<ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
 		<ProjectReference Include="..\GraphQL.Common.Tests\GraphQL.Common.Tests.csproj" />
 	</ItemGroup>
-	
+
 </Project>
diff --git a/tests/GraphQL.Client.Tests/GraphQLClientGetTests.cs b/tests/GraphQL.Client.Tests/GraphQLClientGetTests.cs
index faad38e8..2cdc0dfa 100644
--- a/tests/GraphQL.Client.Tests/GraphQLClientGetTests.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLClientGetTests.cs
@@ -8,14 +8,12 @@ public class GraphQLClientGetTests : BaseGraphQLClientTest {
 
 		[Fact]
 		public async void QueryGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
-				}"
-			};
+				}");
 			var response = await this.GraphQLClient.GetAsync(graphQLRequest).ConfigureAwait(false);
 
 			Assert.Equal("Luke Skywalker", response.Data.person.name.Value);
@@ -24,8 +22,7 @@ public async void QueryGetAsyncFact() {
 
 		[Fact]
 		public async void OperationNameGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person{
 					person(personID: ""1"") {
 						name
@@ -36,7 +33,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") {
 				OperationName = "Person"
 			};
 			var response = await this.GraphQLClient.GetAsync(graphQLRequest).ConfigureAwait(false);
@@ -47,13 +44,12 @@ query Planet {
 
 		[Fact]
 		public async void VariablesGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest (@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
 					}
-				}",
+				}") {
 				Variables = new {
 					personId = "1"
 				}
@@ -66,8 +62,7 @@ query Person($personId: ID!){
 
 		[Fact]
 		public async void OperationNameVariableGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
@@ -78,7 +73,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}"){
 				OperationName = "Person",
 				Variables = new {
 					personId = "1"
diff --git a/tests/GraphQL.Client.Tests/GraphQLClientPostTests.cs b/tests/GraphQL.Client.Tests/GraphQLClientPostTests.cs
index ba56c9a1..aacc1587 100644
--- a/tests/GraphQL.Client.Tests/GraphQLClientPostTests.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLClientPostTests.cs
@@ -9,14 +9,13 @@ public class GraphQLClientPostTests : BaseGraphQLClientTest {
 
 		[Fact]
 		public async void QueryPostAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			};
+			);
 			var response = await this.GraphQLClient.PostAsync(graphQLRequest).ConfigureAwait(false);
 
 			Assert.Equal("Luke Skywalker", response.Data.person.name.Value);
@@ -24,17 +23,14 @@ public async void QueryPostAsyncFact() {
 		}
 
 		[Fact]
-		public async void QueryPostAsyncWithoutUtf8EncodingFact()
-		{
-			var graphQLRequest = new GraphQLRequest
-			{
-				Query = @"
+		public async void QueryPostAsyncWithoutUtf8EncodingFact(){
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			};
+			);
 			this.GraphQLClient.Options.MediaType = MediaTypeHeaderValue.Parse("application/json");
 			var response = await this.GraphQLClient.PostAsync(graphQLRequest).ConfigureAwait(false);
 
@@ -44,8 +40,7 @@ public async void QueryPostAsyncWithoutUtf8EncodingFact()
 
 		[Fact]
 		public async void OperationNamePostAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person{
 					person(personID: ""1"") {
 						name
@@ -56,7 +51,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person"
 			};
 			var response = await this.GraphQLClient.PostAsync(graphQLRequest).ConfigureAwait(false);
@@ -67,13 +62,12 @@ query Planet {
 
 		[Fact]
 		public async void VariablesPostAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
 					}
-				}",
+				}") { 
 				Variables = new {
 					personId = "1"
 				}
@@ -86,8 +80,7 @@ query Person($personId: ID!){
 
 		[Fact]
 		public async void OperationNameVariablePostAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
@@ -98,7 +91,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person",
 				Variables = new {
 					personId = "1"
diff --git a/tests/GraphQL.Client.Tests/Http/GraphQLHttpClientSendQueryAsyncTest.cs b/tests/GraphQL.Client.Tests/Http/GraphQLHttpClientSendQueryAsyncTest.cs
index 82062542..2d21100e 100644
--- a/tests/GraphQL.Client.Tests/Http/GraphQLHttpClientSendQueryAsyncTest.cs
+++ b/tests/GraphQL.Client.Tests/Http/GraphQLHttpClientSendQueryAsyncTest.cs
@@ -1,42 +1,36 @@
-using GraphQL.Client.Http;
-using GraphQL.Common.Request;
 using System;
-using System.Collections.Generic;
 using System.Net.Http;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
 using Xunit;
 
 namespace GraphQL.Client.Tests.Http
 {
-    public class GraphQLHttpClientSendQueryAsyncTest
-    {
+
+	public class GraphQLHttpClientSendQueryAsyncTest{
 
 		// Relates to an issue with the 1.x versions.
 		// See: https://github.com/graphql-dotnet/graphql-client/issues/53
 		[Fact]
-		public async void SendQueryAsyncShouldPreserveUriParametersFact()
-		{
+		public async void SendQueryAsyncShouldPreserveUriParametersFact(){
 			var endpoint = new Uri("http://localhost/api/graphql?code=my-secret-api-key");
 
 			var handlerStub = new HttpHandlerStub();
-			GraphQLHttpClientOptions options = new GraphQLHttpClientOptions()
-			{
+			var options = new GraphQLHttpClientOptions(){
 				EndPoint = endpoint,
 				HttpMessageHandler = handlerStub
 			};
-			GraphQLHttpClient systemUnderTest = new GraphQLHttpClient(options);
+			var systemUnderTest = new GraphQLHttpClient(options);
 
-			var response = await systemUnderTest.SendQueryAsync(new GraphQLRequest
-			{
-				Query = @"
+			var response = await systemUnderTest.SendQueryAsync(new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			});
+			));
 
 			var actualRequestUri = handlerStub.LastRequest.RequestUri;
 			var queryParams = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(actualRequestUri.Query);
@@ -45,20 +39,21 @@ public async void SendQueryAsyncShouldPreserveUriParametersFact()
 		}
 
 
-		private class HttpHandlerStub : HttpMessageHandler
-		{
+		private class HttpHandlerStub : HttpMessageHandler{
+
 			public HttpRequestMessage LastRequest { get; private set; }
 
 			public CancellationToken LastCancellationToken { get; private set; }
 
-			protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
-			{
-				LastRequest = request;
-				LastCancellationToken = cancellationToken;
-				var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
-				response.Content = new StringContent("{}");
+			protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken){
+				this.LastRequest = request;
+				this.LastCancellationToken = cancellationToken;
+				var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK){
+					Content = new StringContent("{}")
+				};
 				return Task.FromResult(response);
 			}
+
 		}
 
 	}
diff --git a/tests/GraphQL.Client.Tests/Http/HttpClientExtensionsTest.cs b/tests/GraphQL.Client.Tests/Http/HttpClientExtensionsTest.cs
index 1738f0a2..607c7e28 100644
--- a/tests/GraphQL.Client.Tests/Http/HttpClientExtensionsTest.cs
+++ b/tests/GraphQL.Client.Tests/Http/HttpClientExtensionsTest.cs
@@ -13,14 +13,13 @@ public class HttpClientExtensionsTest : BaseGraphQLClientTest {
 
 		[Fact]
 		public async void QueryGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			};
+			);
 			var response = await this.GraphQLHttpClient.SendQueryAsync(graphQLRequest).ConfigureAwait(false);
 
 			Assert.Equal("Luke Skywalker", response.Data.person.name.Value);
@@ -29,8 +28,7 @@ public async void QueryGetAsyncFact() {
 
 		[Fact]
 		public async void OperationNameGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person{
 					person(personID: ""1"") {
 						name
@@ -41,7 +39,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}"){
 				OperationName = "Person"
 			};
 			var response = await this.GraphQLHttpClient.SendQueryAsync(graphQLRequest).ConfigureAwait(false);
@@ -52,13 +50,12 @@ query Planet {
 
 		[Fact]
 		public async void VariablesGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
 					}
-				}",
+				}") {
 				Variables = new {
 					personId = "1"
 				}
@@ -71,8 +68,7 @@ query Person($personId: ID!){
 
 		[Fact]
 		public async void OperationNameVariableGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
@@ -83,7 +79,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person",
 				Variables = new {
 					personId = "1"
diff --git a/tests/GraphQL.Client.Tests/IGraphQLClientTest.cs b/tests/GraphQL.Client.Tests/IGraphQLClientTest.cs
index 7b5b6368..7c384d55 100644
--- a/tests/GraphQL.Client.Tests/IGraphQLClientTest.cs
+++ b/tests/GraphQL.Client.Tests/IGraphQLClientTest.cs
@@ -8,14 +8,13 @@ public class IGraphQLClientTest : BaseGraphQLClientTest {
 
 		[Fact]
 		public async void QueryGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			};
+			);
 			var response = await this.GraphQLClientSwapi.SendQueryAsync(graphQLRequest).ConfigureAwait(false);
 
 			Assert.Equal("Luke Skywalker", response.Data.person.name.Value);
@@ -24,8 +23,7 @@ public async void QueryGetAsyncFact() {
 
 		[Fact]
 		public async void OperationNameGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person{
 					person(personID: ""1"") {
 						name
@@ -36,7 +34,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person"
 			};
 			var response = await this.GraphQLClientSwapi.SendQueryAsync(graphQLRequest).ConfigureAwait(false);
@@ -47,13 +45,12 @@ query Planet {
 
 		[Fact]
 		public async void VariablesGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
 					}
-				}",
+				}") {
 				Variables = new {
 					personId = "1"
 				}
@@ -66,8 +63,7 @@ query Person($personId: ID!){
 
 		[Fact]
 		public async void OperationNameVariableGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
@@ -78,7 +74,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person",
 				Variables = new {
 					personId = "1"
diff --git a/tests/GraphQL.Common.Tests/AssertGraphQL.cs b/tests/GraphQL.Common.Tests/AssertGraphQL.cs
index a81f38ad..4115fc9f 100644
--- a/tests/GraphQL.Common.Tests/AssertGraphQL.cs
+++ b/tests/GraphQL.Common.Tests/AssertGraphQL.cs
@@ -6,8 +6,6 @@ namespace GraphQL.Common.Tests {
 
 	public static class AssertGraphQL {
 
-		public static void CorrectGraphQLRequest(GraphQLRequest graphQLRequest) => Assert.NotNull(graphQLRequest.Query);
-
 		public static void CorrectGraphQLResponse(GraphQLResponse graphQLResponse) {
 			Assert.NotNull(graphQLResponse.Data);
 			Assert.Null(graphQLResponse.Errors);
diff --git a/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj b/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
index e0a660a7..4aae0487 100644
--- a/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
+++ b/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
@@ -1,9 +1,10 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../tests.props" />
 
 	<PropertyGroup>
+		<IsTestProject>true</IsTestProject>
 		<TargetFramework>netcoreapp3.0</TargetFramework>
 	</PropertyGroup>
 	
diff --git a/tests/GraphQL.Common.Tests/Request/GraphQLRequestConsts.cs b/tests/GraphQL.Common.Tests/Request/GraphQLRequestConsts.cs
index 9d3fca63..520ca4b6 100644
--- a/tests/GraphQL.Common.Tests/Request/GraphQLRequestConsts.cs
+++ b/tests/GraphQL.Common.Tests/Request/GraphQLRequestConsts.cs
@@ -7,130 +7,122 @@ public static class GraphQLRequestConsts {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#fields"/>
 		/// </summary>
-		public static GraphQLRequest FieldsRequest1 { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					hero {
-						name
-					}
-				}",
+		public static GraphQLRequest FieldsRequest1 { get; } = new GraphQLRequest(@"
+			{
+				hero {
+					name
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#fields"/>
 		/// </summary>
-		public static GraphQLRequest FieldsRequest2 { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					hero {
+		public static GraphQLRequest FieldsRequest2 { get; } = new GraphQLRequest(@"
+			{
+				hero {
+					name
+					# Queries can have comments!
+					friends {
 						name
-						# Queries can have comments!
-						friends {
-							name
-						}
 					}
-				}",
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#arguments"/>
 		/// </summary>
-		public static GraphQLRequest ArgumentsRequest1 { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					human(id: ""1000"") {
-						name
-						height
-					}
-				}",
+		public static GraphQLRequest ArgumentsRequest1 { get; } = new GraphQLRequest(@"
+			{
+				human(id: ""1000"") {
+					name
+					height
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#arguments"/>
 		/// </summary>
-		public static GraphQLRequest ArgumentsRequest2 { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					human(id: ""1000"") {
-						name
-						height(unit: FOOT)
-					}
-				}",
+		public static GraphQLRequest ArgumentsRequest2 { get; } = new GraphQLRequest(@"
+			{
+				human(id: ""1000"") {
+					name
+					height(unit: FOOT)
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#aliases"/>
 		/// </summary>
-		public static GraphQLRequest AliasesRequest { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					empireHero: hero(episode: EMPIRE) {
-						name
-					}
-					jediHero: hero(episode: JEDI) {
-						name
-					}
-				}",
+		public static GraphQLRequest AliasesRequest { get; } = new GraphQLRequest(@"
+			{
+				empireHero: hero(episode: EMPIRE) {
+					name
+				}
+				jediHero: hero(episode: JEDI) {
+					name
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#fragments"/>
 		/// </summary>
-		public static GraphQLRequest FragmentsRequest { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					leftComparison: hero(episode: EMPIRE) {
-						...comparisonFields
-					}
-					rightComparison: hero(episode: JEDI) {
-						...comparisonFields
-					}
+		public static GraphQLRequest FragmentsRequest { get; } = new GraphQLRequest(@"
+			{
+				leftComparison: hero(episode: EMPIRE) {
+					...comparisonFields
+				}
+				rightComparison: hero(episode: JEDI) {
+					...comparisonFields
 				}
+			}
 
-				fragment comparisonFields on Character {
+			fragment comparisonFields on Character {
+				name
+				appearsIn
+				friends {
 					name
-					appearsIn
-					friends {
-						name
-					}
-				}",
+				}
+			}") {
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#operation-name"/>
 		/// </summary>
-		public static GraphQLRequest OperationNameRequest { get; } = new GraphQLRequest {
-			Query = @"
-				query HeroNameAndFriends {
-					hero {
+		public static GraphQLRequest OperationNameRequest { get; } = new GraphQLRequest(@"
+			query HeroNameAndFriends {
+				hero {
+					name
+					friends {
 						name
-						friends {
-							name
-						}
 					}
-				}",
+				}
+			}") {
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#variables"/>
 		/// </summary>
-		public static GraphQLRequest VariablesRequest { get; } = new GraphQLRequest {
-			Query = @"
-				query HeroNameAndFriends($episode: Episode) {
-					hero(episode: $episode) {
+		public static GraphQLRequest VariablesRequest { get; } = new GraphQLRequest(@"
+			query HeroNameAndFriends($episode: Episode) {
+				hero(episode: $episode) {
+					name
+					friends {
 						name
-						friends {
-							name
-						}
 					}
-				}",
+				}
+			}") { 
 			Variables = new {
 				episode = "JEDI"
 			}
@@ -139,16 +131,15 @@ query HeroNameAndFriends($episode: Episode) {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#directives"/>
 		/// </summary>
-		public static GraphQLRequest DirectivesRequest { get; } = new GraphQLRequest {
-			Query = @"
-				query Hero($episode: Episode, $withFriends: Boolean!) {
-					hero(episode: $episode) {
+		public static GraphQLRequest DirectivesRequest { get; } = new GraphQLRequest(@"
+			query Hero($episode: Episode, $withFriends: Boolean!) {
+				hero(episode: $episode) {
+					name
+					friends @include(if: $withFriends) {
 						name
-						friends @include(if: $withFriends) {
-							name
-						}
 					}
-				}",
+				}
+			}") { 
 			Variables = new {
 				episode = "JEDI",
 				withFriends = false
@@ -158,14 +149,13 @@ friends @include(if: $withFriends) {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#mutations"/>
 		/// </summary>
-		public static GraphQLRequest MutationsRequest { get; } = new GraphQLRequest {
-			Query = @"
-				mutation CreateReviewForEpisode($ep: Episode!, $review: ReviewInput!) {
-					createReview(episode: $ep, review: $review) {
-						stars
-						commentary
-					}
-				}",
+		public static GraphQLRequest MutationsRequest { get; } = new GraphQLRequest(@"
+			mutation CreateReviewForEpisode($ep: Episode!, $review: ReviewInput!) {
+				createReview(episode: $ep, review: $review) {
+					stars
+					commentary
+				}
+			}") { 
 			Variables = new {
 				ep = "JEDI",
 				review = new {
@@ -178,19 +168,18 @@ mutation CreateReviewForEpisode($ep: Episode!, $review: ReviewInput!) {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#inline-fragments"/>
 		/// </summary>
-		public static GraphQLRequest InlineFragmentsRequest { get; } = new GraphQLRequest {
-			Query = @"
-				query HeroForEpisode($ep: Episode!) {
-					hero(episode: $ep) {
-						name
-						... on Droid {
-							primaryFunction
-						}
-						... on Human {
-							height
-						}
+		public static GraphQLRequest InlineFragmentsRequest { get; } = new GraphQLRequest(@"
+			query HeroForEpisode($ep: Episode!) {
+				hero(episode: $ep) {
+					name
+					... on Droid {
+						primaryFunction
 					}
-				}",
+					... on Human {
+						height
+					}
+				}
+			}") { 
 			Variables = new {
 				ep = "JEDI"
 			}
@@ -199,22 +188,21 @@ ... on Human {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#meta-fields"/>
 		/// </summary>
-		public static GraphQLRequest MetaFieldsRequest { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					search(text: ""an"") {
-						__typename
-						...on Human {
-							name
-						}
-						... on Droid {
-							name
-						}
-						... on Starship {
-							name
-						}
+		public static GraphQLRequest MetaFieldsRequest { get; } = new GraphQLRequest(@"
+			{
+				search(text: ""an"") {
+					__typename
+					...on Human {
+						name
+					}
+					... on Droid {
+						name
 					}
-				}",
+					... on Starship {
+						name
+					}
+				}
+			}") { 
 			Variables = null
 		};
 
diff --git a/tests/GraphQL.Common.Tests/Request/GraphQLRequestTests.cs b/tests/GraphQL.Common.Tests/Request/GraphQLRequestTests.cs
index 2512fe3b..6eb0febd 100644
--- a/tests/GraphQL.Common.Tests/Request/GraphQLRequestTests.cs
+++ b/tests/GraphQL.Common.Tests/Request/GraphQLRequestTests.cs
@@ -7,49 +7,41 @@ public class GraphQLRequestTests {
 		[Fact]
 		public void FieldsRequest1Fact() {
 			var graphQLRequest = GraphQLRequestConsts.FieldsRequest1;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void FieldsRequest2Fact() {
 			var graphQLRequest = GraphQLRequestConsts.FieldsRequest2;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void ArgumentsRequest1Fact() {
 			var graphQLRequest = GraphQLRequestConsts.ArgumentsRequest1;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void ArgumentsRequest2Fact() {
 			var graphQLRequest = GraphQLRequestConsts.ArgumentsRequest2;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void AliasesRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.AliasesRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void FragmentsRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.FragmentsRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void OperationNameRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.OperationNameRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void VariablesRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.VariablesRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 			Assert.NotNull(graphQLRequest.Variables);
 			Assert.Equal("JEDI", graphQLRequest.Variables.episode);
 		}
@@ -57,7 +49,6 @@ public void VariablesRequestFact() {
 		[Fact]
 		public void DirectivesRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.DirectivesRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 			Assert.NotNull(graphQLRequest.Variables);
 			Assert.Equal("JEDI", graphQLRequest.Variables.episode);
 			Assert.Equal(false, graphQLRequest.Variables.withFriends);
@@ -66,7 +57,6 @@ public void DirectivesRequestFact() {
 		[Fact]
 		public void MutationsRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.MutationsRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 			Assert.NotNull(graphQLRequest.Variables);
 			Assert.Equal("JEDI", graphQLRequest.Variables.ep);
 			Assert.Equal(5, graphQLRequest.Variables.review.stars);
@@ -76,7 +66,6 @@ public void MutationsRequestFact() {
 		[Fact]
 		public void InlineFragmentsRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.InlineFragmentsRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 			Assert.NotNull(graphQLRequest.Variables);
 			Assert.Equal("JEDI", graphQLRequest.Variables.ep);
 		}
@@ -84,7 +73,6 @@ public void InlineFragmentsRequestFact() {
 		[Fact]
 		public void MetaFieldsRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.MetaFieldsRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 	}
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index c7dd0568..ff71ee6d 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -10,14 +10,13 @@ public static class GraphQLClientExtensions
 	{
 		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
 		{
-			var graphQLRequest = new GraphQLRequest
-			{
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				mutation($input: MessageInputType){
 				  addMessage(message: $input){
 				    content
 				  }
-				}",
+				}")
+			{
 				Variables = new
 				{
 					input = new
@@ -30,5 +29,23 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 			};
 			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
 		}
+
+		public static async Task<GraphQLResponse> JoinDeveloperUser(this GraphQLHttpClient client)
+		{
+			var graphQLRequest = new GraphQLRequest(@"
+				mutation($userId: String){
+				  join(userId: $userId){
+				    displayName
+				    id
+				  }
+				}")
+			{
+				Variables = new
+				{
+					userId = "1"
+				}
+			};
+			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 36804c95..635a0d1c 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -11,7 +11,6 @@
 using Microsoft.Extensions.Logging;
 using Xunit;
 
-
 namespace GraphQL.Integration.Tests
 {
 	public class SubscriptionsTest
@@ -24,7 +23,10 @@ public static IWebHost CreateServer(int port)
 			config["server.urls"] = $"http://localhost:{port}";
 
 			var host = new WebHostBuilder()
-				.ConfigureLogging((ctx, logging) => logging.AddDebug())
+				.ConfigureLogging((ctx, logging) =>
+				{
+					logging.AddDebug();
+				})
 				.UseConfiguration(config)
 				.UseKestrel()
 				.UseStartup<IntegrationTestServer.Startup>()
@@ -45,7 +47,7 @@ private GraphQLHttpClient GetGraphQLClient(int port)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
-			} );
+			});
 
 
 		[Fact]
@@ -70,10 +72,7 @@ public async void AssertTestingHarness()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
-		{
-			Query = SubscriptionQuery
-		};
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
 
 		[Fact]
 		public async void CanCreateObservableSubscription()
@@ -165,21 +164,16 @@ public async void CanReconnectWithSameObservable()
 
 		private const string SubscriptionQuery2 = @"
 			subscription {
-			  messageAdded{
-			    content
-				from {
-				  displayName
-				}
+			  userJoined{
+				displayName
+				id
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest
-		{
-			Query = SubscriptionQuery2
-		};
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 		[Fact]
-		public async void CanConnectMultipleSubscriptionsSimultaneously()
+		public async void CanConnectTwoSubscriptionsSimultaneously()
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var callbackTester = new CallbackTester<Exception>();
@@ -189,10 +183,12 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse> observable1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
-				var tester = subscription1.SubscribeTester();
+				var tester = observable1.SubscribeTester();
+				var tester2 = observable2.SubscribeTester();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
@@ -202,42 +198,31 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
-				var tester2 = subscription2.SubscribeTester();
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
-					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
-				}, TimeSpan.FromSeconds(10));
+				await Task.Delay(500); // ToDo: can be removed after https://github.com/graphql-dotnet/server/pull/199 was merged and released
+
+				response = await client.JoinDeveloperUser().ConfigureAwait(false);
+				Assert.Equal("developer", (string)response.Data.join.displayName.Value);
 
-				const string message2 = "How are you?";
-				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-				});
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+					Assert.Equal("1", (string)gqlResponse.Data.userJoined.id.Value);
+					Assert.Equal("developer", (string)gqlResponse.Data.userJoined.displayName.Value);
 				});
-
+				
 				Debug.WriteLine("disposing subscription...");
-				tester.Dispose();
+				tester2.Dispose();
 
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
 				});
 
 				// disposing the client should complete the subscription
 				client.Dispose();
-				tester2.ShouldHaveCompleted();
+				tester.ShouldHaveCompleted();
 			}
 		}
 
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
index 7c2a2333..0ca1dfbd 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -16,7 +16,18 @@ public ChatMutation(IChat chat)
                     var message = chat.AddMessage(receivedMessage);
                     return message;
                 });
-        }
+
+			Field<MessageFromType>("join",
+				arguments: new QueryArguments(
+					new QueryArgument<StringGraphType> { Name = "userId" }
+				),
+				resolve: context =>
+				{
+					var userId = context.GetArgument<string>("userId");
+					var userJoined = chat.Join(userId);
+					return userJoined;
+				});
+		}
     }
 
     public class MessageInputType : InputObjectGraphType
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 3c8c9624..0ceb77a5 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -25,7 +25,15 @@ public ChatSubscriptions(IChat chat)
                 Subscriber = new EventStreamResolver<Message>(Subscribe)
             });
 
-            AddField(new EventStreamFieldType
+			AddField(new EventStreamFieldType
+			{
+				Name = "contentAdded",
+				Type = typeof(MessageType),
+				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+				Subscriber = new EventStreamResolver<Message>(Subscribe)
+			});
+
+			AddField(new EventStreamFieldType
             {
                 Name = "messageAddedByUser",
                 Arguments = new QueryArguments(
@@ -35,7 +43,15 @@ public ChatSubscriptions(IChat chat)
                 Resolver = new FuncFieldResolver<Message>(ResolveMessage),
                 Subscriber = new EventStreamResolver<Message>(SubscribeById)
             });
-        }
+
+			AddField(new EventStreamFieldType
+			{
+				Name = "userJoined",
+				Type = typeof(MessageFromType),
+				Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
+				Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
+			});
+		}
 
         private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
         {
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
index 68c8e86b..e52c0432 100644
--- a/tests/IntegrationTestServer/ChatSchema/IChat.cs
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -11,16 +11,20 @@ public interface IChat
 
         Message AddMessage(Message message);
 
-        IObservable<Message> Messages(string user);
+		MessageFrom Join(string userId);
 
-        Message AddMessage(ReceivedMessage message);
+		IObservable<Message> Messages(string user);
+		IObservable<MessageFrom> UserJoined();
+
+		Message AddMessage(ReceivedMessage message);
     }
 
     public class Chat : IChat
     {
         private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+		private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
 
-        public Chat()
+		public Chat()
         {
             AllMessages = new ConcurrentStack<Message>();
             Users = new ConcurrentDictionary<string, string>
@@ -58,9 +62,25 @@ public Message AddMessage(Message message)
             AllMessages.Push(message);
             _messageStream.OnNext(message);
             return message;
-        }
+		}
+
+		public MessageFrom Join(string userId)
+		{
+			if (!Users.TryGetValue(userId, out var displayName))
+			{
+				displayName = "(unknown)";
+			}
+
+			var joinedUser = new MessageFrom {
+				Id = userId,
+				DisplayName = displayName
+			};
 
-        public IObservable<Message> Messages(string user)
+			_userJoined.OnNext(joinedUser);
+			return joinedUser;
+		}
+
+		public IObservable<Message> Messages(string user)
         {
             return _messageStream
                 .Select(message =>
@@ -75,5 +95,16 @@ public void AddError(Exception exception)
         {
             _messageStream.OnError(exception);
         }
-    }
+
+		public IObservable<MessageFrom> UserJoined()
+		{
+			return _userJoined.AsObservable();
+		}
+	}
+
+	public class User
+	{
+		public string Id { get; set; }
+		public string Name { get; set; }
+	}
 }
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 179554ff..cfba48cd 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -9,10 +9,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
     <PackageReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
     <PackageReference Include="System.Reactive" Version="4.1.2" />
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index fd8448a8..9b0392b7 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Logging;
 
 namespace IntegrationTestServer
 {
@@ -12,6 +13,7 @@ public static void Main(string[] args)
 
 		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
 			WebHost.CreateDefaultBuilder(args)
-				.UseStartup<Startup>();
+				.UseStartup<Startup>()
+			    .ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
 	}
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 0161c739..166bf202 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,6 +1,7 @@
 using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Voyager;
+using GraphQL.Server.Ui.Playground;
 using IntegrationTestServer.ChatSchema;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -63,6 +64,10 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 				GraphQLEndPoint = "/graphql",
 				Path = "/ui/voyager"
 			});
+			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions
+			{
+				Path = "/ui/playground"
+			});
 			app.UseMvc();
 		}
 	}

From b5bba654e94fbd4f445c3bddf1fd01fd8d17698b Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 11 Feb 2019 19:51:59 +0100
Subject: [PATCH 45/49] Fix concurrent subscriptions (#94)

* add StringEnumConverter to JsonSerializerSettings

* fix dependencies

* change version

* fix version

* fix CloseAsync

* lock dispose

* implement external exception handling for subscription streams

* fix doc comment

* add back-off delay for automatic reconnects

* create GraphQLHttpWebSocket class

* get single socket working

* fix subscription test, cleanup code

* more code cleanup

* add test CanConnectMultipleSubscriptionsSimultaneously

* dynamically find free ports for integration test

* add WebSocketExceptionHandler to clientOptions

* move reconnect-logic into subscriptions

* move external exception handler declaration to CreateSubscriptionStream overloads

* fix exception on disposing disconnected subscription

* fix tests, add console app for testing reconnect after server restart

* Update GraphQL.Client.Tests.csproj

* Nullable check (#86)

* nonnullable

* fix some things

* other fix

* netstandard2.0

* Update README.md

* create "queue" for requests so that only one send operation is performed at a time

* fix websockets on win 7

* remove websockets4net dependency

* Update root.props

* Update config.yml

* IsTestProject

* Benchmar

* benchmark

* Update GraphQLLocation.cs

* new Spec

* fix suff for dotnet core 3.0

* check response for 'null' in where clause

* add obsolete parameterless constructor to GraphQLRequest

* add debug output in websocket receive

* reuse observables for identical requests

* store changes to consoleapp

* fix StackOverflowException in GraphQLRequest.GetHashCode()

* fix receiving long messages via websocket

* add obsolete constructor

* make ReceiveResultStream observable Hot

* fix multiple subscriptions by using subject in GraphQLHttpWebSocket

* fix overlapping subscriptions

* fix subscription test to work arround https://github.com/graphql-dotnet/server/pull/199

* add an observable which publishes all websocket exceptions

* fix OnNext calls of exceptionSubject

* fix GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) constructor

* test requests via websockets

* bump pre-release version

* fix initializing websocket when multiple threads create a subscription concurrently
---
 root.props                                    |  2 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  7 ++-
 .../Http/GraphQLHttpWebSocket.cs              | 61 ++++++++++---------
 3 files changed, 38 insertions(+), 32 deletions(-)

diff --git a/root.props b/root.props
index b32dba6a..61db8f41 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.7</Version>
+		<Version>2.0.0-alpha.4.subscription-api.8</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index e6a76359..d242569b 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -171,7 +172,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 
 			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
 
-			subscriptionStreams.Add(request, observable);
+			subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
 
@@ -202,11 +203,11 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 				return subscriptionStreams[request];
 
 			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
-			subscriptionStreams.Add(request, observable);
+			subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
 
-		private Dictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new Dictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+		private ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
 
 		/// <summary>
 		/// Releases unmanaged resources
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 90caf737..28ae1e7b 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -81,6 +81,8 @@ await this.clientWebSocket.SendAsync(
 
 		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
 
+		private object _initializeLock = new object();
+
 		#region Private Methods
 
 		private Task _backOff()
@@ -100,36 +102,39 @@ public Task InitializeWebSocket()
 			if(_disposed != null)
 				throw new OperationCanceledException();
 
-			// if an initialization task is already running, return that
-			if(InitializeWebSocketTask != null &&
-			   !InitializeWebSocketTask.IsFaulted &&
-			   !InitializeWebSocketTask.IsCompleted)
-				return InitializeWebSocketTask;
-
-			// if the websocket is open, return a completed task
-			if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
-				return Task.CompletedTask;
-
-			// else (re-)create websocket and connect
-			//_responseStreamConnection?.Dispose();
-			clientWebSocket?.Dispose();
-
-			// fix websocket not supported on win 7 using
-			// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
-			clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
-			switch (clientWebSocket)
+			lock (_initializeLock)
 			{
-				case ClientWebSocket nativeWebSocket:
-					nativeWebSocket.Options.AddSubProtocol("graphql-ws");
-					break;
-				case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
-					managedWebSocket.Options.AddSubProtocol("graphql-ws");
-					break;
-				default:
-					throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
-			}
+				// if an initialization task is already running, return that
+				if(InitializeWebSocketTask != null &&
+				   !InitializeWebSocketTask.IsFaulted &&
+				   !InitializeWebSocketTask.IsCompleted)
+					return InitializeWebSocketTask;
+
+				// if the websocket is open, return a completed task
+				if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
+					return Task.CompletedTask;
+
+				// else (re-)create websocket and connect
+				//_responseStreamConnection?.Dispose();
+				clientWebSocket?.Dispose();
+
+				// fix websocket not supported on win 7 using
+				// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
+				clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+				switch (clientWebSocket)
+				{
+					case ClientWebSocket nativeWebSocket:
+						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+						break;
+					case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
+						managedWebSocket.Options.AddSubProtocol("graphql-ws");
+						break;
+					default:
+						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
+				}
 
-			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+				return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+			}
 		}
 		
 		private IObservable<GraphQLWebSocketResponse> _createResponseStream()

From 93cd3704190e0d96d83f65080a6b4fa8cd9fdd70 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 7 Mar 2019 11:42:44 +0100
Subject: [PATCH 46/49] Fix json converter in websocket (#99)

* add StringEnumConverter to JsonSerializerSettings

* fix dependencies

* change version

* fix version

* fix CloseAsync

* lock dispose

* implement external exception handling for subscription streams

* fix doc comment

* add back-off delay for automatic reconnects

* create GraphQLHttpWebSocket class

* get single socket working

* fix subscription test, cleanup code

* more code cleanup

* add test CanConnectMultipleSubscriptionsSimultaneously

* dynamically find free ports for integration test

* add WebSocketExceptionHandler to clientOptions

* move reconnect-logic into subscriptions

* move external exception handler declaration to CreateSubscriptionStream overloads

* fix exception on disposing disconnected subscription

* fix tests, add console app for testing reconnect after server restart

* Update GraphQL.Client.Tests.csproj

* Nullable check (#86)

* nonnullable

* fix some things

* other fix

* netstandard2.0

* Update README.md

* create "queue" for requests so that only one send operation is performed at a time

* fix websockets on win 7

* remove websockets4net dependency

* Update root.props

* Update config.yml

* IsTestProject

* Benchmar

* benchmark

* Update GraphQLLocation.cs

* new Spec

* fix suff for dotnet core 3.0

* check response for 'null' in where clause

* add obsolete parameterless constructor to GraphQLRequest

* add debug output in websocket receive

* reuse observables for identical requests

* store changes to consoleapp

* fix StackOverflowException in GraphQLRequest.GetHashCode()

* fix receiving long messages via websocket

* add obsolete constructor

* make ReceiveResultStream observable Hot

* fix multiple subscriptions by using subject in GraphQLHttpWebSocket

* fix overlapping subscriptions

* fix subscription test to work arround https://github.com/graphql-dotnet/server/pull/199

* add an observable which publishes all websocket exceptions

* fix OnNext calls of exceptionSubject

* fix GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) constructor

* test requests via websockets

* bump pre-release version

* use JsonSerializerSettings from options in websocket requests

* fix query errors via websocket

* fix sequence termination and error handling in websocket streams
---
 root.props                                    |  2 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 79 ++++++++--------
 .../Http/GraphQLHttpWebSocket.cs              |  4 +-
 .../SubscriptionsTest.cs                      | 89 ++++++++++++++++++-
 .../ChatSchema/ChatSubscriptions.cs           |  9 ++
 5 files changed, 138 insertions(+), 45 deletions(-)

diff --git a/root.props b/root.props
index 61db8f41..df16b57f 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.8</Version>
+		<Version>2.0.0-alpha.4.subscription-api.10</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index ef71a0ce..4ba91205 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -3,6 +3,7 @@
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Common;
@@ -35,31 +36,39 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Id = startRequest.Id,
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
-					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => {
-							return response != null && response.Id == startRequest.Id;
-						})
-						.SelectMany(response =>
-						{
-							switch (response.Type)
+
+					var observable = Observable.Create<GraphQLResponse>(o =>
+						graphQlHttpWebSocket.ResponseStream.Subscribe(response =>
 							{
-								case GQLWebSocketMessageType.GQL_COMPLETE:
+								// ignore null values and messages for other requests
+								if (response == null || response.Id != startRequest.Id) return;
+
+								// terminate the sequence when a 'complete' message is received
+								if (response.Type == GQLWebSocketMessageType.GQL_COMPLETE)
+								{
 									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
-									return Observable.Empty<GraphQLResponse>();
-								case GQLWebSocketMessageType.GQL_ERROR:
-									Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
-									return Observable.Throw<GraphQLResponse>(
-										new GraphQLSubscriptionException(response.Payload));
-								default:
-									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
-									return Observable.Return(((JObject) response?.Payload)
-										?.ToObject<GraphQLResponse>());
-							}
-						});
+									o.OnCompleted();
+									return;
+								}
+
+								// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+								Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+								o.OnNext(((JObject)response.Payload)?.ToObject<GraphQLResponse>());
+
+								// in case of a GraphQL error, terminate the sequence after the response has been posted
+								if (response.Type == GQLWebSocketMessageType.GQL_ERROR)
+								{
+									Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
+									o.OnCompleted();
+								}
+							},
+							o.OnError,
+							o.OnCompleted)
+					);
 
 					try
 					{
-						// intialize websocket (completes immediately if socket is already open)
+						// initialize websocket (completes immediately if socket is already open)
 						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
 					}
 					catch (Exception e)
@@ -148,12 +157,12 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				.Publish().RefCount();
 		}
 
-		internal static async Task<GraphQLResponse> Request(
+		internal static Task<GraphQLResponse> Request(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
 			CancellationToken cancellationToken = default)
 		{
-			return await Observable.Create<GraphQLResponse>(async observer =>
+			return Observable.Create<GraphQLResponse>(async observer =>
 			{
 				var websocketRequest = new GraphQLWebSocketRequest
 				{
@@ -162,25 +171,12 @@ internal static async Task<GraphQLResponse> Request(
 					Payload = request
 				};
 				var observable = graphQlHttpWebSocket.ResponseStream
-					.Where(response => {
-						return response != null && response.Id == websocketRequest.Id;
-					})
-					.SelectMany(response =>
+					.Where(response => response != null && response.Id == websocketRequest.Id)
+					.TakeUntil(response => response.Type == GQLWebSocketMessageType.GQL_COMPLETE)
+					.Select(response =>
 					{
-						switch (response.Type)
-						{
-							case GQLWebSocketMessageType.GQL_COMPLETE:
-								Debug.WriteLine($"received 'complete' message on request {websocketRequest.Id}");
-								return Observable.Empty<GraphQLResponse>();
-							case GQLWebSocketMessageType.GQL_ERROR:
-								Debug.WriteLine($"received 'error' message on request {websocketRequest.Id}");
-								return Observable.Throw<GraphQLResponse>(
-									new GraphQLSubscriptionException(response.Payload));
-							default:
-								Debug.WriteLine($"received response for request {websocketRequest.Id}");
-								return Observable.Return(((JObject)response?.Payload)
-									?.ToObject<GraphQLResponse>());
-						}
+						Debug.WriteLine($"received response for request {websocketRequest.Id}");
+						return ((JObject) response?.Payload)?.ToObject<GraphQLResponse>();
 					});
 
 				try
@@ -215,7 +211,8 @@ internal static async Task<GraphQLResponse> Request(
 			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 			.Catch<GraphQLResponse, OperationCanceledException>(exception =>
 				Observable.Empty<GraphQLResponse>())
-			.FirstOrDefaultAsync();
+			.FirstOrDefaultAsync()
+			.ToTask(cancellationToken);
 		}
 	}
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 28ae1e7b..eb2881ba 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -65,7 +65,7 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
 				}
 
 				await InitializeWebSocket().ConfigureAwait(false);
-				var webSocketRequestString = JsonConvert.SerializeObject(request);
+				var webSocketRequestString = JsonConvert.SerializeObject(request, _options.JsonSerializerSettings);
 				await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString)),
 					WebSocketMessageType.Text,
@@ -245,7 +245,7 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 						{
 							var stringResult = await reader.ReadToEndAsync();
 							Debug.WriteLine($"data received on websocket {clientWebSocket.GetHashCode()}: {stringResult}");
-							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult, _options.JsonSerializerSettings);
 						}
 					}
 					else
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 635a0d1c..fb704ad4 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -43,10 +43,11 @@ public SubscriptionsTest()
 		{
 		}
 
-		private GraphQLHttpClient GetGraphQLClient(int port)
+		private GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+				UseWebSocketForQueriesAndMutations = requestsViaWebsocket
 			});
 
 
@@ -65,6 +66,34 @@ public async void AssertTestingHarness()
 			}
 		}
 
+		[Fact]
+		public async void CanSendRequestViaWebsocket()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port, true);
+				const string message = "some random testing message";
+				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
+
+				Assert.Equal(message, (string)response.Data.addMessage.content);
+			}
+		}
+
+		[Fact]
+		public async void CanHandleRequestErrorViaWebsocket()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port, true);
+				const string message = "some random testing message";
+				var response = await client.SendQueryAsync(new GraphQLRequest("this query is formatted quite badly")).ConfigureAwait(false);
+
+				Assert.Single(response.Errors);
+			}
+		}
+
 		private const string SubscriptionQuery = @"
 			subscription {
 			  messageAdded{
@@ -272,5 +301,63 @@ public async void CanHandleConnectionTimeout()
 			tester.ShouldHaveCompleted(TimeSpan.FromSeconds(5));
 			server.Dispose();
 		}
+		
+		[Fact]
+		public async void CanHandleSubscriptionError()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(
+					new GraphQLRequest(@"
+						subscription {
+						  failImmediately {
+						    content
+						  }
+						}")
+					);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Single(gqlResponse.Errors);
+				});
+				tester.ShouldHaveCompleted();
+
+				client.Dispose();
+			}
+		}
+
+		[Fact]
+		public async void CanHandleQueryErrorInSubscription()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(
+					new GraphQLRequest(@"
+						subscription {
+						  fieldDoesNotExist {
+						    content
+						  }
+						}")
+				);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Single(gqlResponse.Errors);
+				});
+				tester.ShouldHaveCompleted();
+
+				client.Dispose();
+			}
+		}
 	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 0ceb77a5..178d2b78 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -51,6 +51,15 @@ public ChatSubscriptions(IChat chat)
 				Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
 				Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
 			});
+
+
+			AddField(new EventStreamFieldType
+			{
+				Name = "failImmediately",
+				Type = typeof(MessageType),
+				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+				Subscriber = new EventStreamResolver<Message>(context => throw new NotSupportedException("this is supposed to fail"))
+			});
 		}
 
         private IObservable<Message> SubscribeById(ResolveEventStreamContext context)

From fd6b8c3976ac24b05b2128a4bd7564e9bf9349a2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 1 Apr 2019 11:55:56 +0200
Subject: [PATCH 47/49] create configurable preprocessing method for
 GraphQLRequests

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 37 ++++++++++---------
 .../Http/GraphQLHttpClientOptions.cs          |  6 +++
 2 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index d242569b..a9a0996f 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -118,20 +118,18 @@ public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken canc
 
 		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
 		{
+			var preprocessed = Options.PreProcessRequest(request, this);
+
 			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
-				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+				? this.graphQlHttpWebSocket.Request(preprocessed, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(preprocessed, cancellationToken);
 		}
 
 		public Task<GraphQLResponse> SendMutationAsync(string query, CancellationToken cancellationToken = default) =>
 			this.SendMutationAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
-		{
-			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
-				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
-		}
+		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
+			this.SendQueryAsync(request, cancellationToken);
 
 		[Obsolete("EXPERIMENTAL API")]
 		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, CancellationToken cancellationToken = default) =>
@@ -148,8 +146,9 @@ private GraphQLHttpSubscriptionResult _createSubscription(GraphQLRequest request
 		{
 			if (request == null) { throw new ArgumentNullException(nameof(request)); }
 			if (request.Query == null) { throw new ArgumentNullException(nameof(request.Query)); }
+			var preprocessed = Options.PreProcessRequest(request, this);
 
-			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(_getWebSocketUri(), request);
+			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(_getWebSocketUri(), preprocessed);
 			graphQLSubscriptionResult.StartAsync(cancellationToken);
 			return graphQLSubscriptionResult;
 		}
@@ -167,12 +166,14 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			if (subscriptionStreams.ContainsKey(request))
-				return subscriptionStreams[request];
+			var preprocessed = Options.PreProcessRequest(request, this);
+
+			if (subscriptionStreams.ContainsKey(preprocessed))
+				return subscriptionStreams[preprocessed];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(preprocessed, Options, cancellationToken: _cancellationTokenSource.Token);
 
-			subscriptionStreams.TryAdd(request, observable);
+			subscriptionStreams.TryAdd(preprocessed, observable);
 			return observable;
 		}
 
@@ -199,11 +200,13 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			if(subscriptionStreams.ContainsKey(request))
-				return subscriptionStreams[request];
+			var preprocessed = Options.PreProcessRequest(request, this);
+
+			if (subscriptionStreams.ContainsKey(preprocessed))
+				return subscriptionStreams[preprocessed];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
-			subscriptionStreams.TryAdd(request, observable);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(preprocessed, Options, exceptionHandler, _cancellationTokenSource.Token);
+			subscriptionStreams.TryAdd(preprocessed, observable);
 			return observable;
 		}
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index ddce13c7..65f82edb 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -3,6 +3,7 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
+using GraphQL.Common.Request;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
@@ -54,6 +55,11 @@ public class GraphQLHttpClientOptions {
 		/// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
 		/// </summary>
 		public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
+
+		/// <summary>
+		/// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
+		/// </summary>
+		public Func<GraphQLRequest, GraphQLHttpClient, GraphQLRequest> PreProcessRequest = (request, client) => request;
 	}
 
 }

From 13cfa08b6064fdc64c592be491f34bb1f0a0c033 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 1 Apr 2019 12:19:54 +0200
Subject: [PATCH 48/49] make preprocessing func return a task, fix
 preprocessing of subscription requests

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 32 ++++++++-----------
 .../Http/GraphQLHttpClientOptions.cs          |  3 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  5 +--
 3 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index a9a0996f..a0ed422a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -116,13 +116,13 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
 			this.SendQueryAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		public async Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
 		{
-			var preprocessed = Options.PreProcessRequest(request, this);
+			var preprocessed = await Options.PreProcessRequest(request, this).ConfigureAwait(false);
 
 			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request(preprocessed, cancellationToken)
-				: this.graphQLHttpHandler.PostAsync(preprocessed, cancellationToken);
+				? await this.graphQlHttpWebSocket.Request(preprocessed, cancellationToken).ConfigureAwait(false)
+				: await this.graphQLHttpHandler.PostAsync(preprocessed, cancellationToken).ConfigureAwait(false);
 		}
 
 		public Task<GraphQLResponse> SendMutationAsync(string query, CancellationToken cancellationToken = default) =>
@@ -146,7 +146,7 @@ private GraphQLHttpSubscriptionResult _createSubscription(GraphQLRequest request
 		{
 			if (request == null) { throw new ArgumentNullException(nameof(request)); }
 			if (request.Query == null) { throw new ArgumentNullException(nameof(request.Query)); }
-			var preprocessed = Options.PreProcessRequest(request, this);
+			var preprocessed = Options.PreProcessRequest(request, this).GetAwaiter().GetResult();
 
 			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(_getWebSocketUri(), preprocessed);
 			graphQLSubscriptionResult.StartAsync(cancellationToken);
@@ -165,15 +165,13 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		{
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+			
+			if (subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
 
-			var preprocessed = Options.PreProcessRequest(request, this);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, this, cancellationToken: _cancellationTokenSource.Token);
 
-			if (subscriptionStreams.ContainsKey(preprocessed))
-				return subscriptionStreams[preprocessed];
-
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(preprocessed, Options, cancellationToken: _cancellationTokenSource.Token);
-
-			subscriptionStreams.TryAdd(preprocessed, observable);
+			subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
 
@@ -200,13 +198,11 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			var preprocessed = Options.PreProcessRequest(request, this);
-
-			if (subscriptionStreams.ContainsKey(preprocessed))
-				return subscriptionStreams[preprocessed];
+			if (subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(preprocessed, Options, exceptionHandler, _cancellationTokenSource.Token);
-			subscriptionStreams.TryAdd(preprocessed, observable);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, this, exceptionHandler, _cancellationTokenSource.Token);
+			subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 65f82edb..9fc9134d 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -3,6 +3,7 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
+using System.Threading.Tasks;
 using GraphQL.Common.Request;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
@@ -59,7 +60,7 @@ public class GraphQLHttpClientOptions {
 		/// <summary>
 		/// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
 		/// </summary>
-		public Func<GraphQLRequest, GraphQLHttpClient, GraphQLRequest> PreProcessRequest = (request, client) => request;
+		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreProcessRequest = (request, client) => Task.FromResult(request);
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 4ba91205..03de93bf 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -18,18 +18,19 @@ public static class GraphQLHttpSubscriptionHelpers
 		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
-			GraphQLHttpClientOptions options,
+			GraphQLHttpClient client,
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
 		{
 			return Observable.Defer(() =>
 				Observable.Create<GraphQLResponse>(async observer =>
 				{
+					var preprocessedRequest = await client.Options.PreProcessRequest(request, client);
 					var startRequest = new GraphQLWebSocketRequest
 					{
 						Id = Guid.NewGuid().ToString("N"),
 						Type = GQLWebSocketMessageType.GQL_START,
-						Payload = request
+						Payload = preprocessedRequest
 					};
 					var closeRequest = new GraphQLWebSocketRequest
 					{

From 1b287b8b5958875c1fc8df9e6fc755d161f5b4ed Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 1 Apr 2019 12:29:45 +0200
Subject: [PATCH 49/49] make PreprocessRequest a property

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs              | 4 ++--
 src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs       | 2 +-
 src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index a0ed422a..f05cd2ef 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -118,7 +118,7 @@ public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken canc
 
 		public async Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
 		{
-			var preprocessed = await Options.PreProcessRequest(request, this).ConfigureAwait(false);
+			var preprocessed = await Options.PreprocessRequest(request, this).ConfigureAwait(false);
 
 			return Options.UseWebSocketForQueriesAndMutations
 				? await this.graphQlHttpWebSocket.Request(preprocessed, cancellationToken).ConfigureAwait(false)
@@ -146,7 +146,7 @@ private GraphQLHttpSubscriptionResult _createSubscription(GraphQLRequest request
 		{
 			if (request == null) { throw new ArgumentNullException(nameof(request)); }
 			if (request.Query == null) { throw new ArgumentNullException(nameof(request.Query)); }
-			var preprocessed = Options.PreProcessRequest(request, this).GetAwaiter().GetResult();
+			var preprocessed = Options.PreprocessRequest(request, this).GetAwaiter().GetResult();
 
 			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(_getWebSocketUri(), preprocessed);
 			graphQLSubscriptionResult.StartAsync(cancellationToken);
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 9fc9134d..46d08abf 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -60,7 +60,7 @@ public class GraphQLHttpClientOptions {
 		/// <summary>
 		/// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
 		/// </summary>
-		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreProcessRequest = (request, client) => Task.FromResult(request);
+		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; }= (request, client) => Task.FromResult(request);
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 03de93bf..24b3e32c 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -25,7 +25,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 			return Observable.Defer(() =>
 				Observable.Create<GraphQLResponse>(async observer =>
 				{
-					var preprocessedRequest = await client.Options.PreProcessRequest(request, client);
+					var preprocessedRequest = await client.Options.PreprocessRequest(request, client);
 					var startRequest = new GraphQLWebSocketRequest
 					{
 						Id = Guid.NewGuid().ToString("N"),