< Summary

Class:Microsoft.Azure.CognitiveServices.Search.WebSearch.Web
Assembly:Microsoft.Azure.CognitiveServices.Search.BingWebSearch
File(s):C:\Git\azure-sdk-for-net\sdk\cognitiveservices\Search.BingWebSearch\src\Generated\WebSearch\Web.cs
Covered lines:68
Uncovered lines:85
Coverable lines:153
Total lines:586
Line coverage:44.4% (68 of 153)
Covered branches:40
Total branches:92
Branch coverage:43.4% (40 of 92)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-80%50%
get_Client()-100%100%
SearchWithHttpMessagesAsync()-42.86%43.33%

File(s)

C:\Git\azure-sdk-for-net\sdk\cognitiveservices\Search.BingWebSearch\src\Generated\WebSearch\Web.cs

#LineLine coverage
 1// <auto-generated>
 2// Code generated by Microsoft (R) AutoRest Code Generator.
 3// Changes may cause incorrect behavior and will be lost if the code is
 4// regenerated.
 5// </auto-generated>
 6
 7namespace Microsoft.Azure.CognitiveServices.Search.WebSearch
 8{
 9    using Microsoft.Rest;
 10    using Models;
 11    using Newtonsoft.Json;
 12    using System.Collections;
 13    using System.Collections.Generic;
 14    using System.IO;
 15    using System.Linq;
 16    using System.Net;
 17    using System.Net.Http;
 18    using System.Threading;
 19    using System.Threading.Tasks;
 20
 21    /// <summary>
 22    /// Web operations.
 23    /// </summary>
 24    public partial class Web : IServiceOperations<WebSearchClient>, IWeb
 25    {
 26        /// <summary>
 27        /// Initializes a new instance of the Web class.
 28        /// </summary>
 29        /// <param name='client'>
 30        /// Reference to the service client.
 31        /// </param>
 32        /// <exception cref="System.ArgumentNullException">
 33        /// Thrown when a required parameter is null
 34        /// </exception>
 235        public Web(WebSearchClient client)
 36        {
 237            if (client == null)
 38            {
 039                throw new System.ArgumentNullException("client");
 40            }
 241            Client = client;
 242        }
 43
 44        /// <summary>
 45        /// Gets a reference to the WebSearchClient
 46        /// </summary>
 1647        public WebSearchClient Client { get; private set; }
 48
 49        /// <summary>
 50        /// The Web Search API lets you send a search query to Bing and get back search
 51        /// results that include links to webpages, images, and more.
 52        /// </summary>
 53        /// <param name='query'>
 54        /// The user's search query term. The term may not be empty. The term may
 55        /// contain Bing Advanced Operators. For example, to limit results to a
 56        /// specific domain, use the site: operator.
 57        /// </param>
 58        /// <param name='acceptLanguage'>
 59        /// A comma-delimited list of one or more languages to use for user interface
 60        /// strings. The list is in decreasing order of preference. For additional
 61        /// information, including expected format, see
 62        /// [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). This
 63        /// header and the setLang query parameter are mutually exclusive; do not
 64        /// specify both. If you set this header, you must also specify the cc query
 65        /// parameter. Bing will use the first supported language it finds from the
 66        /// list, and combine that language with the cc parameter value to determine
 67        /// the market to return results for. If the list does not include a supported
 68        /// language, Bing will find the closest language and market that supports the
 69        /// request, and may use an aggregated or default market for the results
 70        /// instead of a specified one. You should use this header and the cc query
 71        /// parameter only if you specify multiple languages; otherwise, you should use
 72        /// the mkt and setLang query parameters. A user interface string is a string
 73        /// that's used as a label in a user interface. There are very few user
 74        /// interface strings in the JSON response objects. Any links in the response
 75        /// objects to Bing.com properties will apply the specified language.
 76        /// </param>
 77        /// <param name='pragma'>
 78        /// By default, Bing returns cached content, if available. To prevent Bing from
 79        /// returning cached content, set the Pragma header to no-cache (for example,
 80        /// Pragma: no-cache).
 81        /// </param>
 82        /// <param name='userAgent'>
 83        /// The user agent originating the request. Bing uses the user agent to provide
 84        /// mobile users with an optimized experience. Although optional, you are
 85        /// strongly encouraged to always specify this header. The user-agent should be
 86        /// the same string that any commonly used browser would send. For information
 87        /// about user agents, see [RFC
 88        /// 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
 89        /// </param>
 90        /// <param name='clientId'>
 91        /// Bing uses this header to provide users with consistent behavior across Bing
 92        /// API calls. Bing often flights new features and improvements, and it uses
 93        /// the client ID as a key for assigning traffic on different flights. If you
 94        /// do not use the same client ID for a user across multiple requests, then
 95        /// Bing may assign the user to multiple conflicting flights. Being assigned to
 96        /// multiple conflicting flights can lead to an inconsistent user experience.
 97        /// For example, if the second request has a different flight assignment than
 98        /// the first, the experience may be unexpected. Also, Bing can use the client
 99        /// ID to tailor web results to that client ID’s search history, providing a
 100        /// richer experience for the user. Bing also uses this header to help improve
 101        /// result rankings by analyzing the activity generated by a client ID. The
 102        /// relevance improvements help with better quality of results delivered by
 103        /// Bing APIs and in turn enables higher click-through rates for the API
 104        /// consumer. IMPORTANT: Although optional, you should consider this header
 105        /// required. Persisting the client ID across multiple requests for the same
 106        /// end user and device combination enables 1) the API consumer to receive a
 107        /// consistent user experience, and 2) higher click-through rates via better
 108        /// quality of results from the Bing APIs. Each user that uses your application
 109        /// on the device must have a unique, Bing generated client ID. If you do not
 110        /// include this header in the request, Bing generates an ID and returns it in
 111        /// the X-MSEdge-ClientID response header. The only time that you should NOT
 112        /// include this header in a request is the first time the user uses your app
 113        /// on that device. Use the client ID for each Bing API request that your app
 114        /// makes for this user on the device. Persist the client ID. To persist the ID
 115        /// in a browser app, use a persistent HTTP cookie to ensure the ID is used
 116        /// across all sessions. Do not use a session cookie. For other apps such as
 117        /// mobile apps, use the device's persistent storage to persist the ID. The
 118        /// next time the user uses your app on that device, get the client ID that you
 119        /// persisted. Bing responses may or may not include this header. If the
 120        /// response includes this header, capture the client ID and use it for all
 121        /// subsequent Bing requests for the user on that device. If you include the
 122        /// X-MSEdge-ClientID, you must not include cookies in the request.
 123        /// </param>
 124        /// <param name='clientIp'>
 125        /// The IPv4 or IPv6 address of the client device. The IP address is used to
 126        /// discover the user's location. Bing uses the location information to
 127        /// determine safe search behavior. Although optional, you are encouraged to
 128        /// always specify this header and the X-Search-Location header. Do not
 129        /// obfuscate the address (for example, by changing the last octet to 0).
 130        /// Obfuscating the address results in the location not being anywhere near the
 131        /// device's actual location, which may result in Bing serving erroneous
 132        /// results.
 133        /// </param>
 134        /// <param name='location'>
 135        /// A semicolon-delimited list of key/value pairs that describe the client's
 136        /// geographical location. Bing uses the location information to determine safe
 137        /// search behavior and to return relevant local content. Specify the key/value
 138        /// pair as &lt;key&gt;:&lt;value&gt;. The following are the keys that you use
 139        /// to specify the user's location. lat (required): The latitude of the
 140        /// client's location, in degrees. The latitude must be greater than or equal
 141        /// to -90.0 and less than or equal to +90.0. Negative values indicate southern
 142        /// latitudes and positive values indicate northern latitudes. long (required):
 143        /// The longitude of the client's location, in degrees. The longitude must be
 144        /// greater than or equal to -180.0 and less than or equal to +180.0. Negative
 145        /// values indicate western longitudes and positive values indicate eastern
 146        /// longitudes. re (required): The radius, in meters, which specifies the
 147        /// horizontal accuracy of the coordinates. Pass the value returned by the
 148        /// device's location service. Typical values might be 22m for GPS/Wi-Fi, 380m
 149        /// for cell tower triangulation, and 18,000m for reverse IP lookup. ts
 150        /// (optional): The UTC UNIX timestamp of when the client was at the location.
 151        /// (The UNIX timestamp is the number of seconds since January 1, 1970.) head
 152        /// (optional): The client's relative heading or direction of travel. Specify
 153        /// the direction of travel as degrees from 0 through 360, counting clockwise
 154        /// relative to true north. Specify this key only if the sp key is nonzero. sp
 155        /// (optional): The horizontal velocity (speed), in meters per second, that the
 156        /// client device is traveling. alt (optional): The altitude of the client
 157        /// device, in meters. are (optional): The radius, in meters, that specifies
 158        /// the vertical accuracy of the coordinates. Specify this key only if you
 159        /// specify the alt key. Although many of the keys are optional, the more
 160        /// information that you provide, the more accurate the location results are.
 161        /// Although optional, you are encouraged to always specify the user's
 162        /// geographical location. Providing the location is especially important if
 163        /// the client's IP address does not accurately reflect the user's physical
 164        /// location (for example, if the client uses VPN). For optimal results, you
 165        /// should include this header and the X-MSEdge-ClientIP header, but at a
 166        /// minimum, you should include this header.
 167        /// </param>
 168        /// <param name='answerCount'>
 169        /// The number of answers that you want the response to include. The answers
 170        /// that Bing returns are based on ranking. For example, if Bing returns
 171        /// webpages, images, videos, and relatedSearches for a request and you set
 172        /// this parameter to two (2), the response includes webpages and images.If you
 173        /// included the responseFilter query parameter in the same request and set it
 174        /// to webpages and news, the response would include only webpages.
 175        /// </param>
 176        /// <param name='countryCode'>
 177        /// A 2-character country code of the country where the results come from. This
 178        /// API supports only the United States market. If you specify this query
 179        /// parameter, it must be set to us. If you set this parameter, you must also
 180        /// specify the Accept-Language header. Bing uses the first supported language
 181        /// it finds from the languages list, and combine that language with the
 182        /// country code that you specify to determine the market to return results
 183        /// for. If the languages list does not include a supported language, Bing
 184        /// finds the closest language and market that supports the request, or it may
 185        /// use an aggregated or default market for the results instead of a specified
 186        /// one. You should use this query parameter and the Accept-Language query
 187        /// parameter only if you specify multiple languages; otherwise, you should use
 188        /// the mkt and setLang query parameters. This parameter and the mkt query
 189        /// parameter are mutually exclusive—do not specify both.
 190        /// </param>
 191        /// <param name='count'>
 192        /// The number of search results to return in the response. The default is 10
 193        /// and the maximum value is 50. The actual number delivered may be less than
 194        /// requested.Use this parameter along with the offset parameter to page
 195        /// results.For example, if your user interface displays 10 search results per
 196        /// page, set count to 10 and offset to 0 to get the first page of results. For
 197        /// each subsequent page, increment offset by 10 (for example, 0, 10, 20). It
 198        /// is possible for multiple pages to include some overlap in results.
 199        /// </param>
 200        /// <param name='freshness'>
 201        /// Filter search results by the following age values: Day—Return webpages that
 202        /// Bing discovered within the last 24 hours. Week—Return webpages that Bing
 203        /// discovered within the last 7 days. Month—Return webpages that discovered
 204        /// within the last 30 days. This filter applies only to webpage results and
 205        /// not to the other results such as news and images. Possible values include:
 206        /// 'Day', 'Week', 'Month'
 207        /// </param>
 208        /// <param name='market'>
 209        /// The market where the results come from. Typically, mkt is the country where
 210        /// the user is making the request from. However, it could be a different
 211        /// country if the user is not located in a country where Bing delivers
 212        /// results. The market must be in the form &lt;language code&gt;-&lt;country
 213        /// code&gt;. For example, en-US. The string is case insensitive. If known, you
 214        /// are encouraged to always specify the market. Specifying the market helps
 215        /// Bing route the request and return an appropriate and optimal response. If
 216        /// you specify a market that is not listed in Market Codes, Bing uses a best
 217        /// fit market code based on an internal mapping that is subject to change.
 218        /// This parameter and the cc query parameter are mutually exclusive—do not
 219        /// specify both.
 220        /// </param>
 221        /// <param name='offset'>
 222        /// The zero-based offset that indicates the number of search results to skip
 223        /// before returning results. The default is 0. The offset should be less than
 224        /// (totalEstimatedMatches - count). Use this parameter along with the count
 225        /// parameter to page results. For example, if your user interface displays 10
 226        /// search results per page, set count to 10 and offset to 0 to get the first
 227        /// page of results. For each subsequent page, increment offset by 10 (for
 228        /// example, 0, 10, 20). it is possible for multiple pages to include some
 229        /// overlap in results.
 230        /// </param>
 231        /// <param name='promote'>
 232        /// A comma-delimited list of answers that you want the response to include
 233        /// regardless of their ranking. For example, if you set answerCount) to two
 234        /// (2) so Bing returns the top two ranked answers, but you also want the
 235        /// response to include news, you'd set promote to news. If the top ranked
 236        /// answers are webpages, images, videos, and relatedSearches, the response
 237        /// includes webpages and images because news is not a ranked answer. But if
 238        /// you set promote to video, Bing would promote the video answer into the
 239        /// response and return webpages, images, and videos. The answers that you want
 240        /// to promote do not count against the answerCount limit. For example, if the
 241        /// ranked answers are news, images, and videos, and you set answerCount to 1
 242        /// and promote to news, the response contains news and images. Or, if the
 243        /// ranked answers are videos, images, and news, the response contains videos
 244        /// and news. Possible values are Computation, Images, News, RelatedSearches,
 245        /// SpellSuggestions, TimeZone, Videos, Webpages. Use only if you specify
 246        /// answerCount.
 247        /// </param>
 248        /// <param name='responseFilter'>
 249        /// A comma-delimited list of answers to include in the response. If you do not
 250        /// specify this parameter, the response includes all search answers for which
 251        /// there's relevant data. Possible filter values are Computation, Images,
 252        /// News, RelatedSearches, SpellSuggestions, TimeZone, Videos, Webpages.
 253        /// Although you may use this filter to get a single answer, you should instead
 254        /// use the answer-specific endpoint in order to get richer results. For
 255        /// example, to receive only images, send the request to one of the Image
 256        /// Search API endpoints. The RelatedSearches and SpellSuggestions answers do
 257        /// not support a separate endpoint like the Image Search API does (only the
 258        /// Web Search API returns them). To include answers that would otherwise be
 259        /// excluded because of ranking, see the promote query parameter.
 260        /// </param>
 261        /// <param name='safeSearch'>
 262        /// A filter used to filter adult content. Off: Return webpages with adult
 263        /// text, images, or videos. Moderate: Return webpages with adult text, but not
 264        /// adult images or videos. Strict: Do not return webpages with adult text,
 265        /// images, or videos. The default is Moderate. If the request comes from a
 266        /// market that Bing's adult policy requires that safeSearch is set to Strict,
 267        /// Bing ignores the safeSearch value and uses Strict. If you use the site:
 268        /// query operator, there is the chance that the response may contain adult
 269        /// content regardless of what the safeSearch query parameter is set to. Use
 270        /// site: only if you are aware of the content on the site and your scenario
 271        /// supports the possibility of adult content. Possible values include: 'Off',
 272        /// 'Moderate', 'Strict'
 273        /// </param>
 274        /// <param name='setLang'>
 275        /// The language to use for user interface strings. Specify the language using
 276        /// the ISO 639-1 2-letter language code. For example, the language code for
 277        /// English is EN. The default is EN (English). Although optional, you should
 278        /// always specify the language. Typically, you set setLang to the same
 279        /// language specified by mkt unless the user wants the user interface strings
 280        /// displayed in a different language. This parameter and the Accept-Language
 281        /// header are mutually exclusive; do not specify both. A user interface string
 282        /// is a string that's used as a label in a user interface. There are few user
 283        /// interface strings in the JSON response objects. Also, any links to Bing.com
 284        /// properties in the response objects apply the specified language.
 285        /// </param>
 286        /// <param name='textDecorations'>
 287        /// A Boolean value that determines whether display strings should contain
 288        /// decoration markers such as hit highlighting characters. If true, the
 289        /// strings may include markers. The default is false. To specify whether to
 290        /// use Unicode characters or HTML tags as the markers, see the textFormat
 291        /// query parameter.
 292        /// </param>
 293        /// <param name='textFormat'>
 294        /// The type of markers to use for text decorations (see the textDecorations
 295        /// query parameter). Possible values are Raw—Use Unicode characters to mark
 296        /// content that needs special formatting. The Unicode characters are in the
 297        /// range E000 through E019. For example, Bing uses E000 and E001 to mark the
 298        /// beginning and end of query terms for hit highlighting. HTML—Use HTML tags
 299        /// to mark content that needs special formatting. For example, use &lt;b&gt;
 300        /// tags to highlight query terms in display strings. The default is Raw. For
 301        /// display strings that contain escapable HTML characters such as &lt;, &gt;,
 302        /// and &amp;, if textFormat is set to HTML, Bing escapes the characters as
 303        /// appropriate (for example, &lt; is escaped to &amp;lt;). Possible values
 304        /// include: 'Raw', 'Html'
 305        /// </param>
 306        /// <param name='customHeaders'>
 307        /// Headers that will be added to request.
 308        /// </param>
 309        /// <param name='cancellationToken'>
 310        /// The cancellation token.
 311        /// </param>
 312        /// <exception cref="ErrorResponseException">
 313        /// Thrown when the operation returned an invalid status code
 314        /// </exception>
 315        /// <exception cref="SerializationException">
 316        /// Thrown when unable to deserialize the response
 317        /// </exception>
 318        /// <exception cref="ValidationException">
 319        /// Thrown when a required parameter is null
 320        /// </exception>
 321        /// <exception cref="System.ArgumentNullException">
 322        /// Thrown when a required parameter is null
 323        /// </exception>
 324        /// <return>
 325        /// A response object containing the response body and response headers.
 326        /// </return>
 327        public async Task<HttpOperationResponse<SearchResponse>> SearchWithHttpMessagesAsync(string query, string accept
 328        {
 2329            if (Client.Endpoint == null)
 330            {
 0331                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
 332            }
 2333            if (query == null)
 334            {
 0335                throw new ValidationException(ValidationRules.CannotBeNull, "query");
 336            }
 2337            string xBingApisSDK = "true";
 338            // Tracing
 2339            bool _shouldTrace = ServiceClientTracing.IsEnabled;
 2340            string _invocationId = null;
 2341            if (_shouldTrace)
 342            {
 0343                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
 0344                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
 0345                tracingParameters.Add("xBingApisSDK", xBingApisSDK);
 0346                tracingParameters.Add("acceptLanguage", acceptLanguage);
 0347                tracingParameters.Add("pragma", pragma);
 0348                tracingParameters.Add("userAgent", userAgent);
 0349                tracingParameters.Add("clientId", clientId);
 0350                tracingParameters.Add("clientIp", clientIp);
 0351                tracingParameters.Add("location", location);
 0352                tracingParameters.Add("answerCount", answerCount);
 0353                tracingParameters.Add("countryCode", countryCode);
 0354                tracingParameters.Add("count", count);
 0355                tracingParameters.Add("freshness", freshness);
 0356                tracingParameters.Add("market", market);
 0357                tracingParameters.Add("offset", offset);
 0358                tracingParameters.Add("promote", promote);
 0359                tracingParameters.Add("query", query);
 0360                tracingParameters.Add("responseFilter", responseFilter);
 0361                tracingParameters.Add("safeSearch", safeSearch);
 0362                tracingParameters.Add("setLang", setLang);
 0363                tracingParameters.Add("textDecorations", textDecorations);
 0364                tracingParameters.Add("textFormat", textFormat);
 0365                tracingParameters.Add("cancellationToken", cancellationToken);
 0366                ServiceClientTracing.Enter(_invocationId, this, "Search", tracingParameters);
 367            }
 368            // Construct URL
 2369            var _baseUrl = Client.BaseUri;
 2370            var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "search";
 2371            _url = _url.Replace("{Endpoint}", Client.Endpoint);
 2372            List<string> _queryParameters = new List<string>();
 2373            if (answerCount != null)
 374            {
 0375                _queryParameters.Add(string.Format("answerCount={0}", System.Uri.EscapeDataString(Rest.Serialization.Saf
 376            }
 2377            if (countryCode != null)
 378            {
 0379                _queryParameters.Add(string.Format("cc={0}", System.Uri.EscapeDataString(countryCode)));
 380            }
 2381            if (count != null)
 382            {
 0383                _queryParameters.Add(string.Format("count={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonC
 384            }
 2385            if (freshness != null)
 386            {
 0387                _queryParameters.Add(string.Format("freshness={0}", System.Uri.EscapeDataString(freshness)));
 388            }
 2389            if (market != null)
 390            {
 2391                _queryParameters.Add(string.Format("mkt={0}", System.Uri.EscapeDataString(market)));
 392            }
 2393            if (offset != null)
 394            {
 0395                _queryParameters.Add(string.Format("offset={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJson
 396            }
 2397            if (promote != null)
 398            {
 0399                _queryParameters.Add(string.Format("promote={0}", System.Uri.EscapeDataString(string.Join(",", promote))
 400            }
 2401            if (query != null)
 402            {
 2403                _queryParameters.Add(string.Format("q={0}", System.Uri.EscapeDataString(query)));
 404            }
 2405            if (responseFilter != null)
 406            {
 0407                _queryParameters.Add(string.Format("responseFilter={0}", System.Uri.EscapeDataString(string.Join(",", re
 408            }
 2409            if (safeSearch != null)
 410            {
 0411                _queryParameters.Add(string.Format("safeSearch={0}", System.Uri.EscapeDataString(safeSearch)));
 412            }
 2413            if (setLang != null)
 414            {
 0415                _queryParameters.Add(string.Format("setLang={0}", System.Uri.EscapeDataString(setLang)));
 416            }
 2417            if (textDecorations != null)
 418            {
 0419                _queryParameters.Add(string.Format("textDecorations={0}", System.Uri.EscapeDataString(Rest.Serialization
 420            }
 2421            if (textFormat != null)
 422            {
 0423                _queryParameters.Add(string.Format("textFormat={0}", System.Uri.EscapeDataString(textFormat)));
 424            }
 2425            if (_queryParameters.Count > 0)
 426            {
 2427                _url += "?" + string.Join("&", _queryParameters);
 428            }
 429            // Create HTTP transport objects
 2430            var _httpRequest = new HttpRequestMessage();
 2431            HttpResponseMessage _httpResponse = null;
 2432            _httpRequest.Method = new HttpMethod("GET");
 2433            _httpRequest.RequestUri = new System.Uri(_url);
 434            // Set Headers
 2435            if (xBingApisSDK != null)
 436            {
 2437                if (_httpRequest.Headers.Contains("X-BingApis-SDK"))
 438                {
 0439                    _httpRequest.Headers.Remove("X-BingApis-SDK");
 440                }
 2441                _httpRequest.Headers.TryAddWithoutValidation("X-BingApis-SDK", xBingApisSDK);
 442            }
 2443            if (acceptLanguage != null)
 444            {
 0445                if (_httpRequest.Headers.Contains("Accept-Language"))
 446                {
 0447                    _httpRequest.Headers.Remove("Accept-Language");
 448                }
 0449                _httpRequest.Headers.TryAddWithoutValidation("Accept-Language", acceptLanguage);
 450            }
 2451            if (pragma != null)
 452            {
 0453                if (_httpRequest.Headers.Contains("Pragma"))
 454                {
 0455                    _httpRequest.Headers.Remove("Pragma");
 456                }
 0457                _httpRequest.Headers.TryAddWithoutValidation("Pragma", pragma);
 458            }
 2459            if (userAgent != null)
 460            {
 0461                if (_httpRequest.Headers.Contains("User-Agent"))
 462                {
 0463                    _httpRequest.Headers.Remove("User-Agent");
 464                }
 0465                _httpRequest.Headers.TryAddWithoutValidation("User-Agent", userAgent);
 466            }
 2467            if (clientId != null)
 468            {
 0469                if (_httpRequest.Headers.Contains("X-MSEdge-ClientID"))
 470                {
 0471                    _httpRequest.Headers.Remove("X-MSEdge-ClientID");
 472                }
 0473                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientID", clientId);
 474            }
 2475            if (clientIp != null)
 476            {
 0477                if (_httpRequest.Headers.Contains("X-MSEdge-ClientIP"))
 478                {
 0479                    _httpRequest.Headers.Remove("X-MSEdge-ClientIP");
 480                }
 0481                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientIP", clientIp);
 482            }
 2483            if (location != null)
 484            {
 0485                if (_httpRequest.Headers.Contains("X-Search-Location"))
 486                {
 0487                    _httpRequest.Headers.Remove("X-Search-Location");
 488                }
 0489                _httpRequest.Headers.TryAddWithoutValidation("X-Search-Location", location);
 490            }
 491
 492
 2493            if (customHeaders != null)
 494            {
 0495                foreach(var _header in customHeaders)
 496                {
 0497                    if (_httpRequest.Headers.Contains(_header.Key))
 498                    {
 0499                        _httpRequest.Headers.Remove(_header.Key);
 500                    }
 0501                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
 502                }
 503            }
 504
 505            // Serialize Request
 2506            string _requestContent = null;
 507            // Set Credentials
 2508            if (Client.Credentials != null)
 509            {
 2510                cancellationToken.ThrowIfCancellationRequested();
 2511                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 512            }
 513            // Send Request
 2514            if (_shouldTrace)
 515            {
 0516                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
 517            }
 2518            cancellationToken.ThrowIfCancellationRequested();
 2519            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 2520            if (_shouldTrace)
 521            {
 0522                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
 523            }
 2524            HttpStatusCode _statusCode = _httpResponse.StatusCode;
 2525            cancellationToken.ThrowIfCancellationRequested();
 2526            string _responseContent = null;
 2527            if ((int)_statusCode != 200)
 528            {
 0529                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _st
 530                try
 531                {
 0532                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 0533                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_res
 0534                    if (_errorBody != null)
 535                    {
 0536                        ex.Body = _errorBody;
 537                    }
 0538                }
 0539                catch (JsonException)
 540                {
 541                    // Ignore the exception
 0542                }
 0543                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
 0544                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
 0545                if (_shouldTrace)
 546                {
 0547                    ServiceClientTracing.Error(_invocationId, ex);
 548                }
 0549                _httpRequest.Dispose();
 0550                if (_httpResponse != null)
 551                {
 0552                    _httpResponse.Dispose();
 553                }
 0554                throw ex;
 555            }
 556            // Create Result
 2557            var _result = new HttpOperationResponse<SearchResponse>();
 2558            _result.Request = _httpRequest;
 2559            _result.Response = _httpResponse;
 560            // Deserialize Response
 2561            if ((int)_statusCode == 200)
 562            {
 2563                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 564                try
 565                {
 2566                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<SearchResponse>(_responseContent
 2567                }
 0568                catch (JsonException ex)
 569                {
 0570                    _httpRequest.Dispose();
 0571                    if (_httpResponse != null)
 572                    {
 0573                        _httpResponse.Dispose();
 574                    }
 0575                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
 576                }
 577            }
 2578            if (_shouldTrace)
 579            {
 0580                ServiceClientTracing.Exit(_invocationId, _result);
 581            }
 2582            return _result;
 2583        }
 584
 585    }
 586}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:47:14 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
get_Client()
SearchWithHttpMessagesAsync()