Converting more projects to .netstandard2.0

darkl · darkl · commit 5d0d93949230 · 2017-11-24T18:07:28.000-05:00
diff --git a/NuGet/WampSharp.Vtortola.nuspec b/NuGet/WampSharp.Vtortola.nuspec
@@ -5,8 +5,14 @@
     <authors>CodeSharp</authors>
     <owners />
     <dependencies>
-      <dependency id="WampSharp" version="[$version$]" />
-      <dependency id="vtortola.WebSocketListener" version="[2.2.2]" />
+      <group targetFramework="net45">
+        <dependency id="WampSharp" version="[$version$]" />
+        <dependency id="vtortola.WebSocketListener" version="[2.2.2]" />
+      </group>
+      <group targetFramework="netstandard2.0">
+        <dependency id="WampSharp" version="[$version$]" />
+        <dependency id="vtortola.WebSocketListener" version="[3.0.0-beta]" />
+      </group>
     </dependencies>
     <id>WampSharp.Vtortola</id>
     <title>WampSharp Vtortola support</title>
@@ -18,5 +24,7 @@
   <files>
     <file src="$bin$\net45\WampSharp.Vtortola.dll" target="lib\net45\WampSharp.Vtortola.dll" />
     <file src="$bin$\net45\WampSharp.Vtortola.xml" target="lib\net45\WampSharp.Vtortola.xml" />
+    <file src="$bin$\netstandard2.0\WampSharp.Vtortola.dll" target="lib\netstandard2.0\WampSharp.Vtortola.dll" />
+    <file src="$bin$\netstandard2.0\WampSharp.Vtortola.xml" target="lib\netstandard2.0\WampSharp.Vtortola.xml" />
   </files>
 </package>
diff --git a/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampBinaryConnection.cs b/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampBinaryConnection.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using vtortola.WebSockets;
 using WampSharp.Core.Message;
@@ -12,9 +13,10 @@ internal class VtortolaWampBinaryConnection<TMessage> : VtortolaWampConnection<T
         private readonly IWampBinaryBinding<TMessage> mBinding;
 
         public VtortolaWampBinaryConnection(WebSocket connection,
-                                            IWampBinaryBinding<TMessage> binding,
-                                            ICookieAuthenticatorFactory cookieAuthenticatorFactory) :
-                                                base(connection, cookieAuthenticatorFactory)
+            CancellationToken cancellationToken,
+            IWampBinaryBinding<TMessage> binding,
+            ICookieAuthenticatorFactory cookieAuthenticatorFactory) :
+            base(connection, cancellationToken, cookieAuthenticatorFactory)
         {
             mBinding = binding;
         }
diff --git a/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampConnection.cs b/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampConnection.cs
@@ -16,14 +16,17 @@ internal abstract class VtortolaWampConnection<TMessage> : AsyncWebSocketWampCon
         IDetailedWampConnection<TMessage>
     {
         protected readonly WebSocket mWebsocket;
+        private readonly CancellationToken mCancellationToken;
         private readonly VtortolaTransportDetails mTransportDetails;
 
         protected VtortolaWampConnection(WebSocket websocket,
-                                         ICookieAuthenticatorFactory cookieAuthenticatorFactory)
+            CancellationToken cancellationToken,
+            ICookieAuthenticatorFactory cookieAuthenticatorFactory)
             : base(new CookieCollectionCookieProvider(websocket.HttpRequest.Cookies),
-                   cookieAuthenticatorFactory)
+                cookieAuthenticatorFactory)
         {
             mWebsocket = websocket;
+            mCancellationToken = cancellationToken;
             mTransportDetails = new VtortolaTransportDetails(mWebsocket);
         }
 
