{"id":2154,"date":"2012-09-26T15:34:22","date_gmt":"2012-09-26T15:34:22","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/webdev\/2012\/09\/26\/wcf-duplex-bi-directional-streaming-with-websocket-transport\/"},"modified":"2022-08-10T06:11:09","modified_gmt":"2022-08-10T13:11:09","slug":"wcf-duplex-bi-directional-streaming-with-websocket-transport","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/wcf-duplex-bi-directional-streaming-with-websocket-transport\/","title":{"rendered":"WCF Duplex Bi-directional Streaming with WebSocket Transport"},"content":{"rendered":"
\n

DuplexBiDirectionalStreaming VS2012 project DuplexBiDirectionalStreaming.zip<\/a><\/p>\n<\/div>\n

Introduction<\/h3>\n

With WebSocket transport, it\u2019s possible to use streamed transport on the Duplex Callback \u2013 something that was previously a technical limitation with WCF but is now possible using this transport. New to .Net4.5 is the NetHttpBinding (and NetHttpsBinding), which is a new standard binding that leverages the WebSocket transport if it makes sense to do so. You can configure it to always use WebSocket transport, but by default, it will only use it for Duplex channel shapes. Why? Well, what this transport gives you is the ability for the server to push data to the client without an incoming request. If your contract is already request-reply, there isn\u2019t much increase in efficiency by using the WebSocket transport. But with duplex, there isn\u2019t necessarily a 1-1 correspondence with requests and replies. Of course, the binding does give you the ability to change this setting.<\/p>\n

Requirements<\/h3>\n

WebSocket transport is only possible on the Windows8 operating system. I\u2019m using Windows8 for this demo with Visual Studio 2012. IIS needs to be installed, with full support for Http Activation and WebSocket Transport. To run the service in IIS from Visual Studio, you need to run Visual Studio as an administrator.<\/p>\n

Walk-Through<\/h3>\n

First, I created a new Console Project in Visual studio. This will be the client. I\u2019ll leave it alone for now, and add a WCF service:<\/p>\n

\"clip_image002\"<\/a><\/p>\n

Next, I\u2019ll define the service contract. I want to be able to upload bytes for as long as I want. Also, I want to be able to download bytes at the same time, and have a way to tell the service to stop sending me bytes. I\u2019ll also put something in there to grab logs from the service implementation. I created this in a new class library so it can be shared between the client and service.<\/p>\n

\n
\n
Code Snippet<\/div>\n
\n
    \n
  1. [<\/span>ServiceContract<\/span>(CallbackContract = <\/span>typeof<\/span>(<\/span>IClientCallback<\/span>))]<\/span><\/li>\n
  2. <\/span>public<\/span> <\/span>interface<\/span> <\/span>IStreamService<\/span><\/li>\n
  3. {<\/span><\/li>\n
  4. \u00a0\u00a0\u00a0\u00a0[<\/span>OperationContract<\/span>(IsOneWay = <\/span>true<\/span>)]<\/span><\/li>\n
  5. \u00a0\u00a0\u00a0\u00a0<\/span>void<\/span> UploadStream(<\/span>Stream<\/span> stream);<\/span><\/li>\n
  6.  <\/li>\n
  7. \u00a0\u00a0\u00a0\u00a0[<\/span>OperationContract<\/span>(IsOneWay = <\/span>true<\/span>)]<\/span><\/li>\n
  8. \u00a0\u00a0\u00a0\u00a0<\/span>void<\/span> StartDownloadingStream();<\/span><\/li>\n
  9.  <\/li>\n
  10. \u00a0\u00a0\u00a0\u00a0[<\/span>OperationContract<\/span>(IsOneWay = <\/span>true<\/span>)]<\/span><\/li>\n
  11. \u00a0\u00a0\u00a0\u00a0<\/span>void<\/span> StopDownloadingStream();<\/span><\/li>\n
  12.  <\/li>\n
  13. \u00a0\u00a0\u00a0\u00a0[<\/span>OperationContract<\/span>(IsOneWay = <\/span>true<\/span>)]<\/span><\/li>\n
  14. \u00a0\u00a0\u00a0\u00a0<\/span>void<\/span> DownloadLog();<\/span><\/li>\n
  15. }<\/span><\/li>\n<\/ol><\/div>\n<\/p><\/div>\n<\/p><\/div>\n

    Remember, this is duplex, so all the service operations return void. Anything that needs to go to the client goes through the callback channel, defined by this:<\/p>\n

    \n
    \n
    Code Snippet<\/div>\n
    \n
      \n
    1. <\/span>public<\/span> <\/span>interface<\/span> <\/span>IClientCallback<\/span><\/li>\n
    2. {<\/span><\/li>\n
    3. \u00a0\u00a0\u00a0\u00a0[<\/span>OperationContract<\/span>(IsOneWay = <\/span>true<\/span>)]<\/span><\/li>\n
    4. \u00a0\u00a0\u00a0\u00a0<\/span>void<\/span> ReceiveStream(<\/span>Stream<\/span> stream);<\/span><\/li>\n
    5.  <\/li>\n
    6. \u00a0\u00a0\u00a0\u00a0[<\/span>OperationContract<\/span>(IsOneWay = <\/span>true<\/span>)]<\/span><\/li>\n
    7. \u00a0\u00a0\u00a0\u00a0<\/span>void<\/span> ReceiveLog(<\/span>List<\/span><<\/span>string<\/span>> log);<\/span><\/li>\n
    8. }<\/span><\/li>\n<\/ol><\/div>\n<\/p><\/div>\n<\/p><\/div>\n

      Now, to implement the service. To do this, I\u2019ll need some kind of custom stream implementation. For demonstration purposes, I\u2019ll use a stream implementation that sends random bytes and can be turned on or off manually or configured to send for a given duration. In order to not blow MaxReceivedMessageSize buffers, I\u2019ll make a configurable throttle on it. The code for this FlowControlledStream can be found in the attached project.<\/p>\n

      See the attached project for the full service implementation, but the new thing here is sending a stream on a callback; previously not possible with WCF. Also in there is the implementation of StopDownloadingStream.<\/p>\n

      \n
      \n
      Code Snippet<\/div>\n
      \n
        \n
      1. <\/span>public<\/span> <\/span>void<\/span> StartDownloadingStream()<\/span><\/li>\n
      2. {<\/span><\/li>\n
      3. \u00a0\u00a0\u00a0\u00a0log.Add(<\/span>string<\/span>.Format(<\/span>"[{0}] StartDownloadingStream Invoked."<\/span>, <\/span>DateTime<\/span>.Now.Minute + <\/span>":"<\/span> + <\/span>DateTime<\/span>.Now.Second + <\/span>"."<\/span> + <\/span>DateTime<\/span>.Now.Millisecond));<\/span><\/li>\n
      4. \u00a0\u00a0\u00a0\u00a0<\/span>IClientCallback<\/span> clientCallbackChannel = <\/span>OperationContext<\/span>.Current.GetCallbackChannel<<\/span>IClientCallback<\/span>>();<\/span><\/li>\n
      5. \u00a0\u00a0\u00a0\u00a0<\/span>ThreadPool<\/span>.QueueUserWorkItem(<\/span>new<\/span> <\/span>WaitCallback<\/span>(PushStream), clientCallbackChannel);<\/span><\/li>\n
      6. }<\/span><\/li>\n
      7.  <\/li>\n
      8. <\/span>private<\/span> <\/span>void<\/span> PushStream(<\/span>object<\/span> state)<\/span><\/li>\n
      9. {<\/span><\/li>\n
      10. \u00a0\u00a0\u00a0\u00a0<\/span>IClientCallback<\/span> pushCallbackChannel = state <\/span>as<\/span> <\/span>IClientCallback<\/span>;<\/span><\/li>\n
      11. \u00a0\u00a0\u00a0\u00a0localStream = <\/span>new<\/span> <\/span>FlowControlledStream<\/span>();<\/span><\/li>\n
      12. \u00a0\u00a0\u00a0\u00a0localStream.ReadThrottle = <\/span>TimeSpan<\/span>.FromMilliseconds(500);<\/span><\/li>\n
      13.  <\/li>\n
      14. \u00a0\u00a0\u00a0\u00a0pushCallbackChannel.ReceiveStream(localStream);<\/span><\/li>\n
      15. }<\/span><\/li>\n
      16.  <\/li>\n
      17. <\/span>public<\/span> <\/span>void<\/span> StopDownloadingStream()<\/span><\/li>\n
      18. {<\/span><\/li>\n
      19. \u00a0\u00a0\u00a0\u00a0log.Add(<\/span>string<\/span>.Format(<\/span>"[{0}] StopDownloadingStream Invoked."<\/span>, <\/span>DateTime<\/span>.Now.Minute + <\/span>":"<\/span> + <\/span>DateTime<\/span>.Now.Second + <\/span>"."<\/span> + <\/span>DateTime<\/span>.Now.Millisecond));<\/span><\/li>\n
      20. \u00a0\u00a0\u00a0\u00a0localStream.StopStreaming = <\/span>true<\/span>;<\/span><\/li>\n
      21. }<\/span><\/li>\n<\/ol><\/div>\n<\/p><\/div>\n<\/p><\/div>\n

        With that finished, I need to modify the Web.config that was generated for me. I want to use WebSocket Transport, so I\u2019ll use the standard NetHttpBinding. By default, netHttpBinding will use WebSocket transport if the contract is duplex, so I shouldn\u2019t have to explicitly add that. But I will increase the MaxReceivedMessageSize to a ridiculous value. So, I replaced the generated System.ServiceModel section with the following:<\/p>\n

        \n
        \n
        Code Snippet<\/div>\n
        \n
          \n
        1. <<\/span>system.serviceModel<\/span>><\/span><\/li>\n
        2. \u00a0\u00a0<<\/span>behaviors<\/span>><\/span><\/li>\n
        3. \u00a0\u00a0\u00a0\u00a0<<\/span>serviceBehaviors<\/span>><\/span><\/li>\n
        4. \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<<\/span>behavior<\/span> <\/span>name<\/span>=<\/span>"<\/span>MyServiceBehavior<\/span>"<\/span>><\/span><\/li>\n
        5. \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<<\/span>serviceMetadata<\/span> <\/span>httpGetEnabled<\/span>=<\/span>"<\/span>true<\/span>"<\/span> <\/span>httpsGetEnabled<\/span>=<\/span>"<\/span>true<\/span>"<\/span>\/><\/span><\/li>\n
        6. \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<<\/span>serviceDebug<\/span> <\/span>includeExceptionDetailInFaults<\/span>=<\/span>"<\/span>true<\/span>"<\/span>\/><\/span><\/li>\n
        7. \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/<\/span>behavior<\/span>><\/span><\/li>\n
        8. \u00a0\u00a0\u00a0\u00a0<\/<\/span>serviceBehaviors<\/span>><\/span><\/li>\n
        9. \u00a0\u00a0<\/<\/span>behaviors<\/span>><\/span><\/li>\n
        10. \u00a0\u00a0<<\/span>serviceHostingEnvironment<\/span> <\/span>aspNetCompatibilityEnabled<\/span>=<\/span>"<\/span>true<\/span>"<\/span> <\/span>multipleSiteBindingsEnabled<\/span>=<\/span>"<\/span>true<\/span>"<\/span> \/><\/span><\/li>\n
        11. \u00a0\u00a0<<\/span>bindings<\/span>><\/span><\/li>\n
        12. \u00a0\u00a0\u00a0\u00a0<<\/span>netHttpBinding<\/span>><\/span><\/li>\n
        13. \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<<\/span>binding<\/span> <\/span>name<\/span>=<\/span>"<\/span>MyBinding<\/span>"<\/span> <\/span>maxReceivedMessageSize<\/span>=<\/span>"<\/span>67108864<\/span>"<\/span> <\/span>transferMode<\/span>=<\/span>"<\/span>Streamed<\/span>"<\/span>><\/span><\/li>\n
        14. \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/<\/span>binding<\/span>><\/span><\/li>\n
        15. \u00a0\u00a0\u00a0\u00a0<\/<\/span>netHttpBinding<\/span>><\/span><\/li>\n
        16. \u00a0\u00a0<\/<\/span>bindings<\/span>><\/span><\/li>\n
        17. \u00a0\u00a0<<\/span>services<\/span>><\/span><\/li>\n
        18. \u00a0\u00a0\u00a0\u00a0<<\/span>service<\/span> <\/span>behaviorConfiguration<\/span>=<\/span>"<\/span>MyServiceBehavior<\/span>"<\/span> <\/span>name<\/span>=<\/span>"<\/span>DuplexService.StreamingService<\/span>"<\/span>><\/span><\/li>\n
        19. \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<<\/span>endpoint<\/span> <\/span>address<\/span>=<\/span>""<\/span> <\/span>contract<\/span>=<\/span>"<\/span>CommonArtifacts.IStreamService<\/span>"<\/span> <\/span>binding<\/span>=<\/span>"<\/span>netHttpBinding<\/span>"<\/span> <\/span>bindingConfiguration<\/span>=<\/span>"<\/span>MyBinding<\/span>"<\/span> \/><\/span><\/li>\n
        20. \u00a0\u00a0\u00a0\u00a0<\/<\/span>service<\/span>><\/span><\/li>\n
        21. \u00a0\u00a0<\/<\/span>services<\/span>><\/span><\/li>\n
        22. <\/<\/span>system.serviceModel<\/span>><\/span><\/li>\n<\/ol><\/div>\n<\/p><\/div>\n<\/p><\/div>\n

          So, after that, I open the service\u2019s Properties page, go to the Web section, and make sure \u201cUse Local IIS Web server\u201d is selected, and I uncheck \u201cUse IIS Express\u201d. When I save that, and allow VS to create the virtual directory, I can browse to the .svc file and get the standard WCF Service help page. Time to work on the Client code.<\/p>\n

          The goal for the client is to prove that we are doing true bi-directional streaming. To do this my client will execute the following:<\/p>\n

          1. Invoke a service operation to start downloading a stream.<\/p>\n

          2. Signal that bytes are being received.<\/p>\n

          3. Upload a stream for a few seconds.<\/p>\n

          4. Signal to the service to stop sending bytes to the receiver.<\/p>\n

          5. Wait for the end of the stream.<\/p>\n

          If the service can\u2019t process the incoming stream while sending bytes out, then it will deadlock. The program is in the attached zip file, but here\u2019s a snipped version:<\/p>\n

          \n
          \n
          Code Snippet<\/div>\n
          \n
            \n
          1. <\/span>ClientReceiver<\/span> receiver = <\/span>new<\/span> <\/span>ClientReceiver<\/span>();<\/span><\/li>\n
          2.  <\/li>\n
          3. <\/span>string<\/span> address = <\/span>"http:\/\/localhost\/DuplexService\/DuplexService.svc"<\/span>;<\/span><\/li>\n
          4. <\/span>NetHttpBinding<\/span> binding = <\/span>new<\/span> <\/span>NetHttpBinding<\/span>();<\/span><\/li>\n
          5. binding.MaxReceivedMessageSize = 64 * 1024 * 1024;<\/span><\/li>\n
          6. binding.TransferMode = <\/span>TransferMode<\/span>.Streamed;<\/span><\/li>\n
          7. <\/span>DuplexChannelFactory<\/span><<\/span>IStreamService<\/span>> factory = <\/span>new<\/span> <\/span>DuplexChannelFactory<\/span><<\/span>IStreamService<\/span>>(<\/span>new<\/span> <\/span>InstanceContext<\/span>(receiver), binding, address);<\/span><\/li>\n
          8. <\/span>IStreamService<\/span> client = factory.CreateChannel();<\/span><\/li>\n<\/ol><\/div>\n<\/p><\/div>\n<\/p><\/div>\n
            \n
            \n
            Code Snippet<\/div>\n
            \n
              \n
            1. client.StartDownloadingStream();<\/span><\/li>\n
            2.  <\/li>\n
            3. \u00a0<\/span>Console<\/span>.WriteLine(<\/span>"[{0}] Waiting for the receiver to start reading bytes."<\/span>, <\/span>DateTime<\/span>.Now.Minute + <\/span>":"<\/span> + <\/span>DateTime<\/span>.Now.Second + <\/span>"."<\/span> + <\/span>DateTime<\/span>.Now.Millisecond);<\/span><\/li>\n
            4. \u00a0receiver.ReceiveStreamInvoked.WaitOne();<\/span><\/li>\n
            5.  <\/li>\n
            6. \u00a0<\/span>Console<\/span>.WriteLine(<\/span>"[{0}] Client Invoking UploadStream, while the receiver is receiving bytes."<\/span>, <\/span>DateTime<\/span>.Now.Minute + <\/span>":"<\/span> + <\/span>DateTime<\/span>.Now.Second + <\/span>"."<\/span> + <\/span>DateTime<\/span>.Now.Millisecond);<\/span><\/li>\n
            7. \u00a0<\/span>FlowControlledStream<\/span> uploadStream = <\/span>new<\/span> <\/span>FlowControlledStream<\/span>();<\/span><\/li>\n
            8. \u00a0uploadStream.ReadThrottle = <\/span>TimeSpan<\/span>.FromMilliseconds(500);<\/span><\/li>\n
            9. \u00a0uploadStream.StreamDuration = <\/span>TimeSpan<\/span>.FromSeconds(5);<\/span><\/li>\n
            10. \u00a0client.UploadStream(uploadStream);<\/span><\/li>\n
            11.  <\/li>\n
            12. \u00a0<\/span>Console<\/span>.WriteLine(<\/span>"[{0}] Client Invoking StopDownloadingStream."<\/span>, <\/span>DateTime<\/span>.Now.Minute + <\/span>":"<\/span> + <\/span>DateTime<\/span>.Now.Second + <\/span>"."<\/span> + <\/span>DateTime<\/span>.Now.Millisecond);<\/span><\/li>\n
            13. \u00a0client.StopDownloadingStream();<\/span><\/li>\n
            14.  <\/li>\n
            15. \u00a0<\/span>Console<\/span>.WriteLine(<\/span>"[{0}] Waiting on ReceiveStreamCompleted from the receiver."<\/span>, <\/span>DateTime<\/span>.Now.Minute + <\/span>":"<\/span> + <\/span>DateTime<\/span>.Now.Second + <\/span>"."<\/span> + <\/span>DateTime<\/span>.Now.Millisecond);<\/span><\/li>\n
            16. \u00a0receiver.ReceiveStreamCompleted.WaitOne();<\/span><\/li>\n<\/ol><\/div>\n<\/p><\/div>\n<\/p><\/div>\n

              Running it produces the following log:<\/p>\n

              \n

              [45:21.308] Client Invoking StartDownloadingStream.<\/font><\/p>\n

              [45:21.844] Waiting for the receiver to start reading bytes.<\/font><\/p>\n

              [45:22.861] ReceiveStream invoked.<\/font><\/p>\n

              [45:22.862] Client Invoking UploadStream, while the receiver is receiving bytes.<\/font><\/p>\n

              [45:27.873] Client Invoking StopDownloadingStream.<\/font><\/p>\n

              [45:27.873] Waiting on ReceiveStreamCompleted from the receiver.<\/font><\/p>\n

              [45:28.371] ReceiveStream read 725248 bytes.<\/font><\/p>\n

              [45:28.371] Getting the log from the server.<\/font><\/p>\n

              The following are the logs from the server:<\/font><\/p>\n

              [45:21.854] StartDownloadingStream Invoked.<\/font><\/p>\n

              [45:23.866] UploadStream Invoked.<\/font><\/p>\n

              [45:27.873] UploadStream Read 528640 bytes.<\/font><\/p>\n

              [45:27.874] StopDownloadingStream Invoked.<\/font><\/p>\n

              [45:28.373] DownloadLog Invoked.<\/font><\/p>\n<\/blockquote>\n

              Comparing the server log and the client log shows that server read bytes from the client for about 5 seconds while sending bytes to the client at the same time. I made sure to set the ReadThrottle to the same amount on both client and service, so the client should<\/i> read more bytes than the service, which it does.<\/p>\n","protected":false},"excerpt":{"rendered":"

              DuplexBiDirectionalStreaming VS2012 project DuplexBiDirectionalStreaming.zip Introduction With WebSocket transport, it\u2019s possible to use streamed transport on the Duplex Callback \u2013 something that was previously a technical limitation with WCF but is now possible using this transport. New to .Net4.5 is the NetHttpBinding (and NetHttpsBinding), which is a new standard binding that leverages the WebSocket transport if […]<\/p>\n","protected":false},"author":457,"featured_media":58792,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[197],"tags":[],"class_list":["post-2154","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-aspnet"],"acf":[],"blog_post_summary":"

              DuplexBiDirectionalStreaming VS2012 project DuplexBiDirectionalStreaming.zip Introduction With WebSocket transport, it\u2019s possible to use streamed transport on the Duplex Callback \u2013 something that was previously a technical limitation with WCF but is now possible using this transport. New to .Net4.5 is the NetHttpBinding (and NetHttpsBinding), which is a new standard binding that leverages the WebSocket transport if […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/2154","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/457"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=2154"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/2154\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/58792"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=2154"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=2154"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=2154"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}