C# QueryString.ToString方法代码示例

            public void With_no_parameters()
            {
                var uri = new Uri("http://foo/bar");
                var qs = new QueryString(uri);

                qs.ToString().ShouldBe(string.Empty);
                qs.ToString(canonical: true).ShouldBe(string.Empty);
            }

        /// <summary>
        /// Combines the given URI components into a string that is properly encoded for use in HTTP headers.
        /// Note that unicode in the HostString will be encoded as punycode.
        /// </summary>
        /// <param name="scheme">http, https, etc.</param>
        /// <param name="host">The host portion of the uri normally included in the Host header. This may include the port.</param>
        /// <param name="pathBase">The first portion of the request path associated with application root.</param>
        /// <param name="path">The portion of the request path that identifies the requested resource.</param>
        /// <param name="query">The query, if any.</param>
        /// <param name="fragment">The fragment, if any.</param>
        /// <returns></returns>
        public static string BuildAbsolute(
            string scheme,
            HostString host,
            PathString pathBase = new PathString(),
            PathString path = new PathString(),
            QueryString query = new QueryString(),
            FragmentString fragment = new FragmentString())
        {
            var combinedPath = (pathBase.HasValue || path.HasValue) ? (pathBase + path).ToString() : "/";

            var encodedHost = host.ToString();
            var encodedQuery = query.ToString();
            var encodedFragment = fragment.ToString();

            // PERF: Calculate string length to allocate correct buffer size for StringBuilder.
            var length = scheme.Length + SchemeDelimiter.Length + encodedHost.Length
                + combinedPath.Length + encodedQuery.Length + encodedFragment.Length;

            return new StringBuilder(length)
                .Append(scheme)
                .Append(SchemeDelimiter)
                .Append(encodedHost)
                .Append(combinedPath)
                .Append(encodedQuery)
                .Append(encodedFragment)
                .ToString();
        }

    public virtual IPromise<IHttpResponse> Execute(string method, string baseUrl, QueryString queryString, System.Net.ICredentials credentials, bool async, Action<IHttpRequest> configure)
    {
      var uri = baseUrl + (queryString == null ? "" : queryString.ToString());

      var req = (HttpWebRequest)System.Net.WebRequest.Create(uri);
      req.AllowAutoRedirect = this.AllowAutoRedirect;
      if (this.AutomaticDecompression) req.AutomaticDecompression = (DecompressionMethods.GZip | DecompressionMethods.Deflate);
      if (this.StoreCookies) req.CookieContainer = _cookieContainer;
      req.Method = method;
      req.ReadWriteTimeout = 300000;
      req.Timeout = DefaultTimeout;
      if (method == "POST")
      {
        req.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
      }
      req.Credentials = credentials;
      var result = new WebRequest(req, this.Compression);
      if (configure != null) configure.Invoke(result);

      var st = Stopwatch.StartNew();
      return result.Execute(async).Convert(r => {
        if (r.Core.Cookies.Count > 0) SetCookies(r.Core.Cookies);
        return (IHttpResponse)r;
      }).Always(() => {
        st.Stop();
        _httpTracing.TraceData(TraceEventType.Verbose, 0, st.ElapsedMilliseconds);
      });
    }

        public ActionResult Process(HttpRequestBase request, ModelStateDictionary modelState)
        {
            IpnVerificationBinder binder = new IpnVerificationBinder();
            Transaction tx = binder.Bind(request.Form, modelState);

            ContentResult cr = new ContentResult();
            cr.ContentEncoding = Encoding.UTF8;
            cr.ContentType = "text/html";
            cr.Content = "INVALID";

            if (tx != null)
            {
                Transaction dbTx = m_txRepository.GetAll().Where(x => x.Tx == tx.Tx).FirstOrDefault();
                if (dbTx != null)
                {
                    string expected = dbTx.ToIpnQueryString().ToString();
                    QueryString actualQs = new QueryString();
                    actualQs.Add(request.Form);
                    actualQs.Remove("cmd");
                    string actual = actualQs.ToString();

                    if (expected == actual)
                    {
                        cr.Content = "VERIFIED";
                    }
                }
            }

            return cr;
        }

            public void Creating_from_empty_map()
            {
                var args = new Dictionary<string, string>();
                var qs = new QueryString(args);

                qs.ToString().ShouldBe(string.Empty);
            }

        public void MyFact()
        {
            var queryString = new QueryString();

            queryString.Add("q", "mcdonald");

            Assert.Equal("q=mcdonald", queryString.ToString());
        }

 /// <summary>
 /// Combines the given URI components into a string that is properly encoded for use in HTTP headers.
 /// </summary>
 /// <param name="pathBase">The first portion of the request path associated with application root.</param>
 /// <param name="path">The portion of the request path that identifies the requested resource.</param>
 /// <param name="query">The query, if any.</param>
 /// <param name="fragment">The fragment, if any.</param>
 /// <returns></returns>
 public static string BuildRelative(
     PathString pathBase = new PathString(),
     PathString path = new PathString(),
     QueryString query = new QueryString(),
     FragmentString fragment = new FragmentString())
 {
     string combinePath = (pathBase.HasValue || path.HasValue) ? (pathBase + path).ToString() : "/";
     return combinePath + query.ToString() + fragment.ToString();
 }

        public void ShouldEncodeWhenConvertingToString()
        {
            // arrange
            QueryString qs = new QueryString();
            qs.Add("1", "http://");

            // act and assert
            Assert.AreEqual("?1=http%3a%2f%2f", qs.ToString());
        }

        public void ShouldBuildHttpPostString()
        {
            // arrange
            QueryString qs = new QueryString();
            qs.Add("1", "2");
            qs.Add("3", "4");

            // act and assert
            Assert.AreEqual("1=2&3=4", qs.ToString(HttpAction.Post));
        }

            public void Creating_from_map()
            {
                var args = new Dictionary<string, string>()
            {
                { "foo", "bar" },
                { "abc", "123" },
            };
                var qs = new QueryString(args);

                qs.ToString().ShouldBe("abc=123&foo=bar");
            }

        private static void AssertEqual(QueryString expected, QueryString actual)
        {
            Assert.IsTrue(expected.Equals(actual), "Expected: " + expected + "\nActual: " + actual);

            Assert.IsTrue(expected.Equals(QueryString.Parse(actual.ToString())), "After serializing and parsing actual, result changed.\n\nExpected: " + expected + "\nActual: " + QueryString.Parse(actual.ToString()));
            Assert.IsTrue(QueryString.Parse(expected.ToString()).Equals(actual), "After serializing and parsing expected, result changed.\n\nExpected: " + QueryString.Parse(expected.ToString()) + "\nActual: " + actual);
            Assert.IsTrue(QueryString.Parse(expected.ToString()).Equals(QueryString.Parse(actual.ToString())), "After serializing and parsing both, result changed.\n\nExpected: " + QueryString.Parse(expected.ToString()) + "\nActual: " + QueryString.Parse(actual.ToString()));
        }

            public void Canonicalize_flag_is_observed()
            {
                var qs = new QueryString("search=start*&test=one two&tilde=~");

                qs.ToString().ShouldBe("search=start*&test=one+two&tilde=%7E");
                qs.ToString(canonical: true).ShouldBe("search=start%2A&test=one%20two&tilde=~");
            }

            public void Keys_with_no_values_are_ok()
            {
                var qs = new QueryString(new Uri("https://foo.bar?foo=bar&baz=&three"));

                qs.ToString().ShouldBe("baz=&foo=bar&three=");
            }

            public void Keys_are_sorted()
            {
                var qs = new QueryString(new Uri("https://foo.bar/?zulu=5&beta=foo&alpha=9"));

                qs.ToString(canonical: true).ShouldBe("alpha=9&beta=foo&zulu=5");
            }

            public void Keys_and_value_case_is_preserved()
            {
                var qs = new QueryString(new Uri("http://foo.bar/baz?TEST=foo&bar=BAZ"));

                qs.ToString().ShouldBe("bar=BAZ&TEST=foo");
            }