@@ -33,7 +36,7 @@ public async Task HandleWebSocketAsync()
             {
                 RaiseConnectionOpen();
 
-                while (mWebsocket.IsConnected)
+                while (IsConnected)
                 {
                     WebSocketMessageReadStream message =
                         await mWebsocket.ReadMessageAsync(CancellationToken.None)
@@ -63,7 +66,8 @@ protected override bool IsConnected
         {
             get
             {
-                return mWebsocket.IsConnected;
+                return !mCancellationToken.IsCancellationRequested &&
+                    mWebsocket.IsConnected;
             }
         }
 
diff --git a/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampTextConnection.cs b/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampTextConnection.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using vtortola.WebSockets;
 using WampSharp.Core.Message;
@@ -12,9 +13,10 @@ internal class VtortolaWampTextConnection<TMessage> : VtortolaWampConnection<TMe
         private readonly IWampTextBinding<TMessage> mBinding;
 
         public VtortolaWampTextConnection(WebSocket connection,
-                                          IWampTextBinding<TMessage> binding,
-                                          ICookieAuthenticatorFactory cookieAuthenticatorFactory) :
-                                              base(connection, cookieAuthenticatorFactory)
+            CancellationToken cancellationToken,
+            IWampTextBinding<TMessage> binding,
+            ICookieAuthenticatorFactory cookieAuthenticatorFactory) :
+            base(connection, cancellationToken, cookieAuthenticatorFactory)
         {
             mBinding = binding;
         }
diff --git a/src/net45/Extensions/WampSharp.Vtortola/VtortolaWebSocketHttpResponse.cs b/src/net45/Extensions/WampSharp.Vtortola/VtortolaWebSocketHttpResponse.cs
@@ -1,6 +1,9 @@
 using System.Linq;
 using System.Net;
 using vtortola.WebSockets;
+#if NETCORE
+using HttpStatusCode = vtortola.WebSockets.HttpStatusCode;
+#endif
 
 namespace WampSharp.Vtortola
 {
diff --git a/src/net45/Extensions/WampSharp.Vtortola/VtortolaWebSocketTransport.cs b/src/net45/Extensions/WampSharp.Vtortola/VtortolaWebSocketTransport.cs
@@ -3,10 +3,10 @@
 using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
-using WampSharp.Logging;
 using vtortola.WebSockets;
 using vtortola.WebSockets.Deflate;
 using vtortola.WebSockets.Rfc6455;
+using WampSharp.Logging;
 using WampSharp.Core.Listener;
 using WampSharp.V2.Authentication;
 using WampSharp.V2.Binding;
@@ -17,13 +17,14 @@ namespace WampSharp.Vtortola
     /// <summary>
     /// Represents a WebSocket transport implemented with Vtortola.
     /// </summary>
-    public class VtortolaWebSocketTransport : WebSocketTransport<WebSocket>
+    public class VtortolaWebSocketTransport : WebSocketTransport<WebSocketData>
     {
         private readonly IPEndPoint mEndpoint;
         private WebSocketListener mListener;
         private readonly bool mPerMessageDeflate;
         private readonly X509Certificate2 mCertificate;
         private readonly WebSocketListenerOptions mOptions;
+        private CancellationTokenSource mCancellationToken;
 
         /// <summary>
         /// Creates a new instance of <see cref="VtortolaWebSocketTransport"/>
@@ -71,6 +72,7 @@ protected VtortolaWebSocketTransport
 
         public override void Dispose()
         {
+            mCancellationToken.Cancel();
             mListener.Stop();
             mListener.Dispose();
         }
@@ -82,42 +84,56 @@ public override void Open()
             WebSocketListenerOptions options = mOptions ?? new WebSocketListenerOptions();
 
             options.SubProtocols = protocols;
-
+            
             WebSocketListener listener = new WebSocketListener(mEndpoint, options);
 
+#if NETCORE
+            WebSocketFactoryRfc6455 factory = new WebSocketFactoryRfc6455();
+#else
             WebSocketFactoryRfc6455 factory = new WebSocketFactoryRfc6455(listener);
 
+#endif
             if (mPerMessageDeflate)
             {
-                factory.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());                
+#if NETCORE
+                listener.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());
+#else
+                factory.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());
+#endif
             }
 
             listener.Standards.RegisterStandard(factory);
-
+            
             if (mCertificate != null)
             {
                 listener.ConnectionExtensions.RegisterExtension(new WebSocketSecureConnectionExtension(mCertificate));
             }
 
+            mCancellationToken = new CancellationTokenSource();
+
+#if NETCORE
+            listener.StartAsync(mCancellationToken.Token);
+#else
             listener.Start();
+#endif
 
             mListener = listener;
 
-            Task.Run(new Func<Task>(ListenAsync));
+            Task.Run(new Func<Task>(() => ListenAsync(mCancellationToken.Token)));
         }
 
