public HttpListenerContext EndGetContext(IAsyncResult asyncResult)
{
this.CheckDisposed();
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
ListenerAsyncResult listenerAsyncResult = asyncResult as ListenerAsyncResult;
if (listenerAsyncResult == null)
{
throw new ArgumentException("Wrong IAsyncResult.", "asyncResult");
}
if (listenerAsyncResult.EndCalled)
{
throw new InvalidOperationException("Cannot reuse this IAsyncResult.");
}
listenerAsyncResult.EndCalled = true;
if (!listenerAsyncResult.IsCompleted)
{
listenerAsyncResult.AsyncWaitHandle.WaitOne();
}
object syncRoot = ((ICollection)this._waitQueue).SyncRoot;
lock (syncRoot)
{
int num = this._waitQueue.IndexOf(listenerAsyncResult);
if (num >= 0)
{
this._waitQueue.RemoveAt(num);
}
}
HttpListenerContext context = listenerAsyncResult.GetContext();
AuthenticationSchemes authenticationSchemes = this.SelectAuthenticationScheme(context);
if (authenticationSchemes != AuthenticationSchemes.Anonymous)
{
context.SetUser(authenticationSchemes, this.Realm, this.UserCredentialsFinder);
}
return(context);
}
/// <summary>
/// Ends an asynchronous operation to get an incoming request information.
/// </summary>
/// <remarks>
/// This method completes an asynchronous operation started by calling the <see cref="BeginGetContext"/> method.
/// </remarks>
/// <returns>
/// A <see cref="HttpListenerContext"/> that contains a client's request information.
/// </returns>
/// <param name="asyncResult">
/// An <see cref="IAsyncResult"/> obtained by calling the <see cref="BeginGetContext"/> method.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="asyncResult"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="asyncResult"/> was not obtained by calling the <see cref="BeginGetContext"/> method.
/// </exception>
/// <exception cref="InvalidOperationException">
/// The EndGetContext method was already called for the specified <paramref name="asyncResult"/>.
/// </exception>
public HttpListenerContext EndGetContext(IAsyncResult asyncResult)
{
CheckDisposed();
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
ListenerAsyncResult ares = asyncResult as ListenerAsyncResult;
if (ares == null)
{
throw new ArgumentException("Wrong IAsyncResult.", "asyncResult");
}
if (ares.EndCalled)
{
throw new InvalidOperationException("Cannot reuse this IAsyncResult.");
}
ares.EndCalled = true;
if (!ares.IsCompleted)
{
ares.AsyncWaitHandle.WaitOne();
}
lock (((ICollection)wait_queue).SyncRoot) {
int idx = wait_queue.IndexOf(ares);
if (idx >= 0)
{
wait_queue.RemoveAt(idx);
}
}
HttpListenerContext context = ares.GetContext();
context.ParseAuthentication(SelectAuthenticationScheme(context));
return(context); // This will throw on error.
}
internal void RegisterContext(HttpListenerContext context)
{
lock (((ICollection)registry).SyncRoot)
registry [context] = context;
ListenerAsyncResult ares = null;
lock (((ICollection)wait_queue).SyncRoot) {
if (wait_queue.Count == 0)
{
lock (((ICollection)ctx_queue).SyncRoot)
ctx_queue.Add(context);
}
else
{
ares = wait_queue [0];
wait_queue.RemoveAt(0);
}
}
if (ares != null)
{
ares.Complete(context);
}
}
/// <summary>
/// Begins getting an incoming request information asynchronously.
/// </summary>
/// <remarks>
/// This asynchronous operation must be completed by calling the <see cref="EndGetContext"/> method.
/// Typically, the method is invoked by the <paramref name="callback"/> delegate.
/// </remarks>
/// <returns>
/// An <see cref="IAsyncResult"/> that contains the status of the asynchronous operation.
/// </returns>
/// <param name="callback">
/// An <see cref="AsyncCallback"/> delegate that references the method(s)
/// called when the asynchronous operation completes.
/// </param>
/// <param name="state">
/// An <see cref="object"/> that contains a user defined object to pass to the <paramref name="callback"/> delegate.
/// </param>
/// <exception cref="ObjectDisposedException">
/// This object has been closed.
/// </exception>
/// <exception cref="InvalidOperationException">
/// The <see cref="HttpListener"/> has not been started or is stopped currently.
/// </exception>
public IAsyncResult BeginGetContext(AsyncCallback callback, Object state)
{
CheckDisposed ();
if (!listening)
throw new InvalidOperationException ("Please, call Start before using this method.");
ListenerAsyncResult ares = new ListenerAsyncResult (callback, state);
// lock wait_queue early to avoid race conditions
lock (((ICollection)wait_queue).SyncRoot) {
lock (((ICollection)ctx_queue).SyncRoot) {
HttpListenerContext ctx = GetContextFromQueue ();
if (ctx != null) {
ares.Complete (ctx, true);
return ares;
}
}
wait_queue.Add (ares);
}
return ares;
}
internal ListenerAsyncResult BeginGetContext(ListenerAsyncResult asyncResult)
{
CheckDisposed ();
if (_prefixes.Count == 0)
throw new InvalidOperationException ("The listener has no URI prefix on which listens.");
if (!_listening)
throw new InvalidOperationException ("The listener hasn't been started.");
// Lock _waitQueue early to avoid race conditions.
lock (_waitQueueSync) {
lock (_ctxQueueSync) {
var ctx = getContextFromQueue ();
if (ctx != null) {
asyncResult.Complete (ctx, true);
return asyncResult;
}
}
_waitQueue.Add (asyncResult);
}
return asyncResult;
}
internal ListenerAsyncResult BeginGetContext (ListenerAsyncResult asyncResult)
{
CheckDisposed ();
if (_prefixes.Count == 0)
throw new InvalidOperationException (
"Please, call AddPrefix before using this method.");
if (!_listening)
throw new InvalidOperationException (
"Please, call Start before using this method.");
// Lock _waitQueue early to avoid race conditions
lock (((ICollection) _waitQueue).SyncRoot) {
lock (((ICollection) _contextQueue).SyncRoot) {
var context = getContextFromQueue ();
if (context != null) {
asyncResult.Complete (context, true);
return asyncResult;
}
}
_waitQueue.Add (asyncResult);
}
return asyncResult;
}
