RequestResponse.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Services / Web / System / Web / Services / Protocols / RequestResponse.cs / 1305376 / RequestResponse.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.Services.Protocols 
{ 

    using System.IO; 
    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Reflection; 
    using System.Threading;
    using System.Web; 
    using System.Text; 
    using System.Runtime.InteropServices;
    using System.Net; 
    using System.Globalization;
    using System.Diagnostics;
    using System.Web.Services.Diagnostics;
 
    internal class RequestResponseUtils
    { 
        private RequestResponseUtils() { } 
        /*
        internal static string UTF8StreamToString(Stream stream) { 
            long position = 0;
            if (stream.CanSeek)
                position = stream.Position;
            StreamReader reader = new StreamReader(stream, new System.Text.UTF8Encoding()); 
            string result = reader.ReadToEnd();
            if (stream.CanSeek) 
                stream.Position = position; 
            return result;
        } 
        */

        //
 
        internal static Encoding GetEncoding(string contentType)
        { 
            string charset = ContentType.GetCharset(contentType); 
            Encoding e = null;
            try 
            {
                if (charset != null && charset.Length > 0)
                    e = Encoding.GetEncoding(charset);
            } 
            catch (Exception ex)
            { 
                if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException) 
                {
                    throw; 
                }
                if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, typeof(RequestResponseUtils), "GetEncoding", ex);
            }
            // default to ASCII encoding per RFC 2376/3023 
            return e == null ? new ASCIIEncoding() : e;
        } 
 
        internal static Encoding GetEncoding2(string contentType)
        { 
            // default to old text/* behavior for non-application base
            if (!ContentType.IsApplication(contentType))
                return GetEncoding(contentType);
 
            string charset = ContentType.GetCharset(contentType);
            Encoding e = null; 
            try 
            {
                if (charset != null && charset.Length > 0) 
                    e = Encoding.GetEncoding(charset);
            }
            catch (Exception ex)
            { 
                if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
                { 
                    throw; 
                }
                if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, typeof(RequestResponseUtils), "GetEncoding2", ex); 
            }
            // no default per application/* mime type
            return e;
        } 

        internal static string ReadResponse(WebResponse response) 
        { 
            return ReadResponse(response, response.GetResponseStream());
        } 

        internal static string ReadResponse(WebResponse response, Stream stream)
        {
            Encoding e = GetEncoding(response.ContentType); 
            if (e == null) e = Encoding.Default;
            StreamReader reader = new StreamReader(stream, e, true); 
            try 
            {
                return reader.ReadToEnd(); 
            }
            finally
            {
                stream.Close(); 
            }
        } 
 
        // used to copy an unbuffered stream to a buffered stream.
        internal static Stream StreamToMemoryStream(Stream stream) 
        {
            MemoryStream memoryStream = new MemoryStream(1024);
            byte[] buffer = new byte[1024];
            int count; 
            while ((count = stream.Read(buffer, 0, buffer.Length)) != 0)
            { 
                memoryStream.Write(buffer, 0, count); 
            }
            memoryStream.Position = 0; 
            return memoryStream;
        }

        internal static string CreateResponseExceptionString(WebResponse response) 
        {
            return CreateResponseExceptionString(response, response.GetResponseStream()); 
        } 

        internal static string CreateResponseExceptionString(WebResponse response, Stream stream) 
        {
            if (response is HttpWebResponse)
            {
                HttpWebResponse httpResponse = (HttpWebResponse)response; 
                int statusCode = (int)httpResponse.StatusCode;
                if (statusCode >= 400 && statusCode != 500) 
                    return Res.GetString(Res.WebResponseKnownError, statusCode, httpResponse.StatusDescription); 
            }
 
            //
            string content = (stream != null) ? ReadResponse(response, stream) : string.Empty;

            if (content.Length > 0) 
            {
                content = HttpUtility.HtmlDecode(content); 
                StringBuilder sb = new StringBuilder(); 
                sb.Append(Res.GetString(Res.WebResponseUnknownError));
                sb.Append(Environment.NewLine); 
                sb.Append("--");
                sb.Append(Environment.NewLine);
                sb.Append(content);
                sb.Append(Environment.NewLine); 
                sb.Append("--");
                sb.Append("."); 
                return sb.ToString(); 
            }
            else 
                return Res.GetString(Res.WebResponseUnknownErrorEmptyBody);
        }

        internal static int GetBufferSize(int contentLength) 
        {
            int bufferSize; 
            if (contentLength == -1) 
                bufferSize = 8000;
            else if (contentLength <= 16000) 
                bufferSize = contentLength;
            else
                bufferSize = 16000;
 
            return bufferSize;
        } 
 
        static class HttpUtility
        { 
            internal static string HtmlDecode(string s)
            {
                if (s == null)
                    return null; 

                // See if this string needs to be decoded at all.  If no 
                // ampersands are found, then no special HTML-encoded chars 
                // are in the string.
                if (s.IndexOf('&') < 0) 
                    return s;

                StringBuilder builder = new StringBuilder();
                StringWriter writer = new StringWriter(builder, CultureInfo.InvariantCulture); 

                HtmlDecode(s, writer); 
 
                return builder.ToString();
            } 

            private static char[] s_entityEndingChars = new char[] { ';', '&' };
            public static void HtmlDecode(string s, TextWriter output)
            { 
                if (s == null)
                    return; 
 
                if (s.IndexOf('&') < 0)
                { 
                    output.Write(s);        // good as is
                    return;
                }
 
                int l = s.Length;
                for (int i = 0; i < l; i++) 
                { 
                    char ch = s[i];
 
                    if (ch == '&')
                    {
                        // We found a '&'. Now look for the next ';' or '&'. The idea is that
                        // if we find another '&' before finding a ';', then this is not an entity, 
                        // and the next '&' might start a real entity (VSWhidbey 275184)
                        int index = s.IndexOfAny(s_entityEndingChars, i + 1); 
                        if (index > 0 && s[index] == ';') 
                        {
                            string entity = s.Substring(i + 1, index - i - 1); 

                            if (entity.Length > 1 && entity[0] == '#')
                            {
                                try 
                                {
                                    // The # syntax can be in decimal or hex, e.g. 
                                    //      å  --> decimal 
                                    //      å  --> same char in hex
                                    // See http://www.w3.org/TR/REC-html40/charset.html#entities 
                                    if (entity[1] == 'x' || entity[1] == 'X')
                                        ch = (char)Int32.Parse(entity.Substring(2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
                                    else
                                        ch = (char)Int32.Parse(entity.Substring(1), CultureInfo.InvariantCulture); 
                                    i = index; // already looked at everything until semicolon
                                } 
                                catch (System.FormatException e) 
                                {
                                    i++;    //if the number isn't valid, ignore it 
                                    if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, typeof(HttpUtility), "HtmlDecode", e);
                                }
                                catch (System.ArgumentException e)
                                { 
                                    i++;    // if there is no number, ignore it.
                                    if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, typeof(HttpUtility), "HtmlDecode", e); 
                                } 
                            }
                            else 
                            {
                                i = index; // already looked at everything until semicolon

                                char entityChar = HtmlEntities.Lookup(entity); 
                                if (entityChar != (char)0)
                                { 
                                    ch = entityChar; 
                                }
                                else 
                                {
                                    output.Write('&');
                                    output.Write(entity);
                                    output.Write(';'); 
                                    continue;
                                } 
                            } 

                        } 
                    }

                    output.Write(ch);
                } 

            } 
 
            // helper class for lookup of HTML encoding entities
            static class HtmlEntities 
            {
                private static object _lookupLockObject = new object();

                // The list is from http://www.w3.org/TR/REC-html40/sgml/entities.html 
                private static String[] _entitiesList = new String[] {
            "\x0022-quot", 
            "\x0026-amp", 
            "\x003c-lt",
            "\x003e-gt", 
            "\x00a0-nbsp",
            "\x00a1-iexcl",
            "\x00a2-cent",
            "\x00a3-pound", 
            "\x00a4-curren",
            "\x00a5-yen", 
            "\x00a6-brvbar", 
            "\x00a7-sect",
            "\x00a8-uml", 
            "\x00a9-copy",
            "\x00aa-ordf",
            "\x00ab-laquo",
            "\x00ac-not", 
            "\x00ad-shy",
            "\x00ae-reg", 
            "\x00af-macr", 
            "\x00b0-deg",
            "\x00b1-plusmn", 
            "\x00b2-sup2",
            "\x00b3-sup3",
            "\x00b4-acute",
            "\x00b5-micro", 
            "\x00b6-para",
            "\x00b7-middot", 
            "\x00b8-cedil", 
            "\x00b9-sup1",
            "\x00ba-ordm", 
            "\x00bb-raquo",
            "\x00bc-frac14",
            "\x00bd-frac12",
            "\x00be-frac34", 
            "\x00bf-iquest",
            "\x00c0-Agrave", 
            "\x00c1-Aacute", 
            "\x00c2-Acirc",
            "\x00c3-Atilde", 
            "\x00c4-Auml",
            "\x00c5-Aring",
            "\x00c6-AElig",
            "\x00c7-Ccedil", 
            "\x00c8-Egrave",
            "\x00c9-Eacute", 
            "\x00ca-Ecirc", 
            "\x00cb-Euml",
            "\x00cc-Igrave", 
            "\x00cd-Iacute",
            "\x00ce-Icirc",
            "\x00cf-Iuml",
            "\x00d0-ETH", 
            "\x00d1-Ntilde",
            "\x00d2-Ograve", 
            "\x00d3-Oacute", 
            "\x00d4-Ocirc",
            "\x00d5-Otilde", 
            "\x00d6-Ouml",
            "\x00d7-times",
            "\x00d8-Oslash",
            "\x00d9-Ugrave", 
            "\x00da-Uacute",
            "\x00db-Ucirc", 
            "\x00dc-Uuml", 
            "\x00dd-Yacute",
            "\x00de-THORN", 
            "\x00df-szlig",
            "\x00e0-agrave",
            "\x00e1-aacute",
            "\x00e2-acirc", 
            "\x00e3-atilde",
            "\x00e4-auml", 
            "\x00e5-aring", 
            "\x00e6-aelig",
            "\x00e7-ccedil", 
            "\x00e8-egrave",
            "\x00e9-eacute",
            "\x00ea-ecirc",
            "\x00eb-euml", 
            "\x00ec-igrave",
            "\x00ed-iacute", 
            "\x00ee-icirc", 
            "\x00ef-iuml",
            "\x00f0-eth", 
            "\x00f1-ntilde",
            "\x00f2-ograve",
            "\x00f3-oacute",
            "\x00f4-ocirc", 
            "\x00f5-otilde",
            "\x00f6-ouml", 
            "\x00f7-divide", 
            "\x00f8-oslash",
            "\x00f9-ugrave", 
            "\x00fa-uacute",
            "\x00fb-ucirc",
            "\x00fc-uuml",
            "\x00fd-yacute", 
            "\x00fe-thorn",
            "\x00ff-yuml", 
            "\x0152-OElig", 
            "\x0153-oelig",
            "\x0160-Scaron", 
            "\x0161-scaron",
            "\x0178-Yuml",
            "\x0192-fnof",
            "\x02c6-circ", 
            "\x02dc-tilde",
            "\x0391-Alpha", 
            "\x0392-Beta", 
            "\x0393-Gamma",
            "\x0394-Delta", 
            "\x0395-Epsilon",
            "\x0396-Zeta",
            "\x0397-Eta",
            "\x0398-Theta", 
            "\x0399-Iota",
            "\x039a-Kappa", 
            "\x039b-Lambda", 
            "\x039c-Mu",
            "\x039d-Nu", 
            "\x039e-Xi",
            "\x039f-Omicron",
            "\x03a0-Pi",
            "\x03a1-Rho", 
            "\x03a3-Sigma",
            "\x03a4-Tau", 
            "\x03a5-Upsilon", 
            "\x03a6-Phi",
            "\x03a7-Chi", 
            "\x03a8-Psi",
            "\x03a9-Omega",
            "\x03b1-alpha",
            "\x03b2-beta", 
            "\x03b3-gamma",
            "\x03b4-delta", 
            "\x03b5-epsilon", 
            "\x03b6-zeta",
            "\x03b7-eta", 
            "\x03b8-theta",
            "\x03b9-iota",
            "\x03ba-kappa",
            "\x03bb-lambda", 
            "\x03bc-mu",
            "\x03bd-nu", 
            "\x03be-xi", 
            "\x03bf-omicron",
            "\x03c0-pi", 
            "\x03c1-rho",
            "\x03c2-sigmaf",
            "\x03c3-sigma",
            "\x03c4-tau", 
            "\x03c5-upsilon",
            "\x03c6-phi", 
            "\x03c7-chi", 
            "\x03c8-psi",
            "\x03c9-omega", 
            "\x03d1-thetasym",
            "\x03d2-upsih",
            "\x03d6-piv",
            "\x2002-ensp", 
            "\x2003-emsp",
            "\x2009-thinsp", 
            "\x200c-zwnj", 
            "\x200d-zwj",
            "\x200e-lrm", 
            "\x200f-rlm",
            "\x2013-ndash",
            "\x2014-mdash",
            "\x2018-lsquo", 
            "\x2019-rsquo",
            "\x201a-sbquo", 
            "\x201c-ldquo", 
            "\x201d-rdquo",
            "\x201e-bdquo", 
            "\x2020-dagger",
            "\x2021-Dagger",
            "\x2022-bull",
            "\x2026-hellip", 
            "\x2030-permil",
            "\x2032-prime", 
            "\x2033-Prime", 
            "\x2039-lsaquo",
            "\x203a-rsaquo", 
            "\x203e-oline",
            "\x2044-frasl",
            "\x20ac-euro",
            "\x2111-image", 
            "\x2118-weierp",
            "\x211c-real", 
            "\x2122-trade", 
            "\x2135-alefsym",
            "\x2190-larr", 
            "\x2191-uarr",
            "\x2192-rarr",
            "\x2193-darr",
            "\x2194-harr", 
            "\x21b5-crarr",
            "\x21d0-lArr", 
            "\x21d1-uArr", 
            "\x21d2-rArr",
            "\x21d3-dArr", 
            "\x21d4-hArr",
            "\x2200-forall",
            "\x2202-part",
            "\x2203-exist", 
            "\x2205-empty",
            "\x2207-nabla", 
            "\x2208-isin", 
            "\x2209-notin",
            "\x220b-ni", 
            "\x220f-prod",
            "\x2211-sum",
            "\x2212-minus",
            "\x2217-lowast", 
            "\x221a-radic",
            "\x221d-prop", 
            "\x221e-infin", 
            "\x2220-ang",
            "\x2227-and", 
            "\x2228-or",
            "\x2229-cap",
            "\x222a-cup",
            "\x222b-int", 
            "\x2234-there4",
            "\x223c-sim", 
            "\x2245-cong", 
            "\x2248-asymp",
            "\x2260-ne", 
            "\x2261-equiv",
            "\x2264-le",
            "\x2265-ge",
            "\x2282-sub", 
            "\x2283-sup",
            "\x2284-nsub", 
            "\x2286-sube", 
            "\x2287-supe",
            "\x2295-oplus", 
            "\x2297-otimes",
            "\x22a5-perp",
            "\x22c5-sdot",
            "\x2308-lceil", 
            "\x2309-rceil",
            "\x230a-lfloor", 
            "\x230b-rfloor", 
            "\x2329-lang",
            "\x232a-rang", 
            "\x25ca-loz",
            "\x2660-spades",
            "\x2663-clubs",
            "\x2665-hearts", 
            "\x2666-diams",
        }; 
 
                private static Hashtable _entitiesLookupTable;
 
                internal /*public*/ static char Lookup(String entity)
                {
                    if (_entitiesLookupTable == null)
                    { 
                        // populate hashtable on demand
                        lock (_lookupLockObject) 
                        { 
                            if (_entitiesLookupTable == null)
                            { 
                                Hashtable t = new Hashtable();

                                foreach (String s in _entitiesList)
                                    t[s.Substring(2)] = s[0];  // 1st char is the code, 2nd '-' 

                                _entitiesLookupTable = t; 
                            } 
                        }
                    } 

                    Object obj = _entitiesLookupTable[entity];

                    if (obj != null) 
                        return (char)obj;
                    else 
                        return (char)0; 
                }
            } 
        }
    }
}
 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK