webfunc.cs

定义社区节点

            {
                
            }
            finally
            {
                rs.Dispose();
                rs = null;
            }
        }


        private static void RequestEnd(RequestState rs)
        {
            
            if (rs.ResponseStream != null)
            {
                try
                {
                    rs.ResponseStream.Close();
                }
                catch (Exception e)
                {
                    
                }
            }

            if (rs.requestInfo != null)
            {
                if (rs.requestInfo.Request != null)
                {
                    try
                    {
                        rs.requestInfo.Request.Abort();

                    }
                    catch (Exception e)
                    {

                    }
                }
            }
            
            lock (_workQueue)
            {
                _activeRequestCount--;
                if (_activeRequestCount < MaxConnections)
                {
                    Monitor.Pulse(_workQueue);
                }
            }
        }

        public static HttpWebRequest CreateWebRequest(string URL)
        {
            return CreateWebRequest(URL, string.Empty, string.Empty, null);
        }
        
        public static HttpWebRequest CreateWebRequest(string URL, string strReferer, string PostData, System.Text.Encoding encoding)
        {
            Uri URI = new Uri(URL);
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(URI);
            request.KeepAlive = true;
            request.Accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-excel, application/msword, application/x-shockwave-flash, */*";
            if (strReferer.Length == 0)
            {
                request.Referer = URL;
            }
            else
            {
                request.Referer = strReferer;
            }
            request.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; Maxthon; .NET CLR 2.0.50727)";
            
            //设置代理
            if (Setting.UseProxy)
            {
                if (!Setting.IEProxy)
                {
                    WebProxy proxy = new WebProxy();

                    try
                    {
                        proxy.Address = new Uri(String.Format("http://{0}:{1}", Setting.ProxyServer, Setting.ProxyPort));
                        if (Setting.ProxyUsername.Length > 0 && Setting.ProxyPassword.Length > 0)
                        {
                            proxy.Credentials = new NetworkCredential(Setting.ProxyUsername, Setting.ProxyPassword);
                        }
                        request.Proxy = proxy;
                    }
                    catch
                    {

                    }
                }
            }
            else
            {
                request.Proxy = null;
            }

            //设置cookie
            if (Variant.CurrentUser != null)
            {
                if (request.CookieContainer == null)
                {
                    request.CookieContainer = new CookieContainer();
                }
                lock (_lockAddCookieobject)
                {
                    CookieCollection tmpCookies = Variant.CurrentUser.Cookies;


                    foreach (System.Net.Cookie cookie in tmpCookies)
                    {
                        cookie.Domain = URI.Host;
                        if (cookie.Value.Length != 0)
                        {
                            request.CookieContainer.Add(cookie);
                        }
                        else
                        {
                            //Console.WriteLine(cookie.ToString());
                        }
                    }
                }

            }

          

            //提交的数据
            if (PostData != null && PostData.Length > 0)
            {
                request.ContentType = "application/x-www-form-urlencoded";
                request.Method = "POST";


                byte[] b;
                if (encoding != null)
                {
                    b = encoding.GetBytes(PostData);
                }
                else
                {
                    b =Variant.encoding.GetBytes(PostData);
                }
                request.ContentLength = b.Length;
                using (System.IO.Stream sw = request.GetRequestStream())
                {
                    try
                    {

                        sw.Write(b, 0, b.Length);
                    }
                    catch
                    {
                        return null;
                    }
                    finally
                    {
                        //if (sw != null) { sw.Close(); }
                    }
                }

            }
            return request;
        }
        
        public static void Get(RequestInfo wreq, RequestCompleteCallback webRequestComplete, ExceptionCallback webRequestException, StartDownloadCallback startDownload,    RequestStatePriority Priority)
        {
            RequestState rs = new RequestState();
            rs.WebRequestComplete = webRequestComplete;
            rs.WebRequestException = webRequestException;
            rs.StartDownload = startDownload;           
            rs.requestInfo= wreq;
            rs.Priority = Priority;
            
            lock (_workQueue)
            {
                Enqueue(rs);
                if (_activeRequestCount < MaxConnections)
                {
                    Monitor.Pulse(_workQueue);
                }
            }
        }

        public static Stream GetStream(WebRequest request)
        {
            MemoryStream dataStream;
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            if (Variant.CurrentUser != null)
            {
                AddCookies(response.Cookies);
            }
            try
            {
                dataStream = CopyStream(response.GetResponseStream());                
            }
            finally
            {
                request.Abort();
                response.Close();
            }
            return dataStream;
        }

        private static MemoryStream CopyStream(Stream stream)
        {
            MemoryStream result = new MemoryStream();
            byte[] buffer = new byte[0x1000];
            while (true)
            {
                int size = stream.Read(buffer, 0, 0x1000);
                if (size <= 0)
                {
                    break;
                }
                result.Write(buffer, 0, size);
            }
            result.Seek(0L, SeekOrigin.Begin);
            return result;
        }

        public static String GetSyncHTML(WebRequest request)
        {
            return GetSyncHTML(request, null);
        }
        public static String GetSyncHTML(WebRequest request, System.Text.Encoding encoding)
        {
            Stream dataStream = GetStream(request);
            string strHtml = string.Empty ;
            System.IO.StreamReader sr = null;
            try
            {
               
                sr = new System.IO.StreamReader(dataStream, encoding!=null?encoding:Variant.encoding);
                strHtml = sr.ReadToEnd();
            }
            finally
            {
                if (sr != null) { sr.Close(); }
            }
            return strHtml;
        }
        public static System.Drawing.Image GetSyncImg(WebRequest request)
        {
            Stream dataStream = GetStream(request);

            System.Drawing.Image img = null;
            try
            {
                
                img = System.Drawing.Image.FromStream(dataStream);
            }
            finally
            {
                
            }
            return img;
        }


        private static RequestState Dequeue()
        {
            lock (_lockQueueobject)
            {
                if (blnNeedSort)
                {
                    _workQueue.Sort(new RequestStateComparer());
                    blnNeedSort = false;
                }
                RequestState rs = _workQueue[0];
                _workQueue.RemoveAt(0);
            
                return rs;
            }
        }
        private static void Enqueue(RequestState rs)
        {
            lock (_lockQueueobject)
            {
                if (!blnNeedSort && _workQueue.Count > 0)
                {
                    if (_workQueue[_workQueue.Count - 1].CompareTo(rs) < 0)
                    {
                        blnNeedSort = true;
                    }
                }

                _workQueue.Add(rs);
            }

        }
         
    }
}