sdk/samples/WCFSamples/TechnologySamples/Extensibility/Channels/HttpCookieSession/CS/extensions/HttpCookieReplySessionChannel.cs

   1
   2 //  Copyright (c) Microsoft Corporation.  All Rights Reserved.
   3
   4 namespace Microsoft.ServiceModel.Samples
   5 {
   6     using System;
   7     using System.ServiceModel;
   8     using System.ServiceModel.Channels;
   9     using System.Collections.Generic;
  10     using System.Threading;
  11
  12     class HttpCookieReplySessionChannel
  13         : ChannelBase, IReplySessionChannel
  14     {
  15         EndpointAddress localAddress;
  16         HttpCookieReplySessionChannelListener parent;
  17         InputQueue<RequestContext> requestQueue;
  18         HttpCookieReplySession session;
  19         TimeSpan sessionTimeout;
  20
  21         public HttpCookieReplySessionChannel(HttpCookieReplySessionChannelListener parent, EndpointAddress localAddress)
  22             : base(parent)
  23         {
  24             this.parent = parent;
  25             this.localAddress = localAddress;
  26             this.sessionTimeout = parent.SessionTimeout;
  27             this.session = new HttpCookieReplySession();
  28             this.requestQueue = new InputQueue<RequestContext>();
  29         }
  30
  31         public EndpointAddress LocalAddress
  32         {
  33             get { return localAddress; }
  34         }
  35
  36         public IInputSession Session
  37         {
  38             get { return this.session; }
  39         }
  40
  41         protected override void OnAbort()
  42         {
  43             this.requestQueue.Close();
  44         }
  45
  46         protected override void OnClose(TimeSpan timeout)
  47         {
  48             this.requestQueue.Close();
  49         }
  50
  51         protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
  52         {
  53             this.requestQueue.Close();
  54             return new CompletedAsyncResult(callback, state);
  55         }
  56
  57         protected override void OnEndClose(IAsyncResult result)
  58         {
  59             CompletedAsyncResult.End(result);
  60         }
  61
  62         protected override void OnOpen(TimeSpan timeout)
  63         {
  64         }
  65
  66         protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
  67         {
  68             return new CompletedAsyncResult(callback, state);
  69         }
  70
  71         protected override void OnEndOpen(IAsyncResult result)
  72         {
  73             CompletedAsyncResult.End(result);
  74         }
  75
  76         public IAsyncResult BeginReceiveRequest(AsyncCallback callback, object state)
  77         {
  78             return BeginReceiveRequest(this.DefaultReceiveTimeout, callback, state);
  79         }
  80
  81         public IAsyncResult BeginReceiveRequest(TimeSpan timeout, AsyncCallback callback, object state)
  82         {
  83             ValidateTimeSpan(timeout);
  84             return new ReceiveRequestAsyncResult(this, timeout, callback, state);
  85         }
  86
  87         public RequestContext EndReceiveRequest(IAsyncResult result)
  88         {
  89             return ReceiveRequestAsyncResult.End(result);
  90         }
  91
  92         public IAsyncResult BeginTryReceiveRequest(
  93             TimeSpan timeout, AsyncCallback callback,
  94             object state)
  95         {
  96             ValidateTimeSpan(timeout);
  97             return this.requestQueue.BeginDequeue(timeout, callback, state);
  98         }
  99
 100         public bool EndTryReceiveRequest(IAsyncResult result,
 101             out RequestContext context)
 102         {
 103             return this.requestQueue.EndDequeue(result, out context);
 104         }
 105
 106         public RequestContext ReceiveRequest()
 107         {
 108             return ReceiveRequest(DefaultReceiveTimeout);
 109         }
 110
 111         public RequestContext ReceiveRequest(TimeSpan timeout)
 112         {
 113             ValidateTimeSpan(timeout);
 114             return this.requestQueue.Dequeue(timeout);
 115         }
 116
 117         public bool TryReceiveRequest(TimeSpan timeout,
 118             out RequestContext context)
 119         {
 120             ValidateTimeSpan(timeout);
 121             return this.requestQueue.Dequeue(timeout, out context);
 122         }
 123
 124         public IAsyncResult BeginWaitForRequest(
 125             TimeSpan timeout, AsyncCallback callback,
 126             object state)
 127         {
 128             return this.requestQueue.BeginWaitForItem(timeout, callback, state);
 129         }
 130
 131         public bool EndWaitForRequest(IAsyncResult result)
 132         {
 133             return this.requestQueue.EndWaitForItem(result);
 134         }
 135
 136         public bool WaitForRequest(TimeSpan timeout)
 137         {
 138             return this.requestQueue.WaitForItem(timeout);
 139         }
 140
 141         public void Enqueue(RequestContext item, ItemDequeuedCallback dequeuedCallback)
 142         {
 143             this.requestQueue.EnqueueAndDispatch(item, dequeuedCallback);
 144         }
 145
 146         static void ValidateTimeSpan(TimeSpan timeout)
 147         {
 148             if (timeout < TimeSpan.Zero)
 149             {
 150                 throw new ArgumentOutOfRangeException("timeout", timeout,
 151                     "Timeout must be greater than or equal to TimeSpan.Zero. To disable timeout, specify TimeSpan.MaxValue.");
 152             }
 153         }
 154
 155         class ReceiveRequestAsyncResult : AsyncResult
 156         {
 157             IReplyChannel channel;
 158             TimeSpan timeout;
 159             static AsyncCallback onReceiveRequest = new AsyncCallback(OnReceiveRequest);
 160             RequestContext requestContext;
 161
 162             public ReceiveRequestAsyncResult(IReplyChannel channel, TimeSpan timeout, AsyncCallback callback, object state)
 163                 : base(callback, state)
 164             {
 165                 this.channel = channel;
 166                 this.timeout = timeout;
 167                 IAsyncResult result = channel.BeginTryReceiveRequest(timeout, onReceiveRequest, this);
 168
 169                 if (!result.CompletedSynchronously)
 170                 {
 171                     return;
 172                 }
 173
 174                 OnReceiveRequestCore(result);
 175                 base.Complete(true);
 176             }
 177
 178             public static RequestContext End(IAsyncResult result)
 179             {
 180                 ReceiveRequestAsyncResult thisPtr = AsyncResult.End<ReceiveRequestAsyncResult>(result);
 181                 return thisPtr.requestContext;
 182             }
 183
 184             void OnReceiveRequestCore(IAsyncResult result)
 185             {
 186                 if (!this.channel.EndTryReceiveRequest(result, out this.requestContext))
 187                 {
 188                     throw new TimeoutException(string.Format("Receive request timed out after {0}.", timeout));
 189                 }
 190             }
 191
 192             static void OnReceiveRequest(IAsyncResult result)
 193             {
 194                 if (result.CompletedSynchronously)
 195                 {
 196                     return;
 197                 }
 198
 199                 ReceiveRequestAsyncResult thisPtr = (ReceiveRequestAsyncResult)result.AsyncState;
 200                 Exception completionException = null;
 201                 try
 202                 {
 203                     thisPtr.OnReceiveRequestCore(result);
 204                 }
 205                 catch (Exception e)
 206                 {
 207                     completionException = e;
 208                 }
 209
 210                 thisPtr.Complete(false, completionException);
 211             }
 212         }
 213     }
 214 }