-        private async Task ListenAsync()
+        private async Task ListenAsync(CancellationToken cancellationToken)
         {
-            while (mListener.IsStarted)
+            while (!cancellationToken.IsCancellationRequested)
             {
                 try
                 {
-                    WebSocket websocket = await mListener.AcceptWebSocketAsync(CancellationToken.None)
+                    WebSocket websocket = await mListener.AcceptWebSocketAsync(cancellationToken)
                         .ConfigureAwait(false);
 
                     if (websocket != null)
                     {
-                        OnNewConnection(websocket);
+                        OnNewConnection(new WebSocketData(websocket, cancellationToken));
                     }
                 }
                 catch (Exception ex)
@@ -127,27 +143,33 @@ private async Task ListenAsync()
             }
         }
 
-        protected override string GetSubProtocol(WebSocket connection)
+        protected override string GetSubProtocol(WebSocketData connection)
         {
-            return connection.HttpResponse.WebSocketProtocol;
+            return connection.WebSocket.HttpResponse.WebSocketProtocol;
         }
 
-        protected override void OpenConnection<TMessage>(WebSocket original, IWampConnection<TMessage> connection)
+        protected override void OpenConnection<TMessage>(WebSocketData original, IWampConnection<TMessage> connection)
         {
             VtortolaWampConnection<TMessage> casted = connection as VtortolaWampConnection<TMessage>;
             Task.Run(new Func<Task>(casted.HandleWebSocketAsync));
         }
 
         protected override IWampConnection<TMessage> CreateBinaryConnection<TMessage>
-            (WebSocket connection, IWampBinaryBinding<TMessage> binding)
+            (WebSocketData connection, IWampBinaryBinding<TMessage> binding)
         {
-            return new VtortolaWampBinaryConnection<TMessage>(connection, binding, AuthenticatorFactory);
+            return new VtortolaWampBinaryConnection<TMessage>(connection.WebSocket,
+                connection.CancellationToken,
+                binding,
+                AuthenticatorFactory);
         }
 
         protected override IWampConnection<TMessage> CreateTextConnection<TMessage>
-            (WebSocket connection, IWampTextBinding<TMessage> binding)
+            (WebSocketData connection, IWampTextBinding<TMessage> binding)
         {
-            return new VtortolaWampTextConnection<TMessage>(connection, binding, AuthenticatorFactory);
+            return new VtortolaWampTextConnection<TMessage>(connection.WebSocket,
+                connection.CancellationToken,
+                binding,
+                AuthenticatorFactory);
         }
     }
 }
diff --git a/src/net45/Extensions/WampSharp.Vtortola/WebSocketData.cs b/src/net45/Extensions/WampSharp.Vtortola/WebSocketData.cs
@@ -0,0 +1,17 @@
+using System.Threading;
+using vtortola.WebSockets;
+
+namespace WampSharp.Vtortola
+{
+    public class WebSocketData
+    {
+        public WebSocket WebSocket { get; }
+        public CancellationToken CancellationToken { get; }
+
+        public WebSocketData(WebSocket webSocket, CancellationToken cancellationToken)
+        {
+            WebSocket = webSocket;
+            CancellationToken = cancellationToken;
+        }
+    }
+}
diff --git a/src/net45/WampSharp.WAMP1/WAMP1/V1/Api/Server/WampRequestContext.cs b/src/net45/WampSharp.WAMP1/WAMP1/V1/Api/Server/WampRequestContext.cs
@@ -1,5 +1,8 @@
 ﻿using System;
+#if !NETSTANDARD2_0
 using System.Runtime.Remoting.Messaging;
+#endif
+using System.Threading;
 using WampSharp.V1.Core.Contracts;
 using WampSharp.V1.Cra;
 
@@ -10,6 +13,7 @@ public class WampRequestContext
     {
         #region Static Members
 
+#if !NETSTANDARD2_0
         public static WampRequestContext Current
         {
             get
@@ -21,6 +25,21 @@ internal set
                 CallContext.LogicalSetData(typeof (WampRequestContext).Name, value);
             }
         }
+#else
+        private static readonly AsyncLocal<WampRequestContext> mCurrent = new AsyncLocal<WampRequestContext>();
+
+        public static WampRequestContext Current
+        {
+            get
+            {
+                return mCurrent.Value;
+            }
+            internal set
+            {
+                mCurrent.Value = value;
+            }
+        }
+#endif
 
         #endregion
 
