C# HttpWebRequest.GetHashCode方法代码示例

        /// <summary>
        /// Handler that the user will call when they want the request to resume processing.
        /// It will check to ensure that the correct WebRequest is passed back to this resumption point.
        /// Else an error will be thrown.
        /// </summary>
        /// <param name="request">HttpWebRequest for which the processing has to resume.</param>
        void ResumeRequestProcessing(HttpWebRequest request)
        {
            AsyncArgsWrapper wrapper = null;

            this._requestToArgsMapper.TryGetValue(request.GetHashCode(), out wrapper);
            if (wrapper == null)
            {
                // It means they called Resume with another WebRequest. Fail sync.
                throw new CacheControllerException("Incorrect HttpWebRequest object passed to ResumeRequestProcessing callback.");
            }

            try
            {
                this._requestToArgsMapper.Remove(request.GetHashCode());

                this.GetWebResponse(wrapper);
            }
            catch (Exception e)
            {
                if (ExceptionUtility.IsFatal(e))
                {
                    throw;
                }

                wrapper.Error = e;
                this._workerManager.CompleteWorkRequest(wrapper.WorkerRequest, wrapper);
            }
        }

        /// <devdoc>
        ///    <para>
        ///       Used by the ServicePoint to find a free or new Connection
        ///       for use in making Requests, this is done with the cavet,
        ///       that once a Connection is "locked" it can only be used
        ///       by a specific request.
        ///
        ///     NOTE: For Whidbey: try to integrate this code into FindConnection()
        ///    </para>
        /// </devdoc>
        private Connection FindConnectionAuthenticationGroup(HttpWebRequest request, string connName) {
            Connection leastBusyConnection = null;

            GlobalLog.Print("ConnectionGroup::FindConnectionAuthenticationGroup [" + connName + "] for request#" + request.GetHashCode() +", m_ConnectionList.Count:" + m_ConnectionList.Count.ToString());

            //
            // First try and find a free Connection (i.e. one not busy with Authentication handshake)
            //   or try to find a Request that has already locked a specific Connection,
            //   if a matching Connection is found, then we're done
            //
            lock (m_ConnectionList) {
                Connection matchingConnection;
                matchingConnection = FindMatchingConnection(request, connName, out leastBusyConnection);
                if (matchingConnection != null) {
                    matchingConnection.MarkAsReserved();
                    return matchingConnection;
                }
                if (AuthenticationRequestQueue.Count == 0) {
                    if (leastBusyConnection != null) {
                        if (request.LockConnection) {
                            m_NtlmNegGroup = true;
                            m_IISVersion = leastBusyConnection.IISVersion;
                        }
                        if(request.LockConnection || (m_NtlmNegGroup && !request.Pipelined && request.UnsafeOrProxyAuthenticatedConnectionSharing && m_IISVersion >= 6)){
                            GlobalLog.Print("Assigning New Locked Request#" + request.GetHashCode().ToString());
                            leastBusyConnection.LockedRequest = request;
                        }
                        leastBusyConnection.MarkAsReserved();
                        return leastBusyConnection;
                    }
                }
                else if (leastBusyConnection != null) {
                    AsyncWaitHandle.Set();
                }
                AuthenticationRequestQueue.Enqueue(request);
            }

            //
            // If all the Connections are busy, then we queue ourselves and need to wait.   As soon as
            //   one of the Connections are free, we grab the lock, and see if we find ourselves
            //   at the head of the queue.  If not, we loop backaround.
            //   Care is taken to examine the request when we wakeup, in case the request is aborted.
            //
            while (true) {
                GlobalLog.Print("waiting");
                request.AbortDelegate = m_AbortDelegate;

                if (!request.Aborted)
                    AsyncWaitHandle.WaitOne();

                GlobalLog.Print("wait up");
                lock(m_ConnectionList) {
                    if (request.Aborted)
                    {
                        PruneAbortedRequests();
                        // Note that request is not on any connection and it will not be submitted
                        return null;
                    }

                    FindMatchingConnection(request, connName, out leastBusyConnection);
                    if (AuthenticationRequestQueue.Peek() == request) {
                        GlobalLog.Print("dequeue");
                        AuthenticationRequestQueue.Dequeue();
                        if (leastBusyConnection != null) {
                            if (request.LockConnection) {
                                m_NtlmNegGroup = true;
                                m_IISVersion = leastBusyConnection.IISVersion;
                            }
                            if(request.LockConnection || (m_NtlmNegGroup  && !request.Pipelined && request.UnsafeOrProxyAuthenticatedConnectionSharing && m_IISVersion >= 6)){
                                leastBusyConnection.LockedRequest = request;
                            }

                            leastBusyConnection.MarkAsReserved();
                            return leastBusyConnection;
                        }
                        AuthenticationRequestQueue.Enqueue(request);
                    }
                    if (leastBusyConnection == null) {
                        AsyncWaitHandle.Reset();
                    }
                }
            }
        }

        /*++

            ConstructTransport - Creates a transport for a given stream,
            and constructors a transport capable of handling it.

            Input:
                    socket - socket
                    result -
                    request -

            Returns:
                   WebExceptionStatus
        --*/
        private WebExceptionStatus ConstructTransport(Socket socket, ref NetworkStream result, HttpWebRequest request) {
            GlobalLog.Enter("Connection#" + ValidationHelper.HashString(this) + "::ConstructTransport", "Socket#"+ValidationHelper.HashString(socket)+", ref NetworkStream, request#"+request.GetHashCode());
            //
            // for now we will look at the scheme and infer SSL if the scheme is "https"
            // in the future this will be replaced by full-extensible
            // scheme for cascadable streams in the future
            //
            Uri destination = request.Address;

            if (destination.Scheme == Uri.UriSchemeHttps) {
                return WebExceptionStatus.SecureChannelFailure;
            }

            if (destination.Scheme != Uri.UriSchemeHttps) {
                //
                // for HTTP we're done
                //
                try {
                    result = new NetworkStream(socket, true);
                }
                catch {
                    GlobalLog.Leave("Connection#" + ValidationHelper.HashString(this) + "::ConstructTransport");
                    return WebExceptionStatus.ConnectFailure;
                }
                GlobalLog.Leave("Connection#" + ValidationHelper.HashString(this) + "::ConstructTransport");
                return WebExceptionStatus.Success;
            }

            //
            // we have to do our tunneling first for proxy case
            //
            if (m_Server.InternalProxyServicePoint) {

                bool success = TunnelThroughProxy(m_Server.Address, request, out socket);

                if (!success) {
                    GlobalLog.Leave("Connection#" + ValidationHelper.HashString(this) + "::ConstructTransport");
                    return WebExceptionStatus.ConnectFailure;
                }
            }

            return WebExceptionStatus.ConnectFailure;
        }