diff --git a/src/netstandard2.0/Extensions/WampSharp.Vtortola/WampSharp.Vtortola.csproj b/src/netstandard2.0/Extensions/WampSharp.Vtortola/WampSharp.Vtortola.csproj
@@ -0,0 +1,29 @@
+﻿<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
+    <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <GenerateAssemblyCopyrightAttribute>false</GenerateAssemblyCopyrightAttribute>
+    <GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
+    <GenerateAssemblyFileVersionAttribute>false</GenerateAssemblyFileVersionAttribute>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\..\..\net45\Extensions\WampSharp.Vtortola\**\*.cs" Exclude="..\..\..\net45\Extensions\WampSharp.Vtortola\**\bin\**;..\..\..\net45\Extensions\WampSharp.Vtortola\**\obj\**;" />
+  </ItemGroup>
+
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+    <DefineConstants>NETCORE</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+    <ProjectReference Include="..\..\WampSharp\WampSharp.csproj" />
+    <PackageReference Include="vtortola.WebSocketListener" Version="3.0.0-beta" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/netstandard2.0/WampSharp.WAMP1/WampSharp.WAMP1.csproj b/src/netstandard2.0/WampSharp.WAMP1/WampSharp.WAMP1.csproj
@@ -0,0 +1,33 @@
+﻿<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <AssemblyTitle>WampSharp.WAMP1</AssemblyTitle>
+    <Authors>CodeSharp</Authors>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <AssemblyName>WampSharp.WAMP1</AssemblyName>
+    <PackageId>WampSharp.WAMP1</PackageId>
+    <PackageTags>websockets;wampws;rpc;pubsub;wampv2</PackageTags>
+    <PackageProjectUrl>https://github.com/Code-Sharp/WampSharp/</PackageProjectUrl>
+    <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
+    <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <GenerateAssemblyCopyrightAttribute>false</GenerateAssemblyCopyrightAttribute>
+    <GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
+    <GenerateAssemblyFileVersionAttribute>false</GenerateAssemblyFileVersionAttribute>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\..\net45\WampSharp.WAMP1\**\*.cs" Exclude="..\..\net45\WampSharp.WAMP1\**\bin\**;..\..\net45\WampSharp.WAMP1\**\obj\**;" />
+  </ItemGroup>
+  
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+    <DefineConstants>$(DefineConstants);NET45;</DefineConstants>
+  </PropertyGroup>
+  
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+    <ProjectReference Include="..\WampSharp\WampSharp.csproj" />
+  </ItemGroup>
+  
+</Project>
diff --git a/src/netstandard2.0/WampSharpNetStandard.sln b/src/netstandard2.0/WampSharpNetStandard.sln

Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,17 @@ internal abstract class VtortolaWampConnection<TMessage> : AsyncWebSocketWampCon`
`16`	`16`	`IDetailedWampConnection<TMessage>`
`17`	`17`	`{`
`18`	`18`	`protected readonly WebSocket mWebsocket;`
	`19`	`+ private readonly CancellationToken mCancellationToken;`
`19`	`20`	`private readonly VtortolaTransportDetails mTransportDetails;`
`20`	`21`
`21`	`22`	`protected VtortolaWampConnection(WebSocket websocket,`
`22`		`- ICookieAuthenticatorFactory cookieAuthenticatorFactory)`
	`23`	`+ CancellationToken cancellationToken,`
	`24`	`+ ICookieAuthenticatorFactory cookieAuthenticatorFactory)`
`23`	`25`	`: base(new CookieCollectionCookieProvider(websocket.HttpRequest.Cookies),`
`24`		`- cookieAuthenticatorFactory)`
	`26`	`+ cookieAuthenticatorFactory)`
`25`	`27`	`{`
`26`	`28`	`mWebsocket = websocket;`
	`29`	`+ mCancellationToken = cancellationToken;`
`27`	`30`	`mTransportDetails = new VtortolaTransportDetails(mWebsocket);`
`28`	`31`	`}`
`29`	`32`
`@@ -33,7 +36,7 @@ public async Task HandleWebSocketAsync()`
`33`	`36`	`{`
`34`	`37`	`RaiseConnectionOpen();`
`35`	`38`
`36`		`- while (mWebsocket.IsConnected)`
	`39`	`+ while (IsConnected)`
`37`	`40`	`{`
`38`	`41`	`WebSocketMessageReadStream message =`
`39`	`42`	`await mWebsocket.ReadMessageAsync(CancellationToken.None)`
`@@ -63,7 +66,8 @@ protected override bool IsConnected`
`63`	`66`	`{`
`64`	`67`	`get`
`65`	`68`	`{`
`66`		`- return mWebsocket.IsConnected;`
	`69`	`+ return !mCancellationToken.IsCancellationRequested &&`
	`70`	`+ mWebsocket.IsConnected;`
`67`	`71`	`}`
`68`	`72`	`}`
`69`	`73`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,9 @@`
`1`	`1`	`using System.Linq;`
`2`	`2`	`using System.Net;`
`3`	`3`	`using vtortola.WebSockets;`
	`4`	`+#if NETCORE`
	`5`	`+using HttpStatusCode = vtortola.WebSockets.HttpStatusCode;`
	`6`	`+#endif`
`4`	`7`
`5`	`8`	`namespace WampSharp.Vtortola`
`6`	`9`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3,10 +3,10 @@`
`3`	`3`	`using System.Security.Cryptography.X509Certificates;`
`4`	`4`	`using System.Threading;`
`5`	`5`	`using System.Threading.Tasks;`
`6`		`-using WampSharp.Logging;`
`7`	`6`	`using vtortola.WebSockets;`
`8`	`7`	`using vtortola.WebSockets.Deflate;`
`9`	`8`	`using vtortola.WebSockets.Rfc6455;`
	`9`	`+using WampSharp.Logging;`
`10`	`10`	`using WampSharp.Core.Listener;`
`11`	`11`	`using WampSharp.V2.Authentication;`
`12`	`12`	`using WampSharp.V2.Binding;`
`@@ -17,13 +17,14 @@ namespace WampSharp.Vtortola`
`17`	`17`	`/// <summary>`
`18`	`18`	`/// Represents a WebSocket transport implemented with Vtortola.`
`19`	`19`	`/// </summary>`
`20`		`- public class VtortolaWebSocketTransport : WebSocketTransport<WebSocket>`
	`20`	`+ public class VtortolaWebSocketTransport : WebSocketTransport<WebSocketData>`
`21`	`21`	`{`
`22`	`22`	`private readonly IPEndPoint mEndpoint;`
`23`	`23`	`private WebSocketListener mListener;`
`24`	`24`	`private readonly bool mPerMessageDeflate;`
`25`	`25`	`private readonly X509Certificate2 mCertificate;`
`26`	`26`	`private readonly WebSocketListenerOptions mOptions;`
	`27`	`+ private CancellationTokenSource mCancellationToken;`
`27`	`28`
`28`	`29`	`/// <summary>`
`29`	`30`	`/// Creates a new instance of <see cref="VtortolaWebSocketTransport"/>`
`@@ -71,6 +72,7 @@ protected VtortolaWebSocketTransport`
`71`	`72`
`72`	`73`	`public override void Dispose()`
`73`	`74`	`{`
	`75`	`+ mCancellationToken.Cancel();`
`74`	`76`	`mListener.Stop();`
`75`	`77`	`mListener.Dispose();`
`76`	`78`	`}`
`@@ -82,42 +84,56 @@ public override void Open()`
`82`	`84`	`WebSocketListenerOptions options = mOptions ?? new WebSocketListenerOptions();`
`83`	`85`
`84`	`86`	`options.SubProtocols = protocols;`
`85`		`-`
	`87`	`+`
`86`	`88`	`WebSocketListener listener = new WebSocketListener(mEndpoint, options);`
`87`	`89`
	`90`	`+#if NETCORE`
	`91`	`+ WebSocketFactoryRfc6455 factory = new WebSocketFactoryRfc6455();`
	`92`	`+#else`
`88`	`93`	`WebSocketFactoryRfc6455 factory = new WebSocketFactoryRfc6455(listener);`
`89`	`94`
	`95`	`+#endif`
`90`	`96`	`if (mPerMessageDeflate)`
`91`	`97`	`{`
`92`		`- factory.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());`
	`98`	`+#if NETCORE`
	`99`	`+ listener.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());`
	`100`	`+#else`
	`101`	`+ factory.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());`
	`102`	`+#endif`
`93`	`103`	`}`
`94`	`104`
`95`	`105`	`listener.Standards.RegisterStandard(factory);`
`96`		`-`
	`106`	`+`
`97`	`107`	`if (mCertificate != null)`
`98`	`108`	`{`
`99`	`109`	`listener.ConnectionExtensions.RegisterExtension(new WebSocketSecureConnectionExtension(mCertificate));`
`100`	`110`	`}`
`101`	`111`
	`112`	`+ mCancellationToken = new CancellationTokenSource();`
	`113`	`+`
	`114`	`+#if NETCORE`
	`115`	`+ listener.StartAsync(mCancellationToken.Token);`
	`116`	`+#else`
`102`	`117`	`listener.Start();`
	`118`	`+#endif`
`103`	`119`
`104`	`120`	`mListener = listener;`
`105`	`121`
`106`		`- Task.Run(new Func<Task>(ListenAsync));`
	`122`	`+ Task.Run(new Func<Task>(() => ListenAsync(mCancellationToken.Token)));`
`107`	`123`	`}`
`108`	`124`
`109`		`- private async Task ListenAsync()`
	`125`	`+ private async Task ListenAsync(CancellationToken cancellationToken)`
`110`	`126`	`{`
`111`		`- while (mListener.IsStarted)`
	`127`	`+ while (!cancellationToken.IsCancellationRequested)`
`112`	`128`	`{`
`113`	`129`	`try`
`114`	`130`	`{`
`115`		`- WebSocket websocket = await mListener.AcceptWebSocketAsync(CancellationToken.None)`
	`131`	`+ WebSocket websocket = await mListener.AcceptWebSocketAsync(cancellationToken)`
`116`	`132`	`.ConfigureAwait(false);`
`117`	`133`
`118`	`134`	`if (websocket != null)`
`119`	`135`	`{`
`120`		`- OnNewConnection(websocket);`
	`136`	`+ OnNewConnection(new WebSocketData(websocket, cancellationToken));`
`121`	`137`	`}`
`122`	`138`	`}`
`123`	`139`	`catch (Exception ex)`
`@@ -127,27 +143,33 @@ private async Task ListenAsync()`
`127`	`143`	`}`
`128`	`144`	`}`
`129`	`145`
`130`		`- protected override string GetSubProtocol(WebSocket connection)`
	`146`	`+ protected override string GetSubProtocol(WebSocketData connection)`
`131`	`147`	`{`
`132`		`- return connection.HttpResponse.WebSocketProtocol;`
	`148`	`+ return connection.WebSocket.HttpResponse.WebSocketProtocol;`
`133`	`149`	`}`
`134`	`150`
`135`		`- protected override void OpenConnection<TMessage>(WebSocket original, IWampConnection<TMessage> connection)`
	`151`	`+ protected override void OpenConnection<TMessage>(WebSocketData original, IWampConnection<TMessage> connection)`
`136`	`152`	`{`
`137`	`153`	`VtortolaWampConnection<TMessage> casted = connection as VtortolaWampConnection<TMessage>;`
`138`	`154`	`Task.Run(new Func<Task>(casted.HandleWebSocketAsync));`
`139`	`155`	`}`
`140`	`156`
`141`	`157`	`protected override IWampConnection<TMessage> CreateBinaryConnection<TMessage>`
`142`		`- (WebSocket connection, IWampBinaryBinding<TMessage> binding)`
	`158`	`+ (WebSocketData connection, IWampBinaryBinding<TMessage> binding)`
`143`	`159`	`{`
`144`		`- return new VtortolaWampBinaryConnection<TMessage>(connection, binding, AuthenticatorFactory);`
	`160`	`+ return new VtortolaWampBinaryConnection<TMessage>(connection.WebSocket,`
	`161`	`+ connection.CancellationToken,`
	`162`	`+ binding,`
	`163`	`+ AuthenticatorFactory);`
`145`	`164`	`}`
`146`	`165`
`147`	`166`	`protected override IWampConnection<TMessage> CreateTextConnection<TMessage>`
`148`		`- (WebSocket connection, IWampTextBinding<TMessage> binding)`
	`167`	`+ (WebSocketData connection, IWampTextBinding<TMessage> binding)`
`149`	`168`	`{`
`150`		`- return new VtortolaWampTextConnection<TMessage>(connection, binding, AuthenticatorFactory);`
	`169`	`+ return new VtortolaWampTextConnection<TMessage>(connection.WebSocket,`
	`170`	`+ connection.CancellationToken,`
	`171`	`+ binding,`
	`172`	`+ AuthenticatorFactory);`
`151`	`173`	`}`
`152`	`174`	`}`
`153`	`175`	`}`