< Summary

Class:Microsoft.Azure.CognitiveServices.Search.VideoSearch.VideosOperations
Assembly:Microsoft.Azure.CognitiveServices.Search.BingVideoSearch
File(s):C:\Git\azure-sdk-for-net\sdk\cognitiveservices\Search.BingVideoSearch\src\Generated\VideoSearch\VideosOperations.cs
Covered lines:177
Uncovered lines:226
Coverable lines:403
Total lines:1563
Line coverage:43.9% (177 of 403)
Covered branches:101
Total branches:240
Branch coverage:42% (101 of 240)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-80%50%
get_Client()-100%100%
SearchWithHttpMessagesAsync()-42.76%43.18%
DetailsWithHttpMessagesAsync()-44.36%43.75%
TrendingWithHttpMessagesAsync()-42.86%38.57%

File(s)

C:\Git\azure-sdk-for-net\sdk\cognitiveservices\Search.BingVideoSearch\src\Generated\VideoSearch\VideosOperations.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.VideoSearch
 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    /// VideosOperations operations.
 23    /// </summary>
 24    public partial class VideosOperations : IServiceOperations<VideoSearchClient>, IVideosOperations
 25    {
 26        /// <summary>
 27        /// Initializes a new instance of the VideosOperations 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>
 635        public VideosOperations(VideoSearchClient client)
 36        {
 637            if (client == null)
 38            {
 039                throw new System.ArgumentNullException("client");
 40            }
 641            Client = client;
 642        }
 43
 44        /// <summary>
 45        /// Gets a reference to the VideoSearchClient
 46        /// </summary>
 4847        public VideoSearchClient Client { get; private set; }
 48
 49        /// <summary>
 50        /// The Video Search API lets you send a search query to Bing and get back a
 51        /// list of videos that are relevant to the search query. This section provides
 52        /// technical details about the query parameters and headers that you use to
 53        /// request videos and the JSON response objects that contain them. For
 54        /// examples that show how to make requests, see [Searching the Web for
 55        /// Videos](https://docs.microsoft.com/azure/cognitive-services/bing-video-search/search-the-web).
 56        /// </summary>
 57        /// <param name='query'>
 58        /// The user's search query string. The query string cannot be empty. The query
 59        /// string may contain [Bing Advanced
 60        /// Operators](http://msdn.microsoft.com/library/ff795620.aspx). For example,
 61        /// to limit videos to a specific domain, use the
 62        /// [site:](http://msdn.microsoft.com/library/ff795613.aspx) operator. Use this
 63        /// parameter only with the Video Search API. Do not specify this parameter
 64        /// when calling the Trending Videos API.
 65        /// </param>
 66        /// <param name='acceptLanguage'>
 67        /// A comma-delimited list of one or more languages to use for user interface
 68        /// strings. The list is in decreasing order of preference. For additional
 69        /// information, including expected format, see
 70        /// [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). This
 71        /// header and the
 72        /// [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#setlang)
 73        /// query parameter are mutually exclusive; do not specify both. If you set
 74        /// this header, you must also specify the
 75        /// [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#cc)
 76        /// query parameter. To determine the market to return results for, Bing uses
 77        /// the first supported language it finds from the list and combines it with
 78        /// the cc parameter value. If the list does not include a supported language,
 79        /// Bing finds the closest language and market that supports the request or it
 80        /// uses an aggregated or default market for the results. To determine the
 81        /// market that Bing used, see the BingAPIs-Market header. Use this header and
 82        /// the cc query parameter only if you specify multiple languages. Otherwise,
 83        /// use the
 84        /// [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#mkt)
 85        /// and
 86        /// [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#setlang)
 87        /// query parameters. A user interface string is a string that's used as a
 88        /// label in a user interface. There are few user interface strings in the JSON
 89        /// response objects. Any links to Bing.com properties in the response objects
 90        /// apply the specified language.
 91        /// </param>
 92        /// <param name='userAgent'>
 93        /// The user agent originating the request. Bing uses the user agent to provide
 94        /// mobile users with an optimized experience. Although optional, you are
 95        /// encouraged to always specify this header. The user-agent should be the same
 96        /// string that any commonly used browser sends. For information about user
 97        /// agents, see [RFC
 98        /// 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The
 99        /// following are examples of user-agent strings. Windows Phone: Mozilla/5.0
 100        /// (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM;
 101        /// Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0 (Linux; U; Android 2.3.5;
 102        /// en - us; SCH - I500 Build / GINGERBREAD) AppleWebKit / 533.1 (KHTML; like
 103        /// Gecko) Version / 4.0 Mobile Safari / 533.1. iPhone: Mozilla / 5.0 (iPhone;
 104        /// CPU iPhone OS 6_1 like Mac OS X) AppleWebKit / 536.26 (KHTML; like Gecko)
 105        /// Mobile / 10B142 iPhone4; 1 BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0
 106        /// (Windows NT 6.3; WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad:
 107        /// Mozilla / 5.0 (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1
 108        /// (KHTML, like Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53
 109        /// </param>
 110        /// <param name='clientId'>
 111        /// Bing uses this header to provide users with consistent behavior across Bing
 112        /// API calls. Bing often flights new features and improvements, and it uses
 113        /// the client ID as a key for assigning traffic on different flights. If you
 114        /// do not use the same client ID for a user across multiple requests, then
 115        /// Bing may assign the user to multiple conflicting flights. Being assigned to
 116        /// multiple conflicting flights can lead to an inconsistent user experience.
 117        /// For example, if the second request has a different flight assignment than
 118        /// the first, the experience may be unexpected. Also, Bing can use the client
 119        /// ID to tailor web results to that client ID’s search history, providing a
 120        /// richer experience for the user. Bing also uses this header to help improve
 121        /// result rankings by analyzing the activity generated by a client ID. The
 122        /// relevance improvements help with better quality of results delivered by
 123        /// Bing APIs and in turn enables higher click-through rates for the API
 124        /// consumer. IMPORTANT: Although optional, you should consider this header
 125        /// required. Persisting the client ID across multiple requests for the same
 126        /// end user and device combination enables 1) the API consumer to receive a
 127        /// consistent user experience, and 2) higher click-through rates via better
 128        /// quality of results from the Bing APIs. Each user that uses your application
 129        /// on the device must have a unique, Bing generated client ID. If you do not
 130        /// include this header in the request, Bing generates an ID and returns it in
 131        /// the X-MSEdge-ClientID response header. The only time that you should NOT
 132        /// include this header in a request is the first time the user uses your app
 133        /// on that device. Use the client ID for each Bing API request that your app
 134        /// makes for this user on the device. Persist the client ID. To persist the ID
 135        /// in a browser app, use a persistent HTTP cookie to ensure the ID is used
 136        /// across all sessions. Do not use a session cookie. For other apps such as
 137        /// mobile apps, use the device's persistent storage to persist the ID. The
 138        /// next time the user uses your app on that device, get the client ID that you
 139        /// persisted. Bing responses may or may not include this header. If the
 140        /// response includes this header, capture the client ID and use it for all
 141        /// subsequent Bing requests for the user on that device. If you include the
 142        /// X-MSEdge-ClientID, you must not include cookies in the request.
 143        /// </param>
 144        /// <param name='clientIp'>
 145        /// The IPv4 or IPv6 address of the client device. The IP address is used to
 146        /// discover the user's location. Bing uses the location information to
 147        /// determine safe search behavior. Although optional, you are encouraged to
 148        /// always specify this header and the X-Search-Location header. Do not
 149        /// obfuscate the address (for example, by changing the last octet to 0).
 150        /// Obfuscating the address results in the location not being anywhere near the
 151        /// device's actual location, which may result in Bing serving erroneous
 152        /// results.
 153        /// </param>
 154        /// <param name='location'>
 155        /// A semicolon-delimited list of key/value pairs that describe the client's
 156        /// geographical location. Bing uses the location information to determine safe
 157        /// search behavior and to return relevant local content. Specify the key/value
 158        /// pair as &lt;key&gt;:&lt;value&gt;. The following are the keys that you use
 159        /// to specify the user's location. lat (required): The latitude of the
 160        /// client's location, in degrees. The latitude must be greater than or equal
 161        /// to -90.0 and less than or equal to +90.0. Negative values indicate southern
 162        /// latitudes and positive values indicate northern latitudes. long (required):
 163        /// The longitude of the client's location, in degrees. The longitude must be
 164        /// greater than or equal to -180.0 and less than or equal to +180.0. Negative
 165        /// values indicate western longitudes and positive values indicate eastern
 166        /// longitudes. re (required): The radius, in meters, which specifies the
 167        /// horizontal accuracy of the coordinates. Pass the value returned by the
 168        /// device's location service. Typical values might be 22m for GPS/Wi-Fi, 380m
 169        /// for cell tower triangulation, and 18,000m for reverse IP lookup. ts
 170        /// (optional): The UTC UNIX timestamp of when the client was at the location.
 171        /// (The UNIX timestamp is the number of seconds since January 1, 1970.) head
 172        /// (optional): The client's relative heading or direction of travel. Specify
 173        /// the direction of travel as degrees from 0 through 360, counting clockwise
 174        /// relative to true north. Specify this key only if the sp key is nonzero. sp
 175        /// (optional): The horizontal velocity (speed), in meters per second, that the
 176        /// client device is traveling. alt (optional): The altitude of the client
 177        /// device, in meters. are (optional): The radius, in meters, that specifies
 178        /// the vertical accuracy of the coordinates. Specify this key only if you
 179        /// specify the alt key. Although many of the keys are optional, the more
 180        /// information that you provide, the more accurate the location results are.
 181        /// Although optional, you are encouraged to always specify the user's
 182        /// geographical location. Providing the location is especially important if
 183        /// the client's IP address does not accurately reflect the user's physical
 184        /// location (for example, if the client uses VPN). For optimal results, you
 185        /// should include this header and the X-MSEdge-ClientIP header, but at a
 186        /// minimum, you should include this header.
 187        /// </param>
 188        /// <param name='countryCode'>
 189        /// A 2-character country code of the country where the results come from. This
 190        /// API supports only the United States market. If you specify this query
 191        /// parameter, it must be set to us. If you set this parameter, you must also
 192        /// specify the Accept-Language header. Bing uses the first supported language
 193        /// it finds from the languages list, and combine that language with the
 194        /// country code that you specify to determine the market to return results
 195        /// for. If the languages list does not include a supported language, Bing
 196        /// finds the closest language and market that supports the request, or it may
 197        /// use an aggregated or default market for the results instead of a specified
 198        /// one. You should use this query parameter and the Accept-Language query
 199        /// parameter only if you specify multiple languages; otherwise, you should use
 200        /// the mkt and setLang query parameters. This parameter and the mkt query
 201        /// parameter are mutually exclusive—do not specify both.
 202        /// </param>
 203        /// <param name='count'>
 204        /// The number of videos to return in the response. The actual number delivered
 205        /// may be less than requested. The default is 35. The maximum is 105. You may
 206        /// use this parameter along with the offset parameter to page results. For
 207        /// example, if your user interface presents 20 videos per page, set count to
 208        /// 20 and offset to 0 to get the first page of results. For each subsequent
 209        /// page, increment offset by 20 (for example, 0, 20, 40). Use this parameter
 210        /// only with the Video Search API. Do not specify this parameter when calling
 211        /// the Trending Videos API or the Web Search API.
 212        /// </param>
 213        /// <param name='freshness'>
 214        /// Filter videos by the date and time that Bing discovered the video. The
 215        /// following are the possible filter values. Day: Return videos discovered
 216        /// within the last 24 hours. Week: Return videos discovered within the last 7
 217        /// days. Month: Return videos discovered within the last 30 days. Possible
 218        /// values include: 'Day', 'Week', 'Month'
 219        /// </param>
 220        /// <param name='id'>
 221        /// An ID that uniquely identifies a video. The
 222        /// [Video](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#video)
 223        /// object's videoId field contains the ID that you set this parameter to. You
 224        /// use this parameter to ensure that the specified video is the first video in
 225        /// the list of videos that Bing returns.
 226        /// </param>
 227        /// <param name='length'>
 228        /// Filter videos by the following lengths: Short: Return videos that are less
 229        /// than 5 minutes. Medium: Return videos that are between 5 and 20 minutes,
 230        /// inclusive. Long: Return videos that are longer than 20 minutes. All: Do not
 231        /// filter by length.Specifying this value is the same as not specifying the
 232        /// videoLength parameter. Possible values include: 'All', 'Short', 'Medium',
 233        /// 'Long'
 234        /// </param>
 235        /// <param name='market'>
 236        /// The market where the results come from. Typically, mkt is the country where
 237        /// the user is making the request from. However, it could be a different
 238        /// country if the user is not located in a country where Bing delivers
 239        /// results. The market must be in the form &lt;language code&gt;-&lt;country
 240        /// code&gt;. For example, en-US. The string is case insensitive. For a list of
 241        /// possible market values, see [Market
 242        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#market-codes)
 243        /// NOTE: If known, you are encouraged to always specify the market. Specifying
 244        /// the market helps Bing route the request and return an appropriate and
 245        /// optimal response. If you specify a market that is not listed in [Market
 246        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#market-codes)
 247        /// Bing uses a best fit market code based on an internal mapping that is
 248        /// subject to change. This parameter and the
 249        /// [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#cc)
 250        /// query parameter are mutually exclusive—do not specify both.
 251        /// </param>
 252        /// <param name='offset'>
 253        /// The zero-based offset that indicates the number of videos to skip before
 254        /// returning videos. The default is 0. The offset should be less than
 255        /// ([totalEstimatedMatches](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-refer
 256        /// - count). Use this parameter along with the count parameter to page
 257        /// results. For example, if your user interface displays 20 videos per page,
 258        /// set count to 20 and offset to 0 to get the first page of results. For each
 259        /// subsequent page, increment offset by 20 (for example, 0, 20, 40). It is
 260        /// possible for multiple pages to include some overlap in results. To prevent
 261        /// duplicates, see
 262        /// [nextOffset](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#videos-
 263        /// Use this parameter only with the Video Search API.
 264        /// </param>
 265        /// <param name='pricing'>
 266        /// Filter videos by the following pricing options: Free: Return videos that
 267        /// are free to view. Paid: Return videos that require a subscription or
 268        /// payment to view. All: Do not filter by pricing.Specifying this value is the
 269        /// same as not specifying the pricing parameter. Possible values include:
 270        /// 'All', 'Free', 'Paid'
 271        /// </param>
 272        /// <param name='resolution'>
 273        /// Filter videos by the following resolutions: SD480p: Return videos with a
 274        /// 480p or higher resolution. HD720p: Return videos with a 720p or higher
 275        /// resolution. HD1080p: Return videos with a 1080p or higher resolution. All:
 276        /// Do not filter by resolution.Specifying this value is the same as not
 277        /// specifying the resolution parameter. Possible values include: 'All',
 278        /// 'SD480p', 'HD720p', 'HD1080p'
 279        /// </param>
 280        /// <param name='safeSearch'>
 281        /// Filter videos for adult content. The following are the possible filter
 282        /// values. Off: If the request is through the Video Search API, the response
 283        /// includes adult videos and the thumbnail images of the videos are clear
 284        /// (non-fuzzy). If the request is through the Web Search API, the response
 285        /// includes adult videos but the thumbnail images of the videos are pixelated
 286        /// (fuzzy). Moderate: If the request is through the Video Search API, the
 287        /// response does not include videos with adult content. If the request is
 288        /// through the Web Search API, the response may include videos with adult
 289        /// content but the thumbnail images of the videos are pixelated (fuzzy).
 290        /// Strict: Does not return videos with adult content. The default is Moderate.
 291        /// If the request comes from a market that Bing's adult policy requires that
 292        /// safeSearch is set to Strict, Bing ignores the safeSearch value and uses
 293        /// Strict. If you use the site: query operator, there is the chance that the
 294        /// response may contain adult content regardless of what the safeSearch query
 295        /// parameter is set to. Use site: only if you are aware of the content on the
 296        /// site and your scenario supports the possibility of adult content. Possible
 297        /// values include: 'Off', 'Moderate', 'Strict'
 298        /// </param>
 299        /// <param name='setLang'>
 300        /// The language to use for user interface strings. Specify the language using
 301        /// the ISO 639-1 2-letter language code. For example, the language code for
 302        /// English is EN. The default is EN (English). Although optional, you should
 303        /// always specify the language. Typically, you set setLang to the same
 304        /// language specified by mkt unless the user wants the user interface strings
 305        /// displayed in a different language. This parameter and the
 306        /// [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#ac
 307        /// header are mutually exclusive; do not specify both. A user interface string
 308        /// is a string that's used as a label in a user interface. There are few user
 309        /// interface strings in the JSON response objects. Also, any links to Bing.com
 310        /// properties in the response objects apply the specified language.
 311        /// </param>
 312        /// <param name='textDecorations'>
 313        /// A Boolean value that determines whether display strings contain decoration
 314        /// markers such as hit highlighting characters. If true, the strings may
 315        /// include markers. The default is false. To specify whether to use Unicode
 316        /// characters or HTML tags as the markers, see the
 317        /// [textFormat](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#textfor
 318        /// query parameter. For information about hit highlighting, see [Hit
 319        /// Highlighting](https://docs.microsoft.com/azure/cognitive-services/bing-news-search/hit-highlighting).
 320        /// </param>
 321        /// <param name='textFormat'>
 322        /// The type of markers to use for text decorations (see the textDecorations
 323        /// query parameter). Possible values are Raw—Use Unicode characters to mark
 324        /// content that needs special formatting. The Unicode characters are in the
 325        /// range E000 through E019. For example, Bing uses E000 and E001 to mark the
 326        /// beginning and end of query terms for hit highlighting. HTML—Use HTML tags
 327        /// to mark content that needs special formatting. For example, use &lt;b&gt;
 328        /// tags to highlight query terms in display strings. The default is Raw. For
 329        /// display strings that contain escapable HTML characters such as &lt;, &gt;,
 330        /// and &amp;, if textFormat is set to HTML, Bing escapes the characters as
 331        /// appropriate (for example, &lt; is escaped to &amp;lt;). Possible values
 332        /// include: 'Raw', 'Html'
 333        /// </param>
 334        /// <param name='customHeaders'>
 335        /// Headers that will be added to request.
 336        /// </param>
 337        /// <param name='cancellationToken'>
 338        /// The cancellation token.
 339        /// </param>
 340        /// <exception cref="ErrorResponseException">
 341        /// Thrown when the operation returned an invalid status code
 342        /// </exception>
 343        /// <exception cref="SerializationException">
 344        /// Thrown when unable to deserialize the response
 345        /// </exception>
 346        /// <exception cref="ValidationException">
 347        /// Thrown when a required parameter is null
 348        /// </exception>
 349        /// <exception cref="System.ArgumentNullException">
 350        /// Thrown when a required parameter is null
 351        /// </exception>
 352        /// <return>
 353        /// A response object containing the response body and response headers.
 354        /// </return>
 355        public async Task<HttpOperationResponse<Videos>> SearchWithHttpMessagesAsync(string query, string acceptLanguage
 356        {
 2357            if (Client.Endpoint == null)
 358            {
 0359                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
 360            }
 2361            if (query == null)
 362            {
 0363                throw new ValidationException(ValidationRules.CannotBeNull, "query");
 364            }
 2365            string xBingApisSDK = "true";
 366            // Tracing
 2367            bool _shouldTrace = ServiceClientTracing.IsEnabled;
 2368            string _invocationId = null;
 2369            if (_shouldTrace)
 370            {
 0371                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
 0372                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
 0373                tracingParameters.Add("xBingApisSDK", xBingApisSDK);
 0374                tracingParameters.Add("acceptLanguage", acceptLanguage);
 0375                tracingParameters.Add("userAgent", userAgent);
 0376                tracingParameters.Add("clientId", clientId);
 0377                tracingParameters.Add("clientIp", clientIp);
 0378                tracingParameters.Add("location", location);
 0379                tracingParameters.Add("countryCode", countryCode);
 0380                tracingParameters.Add("count", count);
 0381                tracingParameters.Add("freshness", freshness);
 0382                tracingParameters.Add("id", id);
 0383                tracingParameters.Add("length", length);
 0384                tracingParameters.Add("market", market);
 0385                tracingParameters.Add("offset", offset);
 0386                tracingParameters.Add("pricing", pricing);
 0387                tracingParameters.Add("query", query);
 0388                tracingParameters.Add("resolution", resolution);
 0389                tracingParameters.Add("safeSearch", safeSearch);
 0390                tracingParameters.Add("setLang", setLang);
 0391                tracingParameters.Add("textDecorations", textDecorations);
 0392                tracingParameters.Add("textFormat", textFormat);
 0393                tracingParameters.Add("cancellationToken", cancellationToken);
 0394                ServiceClientTracing.Enter(_invocationId, this, "Search", tracingParameters);
 395            }
 396            // Construct URL
 2397            var _baseUrl = Client.BaseUri;
 2398            var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "videos/search";
 2399            _url = _url.Replace("{Endpoint}", Client.Endpoint);
 2400            List<string> _queryParameters = new List<string>();
 2401            if (countryCode != null)
 402            {
 0403                _queryParameters.Add(string.Format("cc={0}", System.Uri.EscapeDataString(countryCode)));
 404            }
 2405            if (count != null)
 406            {
 0407                _queryParameters.Add(string.Format("count={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonC
 408            }
 2409            if (freshness != null)
 410            {
 0411                _queryParameters.Add(string.Format("freshness={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJ
 412            }
 2413            if (id != null)
 414            {
 0415                _queryParameters.Add(string.Format("id={0}", System.Uri.EscapeDataString(id)));
 416            }
 2417            if (length != null)
 418            {
 0419                _queryParameters.Add(string.Format("length={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJson
 420            }
 2421            if (market != null)
 422            {
 0423                _queryParameters.Add(string.Format("mkt={0}", System.Uri.EscapeDataString(market)));
 424            }
 2425            if (offset != null)
 426            {
 0427                _queryParameters.Add(string.Format("offset={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJson
 428            }
 2429            if (pricing != null)
 430            {
 0431                _queryParameters.Add(string.Format("pricing={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJso
 432            }
 2433            if (query != null)
 434            {
 2435                _queryParameters.Add(string.Format("q={0}", System.Uri.EscapeDataString(query)));
 436            }
 2437            if (resolution != null)
 438            {
 0439                _queryParameters.Add(string.Format("resolution={0}", System.Uri.EscapeDataString(Rest.Serialization.Safe
 440            }
 2441            if (safeSearch != null)
 442            {
 0443                _queryParameters.Add(string.Format("safeSearch={0}", System.Uri.EscapeDataString(Rest.Serialization.Safe
 444            }
 2445            if (setLang != null)
 446            {
 0447                _queryParameters.Add(string.Format("setLang={0}", System.Uri.EscapeDataString(setLang)));
 448            }
 2449            if (textDecorations != null)
 450            {
 0451                _queryParameters.Add(string.Format("textDecorations={0}", System.Uri.EscapeDataString(Rest.Serialization
 452            }
 2453            if (textFormat != null)
 454            {
 0455                _queryParameters.Add(string.Format("textFormat={0}", System.Uri.EscapeDataString(Rest.Serialization.Safe
 456            }
 2457            if (_queryParameters.Count > 0)
 458            {
 2459                _url += "?" + string.Join("&", _queryParameters);
 460            }
 461            // Create HTTP transport objects
 2462            var _httpRequest = new HttpRequestMessage();
 2463            HttpResponseMessage _httpResponse = null;
 2464            _httpRequest.Method = new HttpMethod("GET");
 2465            _httpRequest.RequestUri = new System.Uri(_url);
 466            // Set Headers
 2467            if (xBingApisSDK != null)
 468            {
 2469                if (_httpRequest.Headers.Contains("X-BingApis-SDK"))
 470                {
 0471                    _httpRequest.Headers.Remove("X-BingApis-SDK");
 472                }
 2473                _httpRequest.Headers.TryAddWithoutValidation("X-BingApis-SDK", xBingApisSDK);
 474            }
 2475            if (acceptLanguage != null)
 476            {
 0477                if (_httpRequest.Headers.Contains("Accept-Language"))
 478                {
 0479                    _httpRequest.Headers.Remove("Accept-Language");
 480                }
 0481                _httpRequest.Headers.TryAddWithoutValidation("Accept-Language", acceptLanguage);
 482            }
 2483            if (userAgent != null)
 484            {
 0485                if (_httpRequest.Headers.Contains("User-Agent"))
 486                {
 0487                    _httpRequest.Headers.Remove("User-Agent");
 488                }
 0489                _httpRequest.Headers.TryAddWithoutValidation("User-Agent", userAgent);
 490            }
 2491            if (clientId != null)
 492            {
 0493                if (_httpRequest.Headers.Contains("X-MSEdge-ClientID"))
 494                {
 0495                    _httpRequest.Headers.Remove("X-MSEdge-ClientID");
 496                }
 0497                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientID", clientId);
 498            }
 2499            if (clientIp != null)
 500            {
 0501                if (_httpRequest.Headers.Contains("X-MSEdge-ClientIP"))
 502                {
 0503                    _httpRequest.Headers.Remove("X-MSEdge-ClientIP");
 504                }
 0505                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientIP", clientIp);
 506            }
 2507            if (location != null)
 508            {
 0509                if (_httpRequest.Headers.Contains("X-Search-Location"))
 510                {
 0511                    _httpRequest.Headers.Remove("X-Search-Location");
 512                }
 0513                _httpRequest.Headers.TryAddWithoutValidation("X-Search-Location", location);
 514            }
 515
 516
 2517            if (customHeaders != null)
 518            {
 0519                foreach(var _header in customHeaders)
 520                {
 0521                    if (_httpRequest.Headers.Contains(_header.Key))
 522                    {
 0523                        _httpRequest.Headers.Remove(_header.Key);
 524                    }
 0525                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
 526                }
 527            }
 528
 529            // Serialize Request
 2530            string _requestContent = null;
 531            // Set Credentials
 2532            if (Client.Credentials != null)
 533            {
 2534                cancellationToken.ThrowIfCancellationRequested();
 2535                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 536            }
 537            // Send Request
 2538            if (_shouldTrace)
 539            {
 0540                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
 541            }
 2542            cancellationToken.ThrowIfCancellationRequested();
 2543            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 2544            if (_shouldTrace)
 545            {
 0546                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
 547            }
 2548            HttpStatusCode _statusCode = _httpResponse.StatusCode;
 2549            cancellationToken.ThrowIfCancellationRequested();
 2550            string _responseContent = null;
 2551            if ((int)_statusCode != 200)
 552            {
 0553                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _st
 554                try
 555                {
 0556                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 0557                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_res
 0558                    if (_errorBody != null)
 559                    {
 0560                        ex.Body = _errorBody;
 561                    }
 0562                }
 0563                catch (JsonException)
 564                {
 565                    // Ignore the exception
 0566                }
 0567                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
 0568                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
 0569                if (_shouldTrace)
 570                {
 0571                    ServiceClientTracing.Error(_invocationId, ex);
 572                }
 0573                _httpRequest.Dispose();
 0574                if (_httpResponse != null)
 575                {
 0576                    _httpResponse.Dispose();
 577                }
 0578                throw ex;
 579            }
 580            // Create Result
 2581            var _result = new HttpOperationResponse<Videos>();
 2582            _result.Request = _httpRequest;
 2583            _result.Response = _httpResponse;
 584            // Deserialize Response
 2585            if ((int)_statusCode == 200)
 586            {
 2587                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 588                try
 589                {
 2590                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<Videos>(_responseContent, Client
 2591                }
 0592                catch (JsonException ex)
 593                {
 0594                    _httpRequest.Dispose();
 0595                    if (_httpResponse != null)
 596                    {
 0597                        _httpResponse.Dispose();
 598                    }
 0599                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
 600                }
 601            }
 2602            if (_shouldTrace)
 603            {
 0604                ServiceClientTracing.Exit(_invocationId, _result);
 605            }
 2606            return _result;
 2607        }
 608
 609        /// <summary>
 610        /// The Video Detail Search API lets you search on Bing and get back insights
 611        /// about a video, such as related videos. This section provides technical
 612        /// details about the query parameters and headers that you use to request
 613        /// insights of videos and the JSON response objects that contain them. For
 614        /// examples that show how to make requests, see [Searching the Web for
 615        /// Videos](https://docs.microsoft.com/azure/cognitive-services/bing-video-search/search-the-web).
 616        /// </summary>
 617        /// <param name='query'>
 618        /// The user's search query string. The query string cannot be empty. The query
 619        /// string may contain [Bing Advanced
 620        /// Operators](http://msdn.microsoft.com/library/ff795620.aspx). For example,
 621        /// to limit videos to a specific domain, use the
 622        /// [site:](http://msdn.microsoft.com/library/ff795613.aspx) operator. Use this
 623        /// parameter only with the Video Search API. Do not specify this parameter
 624        /// when calling the Trending Videos API.
 625        /// </param>
 626        /// <param name='acceptLanguage'>
 627        /// A comma-delimited list of one or more languages to use for user interface
 628        /// strings. The list is in decreasing order of preference. For additional
 629        /// information, including expected format, see
 630        /// [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). This
 631        /// header and the
 632        /// [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#setlang)
 633        /// query parameter are mutually exclusive; do not specify both. If you set
 634        /// this header, you must also specify the
 635        /// [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#cc)
 636        /// query parameter. To determine the market to return results for, Bing uses
 637        /// the first supported language it finds from the list and combines it with
 638        /// the cc parameter value. If the list does not include a supported language,
 639        /// Bing finds the closest language and market that supports the request or it
 640        /// uses an aggregated or default market for the results. To determine the
 641        /// market that Bing used, see the BingAPIs-Market header. Use this header and
 642        /// the cc query parameter only if you specify multiple languages. Otherwise,
 643        /// use the
 644        /// [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#mkt)
 645        /// and
 646        /// [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#setlang)
 647        /// query parameters. A user interface string is a string that's used as a
 648        /// label in a user interface. There are few user interface strings in the JSON
 649        /// response objects. Any links to Bing.com properties in the response objects
 650        /// apply the specified language.
 651        /// </param>
 652        /// <param name='userAgent'>
 653        /// The user agent originating the request. Bing uses the user agent to provide
 654        /// mobile users with an optimized experience. Although optional, you are
 655        /// encouraged to always specify this header. The user-agent should be the same
 656        /// string that any commonly used browser sends. For information about user
 657        /// agents, see [RFC
 658        /// 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The
 659        /// following are examples of user-agent strings. Windows Phone: Mozilla/5.0
 660        /// (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM;
 661        /// Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0 (Linux; U; Android 2.3.5;
 662        /// en - us; SCH - I500 Build / GINGERBREAD) AppleWebKit / 533.1 (KHTML; like
 663        /// Gecko) Version / 4.0 Mobile Safari / 533.1. iPhone: Mozilla / 5.0 (iPhone;
 664        /// CPU iPhone OS 6_1 like Mac OS X) AppleWebKit / 536.26 (KHTML; like Gecko)
 665        /// Mobile / 10B142 iPhone4; 1 BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0
 666        /// (Windows NT 6.3; WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad:
 667        /// Mozilla / 5.0 (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1
 668        /// (KHTML, like Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53
 669        /// </param>
 670        /// <param name='clientId'>
 671        /// Bing uses this header to provide users with consistent behavior across Bing
 672        /// API calls. Bing often flights new features and improvements, and it uses
 673        /// the client ID as a key for assigning traffic on different flights. If you
 674        /// do not use the same client ID for a user across multiple requests, then
 675        /// Bing may assign the user to multiple conflicting flights. Being assigned to
 676        /// multiple conflicting flights can lead to an inconsistent user experience.
 677        /// For example, if the second request has a different flight assignment than
 678        /// the first, the experience may be unexpected. Also, Bing can use the client
 679        /// ID to tailor web results to that client ID’s search history, providing a
 680        /// richer experience for the user. Bing also uses this header to help improve
 681        /// result rankings by analyzing the activity generated by a client ID. The
 682        /// relevance improvements help with better quality of results delivered by
 683        /// Bing APIs and in turn enables higher click-through rates for the API
 684        /// consumer. IMPORTANT: Although optional, you should consider this header
 685        /// required. Persisting the client ID across multiple requests for the same
 686        /// end user and device combination enables 1) the API consumer to receive a
 687        /// consistent user experience, and 2) higher click-through rates via better
 688        /// quality of results from the Bing APIs. Each user that uses your application
 689        /// on the device must have a unique, Bing generated client ID. If you do not
 690        /// include this header in the request, Bing generates an ID and returns it in
 691        /// the X-MSEdge-ClientID response header. The only time that you should NOT
 692        /// include this header in a request is the first time the user uses your app
 693        /// on that device. Use the client ID for each Bing API request that your app
 694        /// makes for this user on the device. Persist the client ID. To persist the ID
 695        /// in a browser app, use a persistent HTTP cookie to ensure the ID is used
 696        /// across all sessions. Do not use a session cookie. For other apps such as
 697        /// mobile apps, use the device's persistent storage to persist the ID. The
 698        /// next time the user uses your app on that device, get the client ID that you
 699        /// persisted. Bing responses may or may not include this header. If the
 700        /// response includes this header, capture the client ID and use it for all
 701        /// subsequent Bing requests for the user on that device. If you include the
 702        /// X-MSEdge-ClientID, you must not include cookies in the request.
 703        /// </param>
 704        /// <param name='clientIp'>
 705        /// The IPv4 or IPv6 address of the client device. The IP address is used to
 706        /// discover the user's location. Bing uses the location information to
 707        /// determine safe search behavior. Although optional, you are encouraged to
 708        /// always specify this header and the X-Search-Location header. Do not
 709        /// obfuscate the address (for example, by changing the last octet to 0).
 710        /// Obfuscating the address results in the location not being anywhere near the
 711        /// device's actual location, which may result in Bing serving erroneous
 712        /// results.
 713        /// </param>
 714        /// <param name='location'>
 715        /// A semicolon-delimited list of key/value pairs that describe the client's
 716        /// geographical location. Bing uses the location information to determine safe
 717        /// search behavior and to return relevant local content. Specify the key/value
 718        /// pair as &lt;key&gt;:&lt;value&gt;. The following are the keys that you use
 719        /// to specify the user's location. lat (required): The latitude of the
 720        /// client's location, in degrees. The latitude must be greater than or equal
 721        /// to -90.0 and less than or equal to +90.0. Negative values indicate southern
 722        /// latitudes and positive values indicate northern latitudes. long (required):
 723        /// The longitude of the client's location, in degrees. The longitude must be
 724        /// greater than or equal to -180.0 and less than or equal to +180.0. Negative
 725        /// values indicate western longitudes and positive values indicate eastern
 726        /// longitudes. re (required): The radius, in meters, which specifies the
 727        /// horizontal accuracy of the coordinates. Pass the value returned by the
 728        /// device's location service. Typical values might be 22m for GPS/Wi-Fi, 380m
 729        /// for cell tower triangulation, and 18,000m for reverse IP lookup. ts
 730        /// (optional): The UTC UNIX timestamp of when the client was at the location.
 731        /// (The UNIX timestamp is the number of seconds since January 1, 1970.) head
 732        /// (optional): The client's relative heading or direction of travel. Specify
 733        /// the direction of travel as degrees from 0 through 360, counting clockwise
 734        /// relative to true north. Specify this key only if the sp key is nonzero. sp
 735        /// (optional): The horizontal velocity (speed), in meters per second, that the
 736        /// client device is traveling. alt (optional): The altitude of the client
 737        /// device, in meters. are (optional): The radius, in meters, that specifies
 738        /// the vertical accuracy of the coordinates. Specify this key only if you
 739        /// specify the alt key. Although many of the keys are optional, the more
 740        /// information that you provide, the more accurate the location results are.
 741        /// Although optional, you are encouraged to always specify the user's
 742        /// geographical location. Providing the location is especially important if
 743        /// the client's IP address does not accurately reflect the user's physical
 744        /// location (for example, if the client uses VPN). For optimal results, you
 745        /// should include this header and the X-MSEdge-ClientIP header, but at a
 746        /// minimum, you should include this header.
 747        /// </param>
 748        /// <param name='countryCode'>
 749        /// A 2-character country code of the country where the results come from. This
 750        /// API supports only the United States market. If you specify this query
 751        /// parameter, it must be set to us. If you set this parameter, you must also
 752        /// specify the Accept-Language header. Bing uses the first supported language
 753        /// it finds from the languages list, and combine that language with the
 754        /// country code that you specify to determine the market to return results
 755        /// for. If the languages list does not include a supported language, Bing
 756        /// finds the closest language and market that supports the request, or it may
 757        /// use an aggregated or default market for the results instead of a specified
 758        /// one. You should use this query parameter and the Accept-Language query
 759        /// parameter only if you specify multiple languages; otherwise, you should use
 760        /// the mkt and setLang query parameters. This parameter and the mkt query
 761        /// parameter are mutually exclusive—do not specify both.
 762        /// </param>
 763        /// <param name='id'>
 764        /// An ID that uniquely identifies a video. The
 765        /// [Video](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#video)
 766        /// object's videoId field contains the ID that you set this parameter to. You
 767        /// use this parameter to identify the video to get insights of.
 768        /// </param>
 769        /// <param name='modules'>
 770        /// A comma-delimited list of insights to request. The following are the
 771        /// possible case-insensitive values. All: Return all available insights.
 772        /// RelatedVideos: Return a list of videos that are similar to the video
 773        /// specified by the id query parameter. VideoResult: Return the video that
 774        /// you're requesting insights of (this is the video that you set the id query
 775        /// parameter to in your insights request). If you specify an insight and there
 776        /// is no data for it, the response object does not include the related field.
 777        /// For example, if you specify RelatedVideos and none exist, the response does
 778        /// not include the relatedVideos field. Although the user's query term is not
 779        /// required, you should always include it because it helps to improve
 780        /// relevance and the results.
 781        /// </param>
 782        /// <param name='market'>
 783        /// The market where the results come from. Typically, mkt is the country where
 784        /// the user is making the request from. However, it could be a different
 785        /// country if the user is not located in a country where Bing delivers
 786        /// results. The market must be in the form &lt;language code&gt;-&lt;country
 787        /// code&gt;. For example, en-US. The string is case insensitive. For a list of
 788        /// possible market values, see [Market
 789        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#market-codes)
 790        /// NOTE: If known, you are encouraged to always specify the market. Specifying
 791        /// the market helps Bing route the request and return an appropriate and
 792        /// optimal response. If you specify a market that is not listed in [Market
 793        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#market-codes)
 794        /// Bing uses a best fit market code based on an internal mapping that is
 795        /// subject to change. This parameter and the
 796        /// [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#cc)
 797        /// query parameter are mutually exclusive—do not specify both.
 798        /// </param>
 799        /// <param name='resolution'>
 800        /// Filter videos by the following resolutions: SD480p: Return videos with a
 801        /// 480p or higher resolution. HD720p: Return videos with a 720p or higher
 802        /// resolution. HD1080p: Return videos with a 1080p or higher resolution. All:
 803        /// Do not filter by resolution.Specifying this value is the same as not
 804        /// specifying the resolution parameter. Possible values include: 'All',
 805        /// 'SD480p', 'HD720p', 'HD1080p'
 806        /// </param>
 807        /// <param name='safeSearch'>
 808        /// Filter videos for adult content. The following are the possible filter
 809        /// values. Off: If the request is through the Video Search API, the response
 810        /// includes adult videos and the thumbnail images of the videos are clear
 811        /// (non-fuzzy). If the request is through the Web Search API, the response
 812        /// includes adult videos but the thumbnail images of the videos are pixelated
 813        /// (fuzzy). Moderate: If the request is through the Video Search API, the
 814        /// response does not include videos with adult content. If the request is
 815        /// through the Web Search API, the response may include videos with adult
 816        /// content but the thumbnail images of the videos are pixelated (fuzzy).
 817        /// Strict: Does not return videos with adult content. The default is Moderate.
 818        /// If the request comes from a market that Bing's adult policy requires that
 819        /// safeSearch is set to Strict, Bing ignores the safeSearch value and uses
 820        /// Strict. If you use the site: query operator, there is the chance that the
 821        /// response may contain adult content regardless of what the safeSearch query
 822        /// parameter is set to. Use site: only if you are aware of the content on the
 823        /// site and your scenario supports the possibility of adult content. Possible
 824        /// values include: 'Off', 'Moderate', 'Strict'
 825        /// </param>
 826        /// <param name='setLang'>
 827        /// The language to use for user interface strings. Specify the language using
 828        /// the ISO 639-1 2-letter language code. For example, the language code for
 829        /// English is EN. The default is EN (English). Although optional, you should
 830        /// always specify the language. Typically, you set setLang to the same
 831        /// language specified by mkt unless the user wants the user interface strings
 832        /// displayed in a different language. This parameter and the
 833        /// [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#ac
 834        /// header are mutually exclusive; do not specify both. A user interface string
 835        /// is a string that's used as a label in a user interface. There are few user
 836        /// interface strings in the JSON response objects. Also, any links to Bing.com
 837        /// properties in the response objects apply the specified language.
 838        /// </param>
 839        /// <param name='textDecorations'>
 840        /// A Boolean value that determines whether display strings contain decoration
 841        /// markers such as hit highlighting characters. If true, the strings may
 842        /// include markers. The default is false. To specify whether to use Unicode
 843        /// characters or HTML tags as the markers, see the
 844        /// [textFormat](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#textfor
 845        /// query parameter. For information about hit highlighting, see [Hit
 846        /// Highlighting](https://docs.microsoft.com/azure/cognitive-services/bing-news-search/hit-highlighting).
 847        /// </param>
 848        /// <param name='textFormat'>
 849        /// The type of markers to use for text decorations (see the textDecorations
 850        /// query parameter). Possible values are Raw—Use Unicode characters to mark
 851        /// content that needs special formatting. The Unicode characters are in the
 852        /// range E000 through E019. For example, Bing uses E000 and E001 to mark the
 853        /// beginning and end of query terms for hit highlighting. HTML—Use HTML tags
 854        /// to mark content that needs special formatting. For example, use &lt;b&gt;
 855        /// tags to highlight query terms in display strings. The default is Raw. For
 856        /// display strings that contain escapable HTML characters such as &lt;, &gt;,
 857        /// and &amp;, if textFormat is set to HTML, Bing escapes the characters as
 858        /// appropriate (for example, &lt; is escaped to &amp;lt;). Possible values
 859        /// include: 'Raw', 'Html'
 860        /// </param>
 861        /// <param name='customHeaders'>
 862        /// Headers that will be added to request.
 863        /// </param>
 864        /// <param name='cancellationToken'>
 865        /// The cancellation token.
 866        /// </param>
 867        /// <exception cref="ErrorResponseException">
 868        /// Thrown when the operation returned an invalid status code
 869        /// </exception>
 870        /// <exception cref="SerializationException">
 871        /// Thrown when unable to deserialize the response
 872        /// </exception>
 873        /// <exception cref="ValidationException">
 874        /// Thrown when a required parameter is null
 875        /// </exception>
 876        /// <exception cref="System.ArgumentNullException">
 877        /// Thrown when a required parameter is null
 878        /// </exception>
 879        /// <return>
 880        /// A response object containing the response body and response headers.
 881        /// </return>
 882        public async Task<HttpOperationResponse<VideoDetails>> DetailsWithHttpMessagesAsync(string query, string acceptL
 883        {
 2884            if (Client.Endpoint == null)
 885            {
 0886                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
 887            }
 2888            if (query == null)
 889            {
 0890                throw new ValidationException(ValidationRules.CannotBeNull, "query");
 891            }
 2892            string xBingApisSDK = "true";
 893            // Tracing
 2894            bool _shouldTrace = ServiceClientTracing.IsEnabled;
 2895            string _invocationId = null;
 2896            if (_shouldTrace)
 897            {
 0898                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
 0899                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
 0900                tracingParameters.Add("xBingApisSDK", xBingApisSDK);
 0901                tracingParameters.Add("acceptLanguage", acceptLanguage);
 0902                tracingParameters.Add("userAgent", userAgent);
 0903                tracingParameters.Add("clientId", clientId);
 0904                tracingParameters.Add("clientIp", clientIp);
 0905                tracingParameters.Add("location", location);
 0906                tracingParameters.Add("countryCode", countryCode);
 0907                tracingParameters.Add("id", id);
 0908                tracingParameters.Add("modules", modules);
 0909                tracingParameters.Add("market", market);
 0910                tracingParameters.Add("query", query);
 0911                tracingParameters.Add("resolution", resolution);
 0912                tracingParameters.Add("safeSearch", safeSearch);
 0913                tracingParameters.Add("setLang", setLang);
 0914                tracingParameters.Add("textDecorations", textDecorations);
 0915                tracingParameters.Add("textFormat", textFormat);
 0916                tracingParameters.Add("cancellationToken", cancellationToken);
 0917                ServiceClientTracing.Enter(_invocationId, this, "Details", tracingParameters);
 918            }
 919            // Construct URL
 2920            var _baseUrl = Client.BaseUri;
 2921            var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "videos/details";
 2922            _url = _url.Replace("{Endpoint}", Client.Endpoint);
 2923            List<string> _queryParameters = new List<string>();
 2924            if (countryCode != null)
 925            {
 0926                _queryParameters.Add(string.Format("cc={0}", System.Uri.EscapeDataString(countryCode)));
 927            }
 2928            if (id != null)
 929            {
 2930                _queryParameters.Add(string.Format("id={0}", System.Uri.EscapeDataString(id)));
 931            }
 2932            if (modules != null)
 933            {
 0934                _queryParameters.Add(string.Format("modules={0}", System.Uri.EscapeDataString(string.Join(",", modules))
 935            }
 2936            if (market != null)
 937            {
 0938                _queryParameters.Add(string.Format("mkt={0}", System.Uri.EscapeDataString(market)));
 939            }
 2940            if (query != null)
 941            {
 2942                _queryParameters.Add(string.Format("q={0}", System.Uri.EscapeDataString(query)));
 943            }
 2944            if (resolution != null)
 945            {
 0946                _queryParameters.Add(string.Format("resolution={0}", System.Uri.EscapeDataString(Rest.Serialization.Safe
 947            }
 2948            if (safeSearch != null)
 949            {
 0950                _queryParameters.Add(string.Format("safeSearch={0}", System.Uri.EscapeDataString(Rest.Serialization.Safe
 951            }
 2952            if (setLang != null)
 953            {
 0954                _queryParameters.Add(string.Format("setLang={0}", System.Uri.EscapeDataString(setLang)));
 955            }
 2956            if (textDecorations != null)
 957            {
 0958                _queryParameters.Add(string.Format("textDecorations={0}", System.Uri.EscapeDataString(Rest.Serialization
 959            }
 2960            if (textFormat != null)
 961            {
 0962                _queryParameters.Add(string.Format("textFormat={0}", System.Uri.EscapeDataString(Rest.Serialization.Safe
 963            }
 2964            if (_queryParameters.Count > 0)
 965            {
 2966                _url += "?" + string.Join("&", _queryParameters);
 967            }
 968            // Create HTTP transport objects
 2969            var _httpRequest = new HttpRequestMessage();
 2970            HttpResponseMessage _httpResponse = null;
 2971            _httpRequest.Method = new HttpMethod("GET");
 2972            _httpRequest.RequestUri = new System.Uri(_url);
 973            // Set Headers
 2974            if (xBingApisSDK != null)
 975            {
 2976                if (_httpRequest.Headers.Contains("X-BingApis-SDK"))
 977                {
 0978                    _httpRequest.Headers.Remove("X-BingApis-SDK");
 979                }
 2980                _httpRequest.Headers.TryAddWithoutValidation("X-BingApis-SDK", xBingApisSDK);
 981            }
 2982            if (acceptLanguage != null)
 983            {
 0984                if (_httpRequest.Headers.Contains("Accept-Language"))
 985                {
 0986                    _httpRequest.Headers.Remove("Accept-Language");
 987                }
 0988                _httpRequest.Headers.TryAddWithoutValidation("Accept-Language", acceptLanguage);
 989            }
 2990            if (userAgent != null)
 991            {
 0992                if (_httpRequest.Headers.Contains("User-Agent"))
 993                {
 0994                    _httpRequest.Headers.Remove("User-Agent");
 995                }
 0996                _httpRequest.Headers.TryAddWithoutValidation("User-Agent", userAgent);
 997            }
 2998            if (clientId != null)
 999            {
 01000                if (_httpRequest.Headers.Contains("X-MSEdge-ClientID"))
 1001                {
 01002                    _httpRequest.Headers.Remove("X-MSEdge-ClientID");
 1003                }
 01004                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientID", clientId);
 1005            }
 21006            if (clientIp != null)
 1007            {
 01008                if (_httpRequest.Headers.Contains("X-MSEdge-ClientIP"))
 1009                {
 01010                    _httpRequest.Headers.Remove("X-MSEdge-ClientIP");
 1011                }
 01012                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientIP", clientIp);
 1013            }
 21014            if (location != null)
 1015            {
 01016                if (_httpRequest.Headers.Contains("X-Search-Location"))
 1017                {
 01018                    _httpRequest.Headers.Remove("X-Search-Location");
 1019                }
 01020                _httpRequest.Headers.TryAddWithoutValidation("X-Search-Location", location);
 1021            }
 1022
 1023
 21024            if (customHeaders != null)
 1025            {
 01026                foreach(var _header in customHeaders)
 1027                {
 01028                    if (_httpRequest.Headers.Contains(_header.Key))
 1029                    {
 01030                        _httpRequest.Headers.Remove(_header.Key);
 1031                    }
 01032                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
 1033                }
 1034            }
 1035
 1036            // Serialize Request
 21037            string _requestContent = null;
 1038            // Set Credentials
 21039            if (Client.Credentials != null)
 1040            {
 21041                cancellationToken.ThrowIfCancellationRequested();
 21042                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 1043            }
 1044            // Send Request
 21045            if (_shouldTrace)
 1046            {
 01047                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
 1048            }
 21049            cancellationToken.ThrowIfCancellationRequested();
 21050            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 21051            if (_shouldTrace)
 1052            {
 01053                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
 1054            }
 21055            HttpStatusCode _statusCode = _httpResponse.StatusCode;
 21056            cancellationToken.ThrowIfCancellationRequested();
 21057            string _responseContent = null;
 21058            if ((int)_statusCode != 200)
 1059            {
 01060                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _st
 1061                try
 1062                {
 01063                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 01064                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_res
 01065                    if (_errorBody != null)
 1066                    {
 01067                        ex.Body = _errorBody;
 1068                    }
 01069                }
 01070                catch (JsonException)
 1071                {
 1072                    // Ignore the exception
 01073                }
 01074                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
 01075                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
 01076                if (_shouldTrace)
 1077                {
 01078                    ServiceClientTracing.Error(_invocationId, ex);
 1079                }
 01080                _httpRequest.Dispose();
 01081                if (_httpResponse != null)
 1082                {
 01083                    _httpResponse.Dispose();
 1084                }
 01085                throw ex;
 1086            }
 1087            // Create Result
 21088            var _result = new HttpOperationResponse<VideoDetails>();
 21089            _result.Request = _httpRequest;
 21090            _result.Response = _httpResponse;
 1091            // Deserialize Response
 21092            if ((int)_statusCode == 200)
 1093            {
 21094                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 1095                try
 1096                {
 21097                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<VideoDetails>(_responseContent, 
 21098                }
 01099                catch (JsonException ex)
 1100                {
 01101                    _httpRequest.Dispose();
 01102                    if (_httpResponse != null)
 1103                    {
 01104                        _httpResponse.Dispose();
 1105                    }
 01106                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
 1107                }
 1108            }
 21109            if (_shouldTrace)
 1110            {
 01111                ServiceClientTracing.Exit(_invocationId, _result);
 1112            }
 21113            return _result;
 21114        }
 1115
 1116        /// <summary>
 1117        /// The Video Trending Search API lets you search on Bing and get back a list
 1118        /// of videos that are trending based on search requests made by others. The
 1119        /// videos are broken out into different categories. For example, Top Music
 1120        /// Videos. For a list of markets that support trending videos, see [Trending
 1121        /// Videos](https://docs.microsoft.com/azure/cognitive-services/bing-video-search/trending-videos).
 1122        /// </summary>
 1123        /// <param name='acceptLanguage'>
 1124        /// A comma-delimited list of one or more languages to use for user interface
 1125        /// strings. The list is in decreasing order of preference. For additional
 1126        /// information, including expected format, see
 1127        /// [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). This
 1128        /// header and the
 1129        /// [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#setlang)
 1130        /// query parameter are mutually exclusive; do not specify both. If you set
 1131        /// this header, you must also specify the
 1132        /// [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#cc)
 1133        /// query parameter. To determine the market to return results for, Bing uses
 1134        /// the first supported language it finds from the list and combines it with
 1135        /// the cc parameter value. If the list does not include a supported language,
 1136        /// Bing finds the closest language and market that supports the request or it
 1137        /// uses an aggregated or default market for the results. To determine the
 1138        /// market that Bing used, see the BingAPIs-Market header. Use this header and
 1139        /// the cc query parameter only if you specify multiple languages. Otherwise,
 1140        /// use the
 1141        /// [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#mkt)
 1142        /// and
 1143        /// [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#setlang)
 1144        /// query parameters. A user interface string is a string that's used as a
 1145        /// label in a user interface. There are few user interface strings in the JSON
 1146        /// response objects. Any links to Bing.com properties in the response objects
 1147        /// apply the specified language.
 1148        /// </param>
 1149        /// <param name='userAgent'>
 1150        /// The user agent originating the request. Bing uses the user agent to provide
 1151        /// mobile users with an optimized experience. Although optional, you are
 1152        /// encouraged to always specify this header. The user-agent should be the same
 1153        /// string that any commonly used browser sends. For information about user
 1154        /// agents, see [RFC
 1155        /// 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The
 1156        /// following are examples of user-agent strings. Windows Phone: Mozilla/5.0
 1157        /// (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM;
 1158        /// Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0 (Linux; U; Android 2.3.5;
 1159        /// en - us; SCH - I500 Build / GINGERBREAD) AppleWebKit / 533.1 (KHTML; like
 1160        /// Gecko) Version / 4.0 Mobile Safari / 533.1. iPhone: Mozilla / 5.0 (iPhone;
 1161        /// CPU iPhone OS 6_1 like Mac OS X) AppleWebKit / 536.26 (KHTML; like Gecko)
 1162        /// Mobile / 10B142 iPhone4; 1 BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0
 1163        /// (Windows NT 6.3; WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad:
 1164        /// Mozilla / 5.0 (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1
 1165        /// (KHTML, like Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53
 1166        /// </param>
 1167        /// <param name='clientId'>
 1168        /// Bing uses this header to provide users with consistent behavior across Bing
 1169        /// API calls. Bing often flights new features and improvements, and it uses
 1170        /// the client ID as a key for assigning traffic on different flights. If you
 1171        /// do not use the same client ID for a user across multiple requests, then
 1172        /// Bing may assign the user to multiple conflicting flights. Being assigned to
 1173        /// multiple conflicting flights can lead to an inconsistent user experience.
 1174        /// For example, if the second request has a different flight assignment than
 1175        /// the first, the experience may be unexpected. Also, Bing can use the client
 1176        /// ID to tailor web results to that client ID’s search history, providing a
 1177        /// richer experience for the user. Bing also uses this header to help improve
 1178        /// result rankings by analyzing the activity generated by a client ID. The
 1179        /// relevance improvements help with better quality of results delivered by
 1180        /// Bing APIs and in turn enables higher click-through rates for the API
 1181        /// consumer. IMPORTANT: Although optional, you should consider this header
 1182        /// required. Persisting the client ID across multiple requests for the same
 1183        /// end user and device combination enables 1) the API consumer to receive a
 1184        /// consistent user experience, and 2) higher click-through rates via better
 1185        /// quality of results from the Bing APIs. Each user that uses your application
 1186        /// on the device must have a unique, Bing generated client ID. If you do not
 1187        /// include this header in the request, Bing generates an ID and returns it in
 1188        /// the X-MSEdge-ClientID response header. The only time that you should NOT
 1189        /// include this header in a request is the first time the user uses your app
 1190        /// on that device. Use the client ID for each Bing API request that your app
 1191        /// makes for this user on the device. Persist the client ID. To persist the ID
 1192        /// in a browser app, use a persistent HTTP cookie to ensure the ID is used
 1193        /// across all sessions. Do not use a session cookie. For other apps such as
 1194        /// mobile apps, use the device's persistent storage to persist the ID. The
 1195        /// next time the user uses your app on that device, get the client ID that you
 1196        /// persisted. Bing responses may or may not include this header. If the
 1197        /// response includes this header, capture the client ID and use it for all
 1198        /// subsequent Bing requests for the user on that device. If you include the
 1199        /// X-MSEdge-ClientID, you must not include cookies in the request.
 1200        /// </param>
 1201        /// <param name='clientIp'>
 1202        /// The IPv4 or IPv6 address of the client device. The IP address is used to
 1203        /// discover the user's location. Bing uses the location information to
 1204        /// determine safe search behavior. Although optional, you are encouraged to
 1205        /// always specify this header and the X-Search-Location header. Do not
 1206        /// obfuscate the address (for example, by changing the last octet to 0).
 1207        /// Obfuscating the address results in the location not being anywhere near the
 1208        /// device's actual location, which may result in Bing serving erroneous
 1209        /// results.
 1210        /// </param>
 1211        /// <param name='location'>
 1212        /// A semicolon-delimited list of key/value pairs that describe the client's
 1213        /// geographical location. Bing uses the location information to determine safe
 1214        /// search behavior and to return relevant local content. Specify the key/value
 1215        /// pair as &lt;key&gt;:&lt;value&gt;. The following are the keys that you use
 1216        /// to specify the user's location. lat (required): The latitude of the
 1217        /// client's location, in degrees. The latitude must be greater than or equal
 1218        /// to -90.0 and less than or equal to +90.0. Negative values indicate southern
 1219        /// latitudes and positive values indicate northern latitudes. long (required):
 1220        /// The longitude of the client's location, in degrees. The longitude must be
 1221        /// greater than or equal to -180.0 and less than or equal to +180.0. Negative
 1222        /// values indicate western longitudes and positive values indicate eastern
 1223        /// longitudes. re (required): The radius, in meters, which specifies the
 1224        /// horizontal accuracy of the coordinates. Pass the value returned by the
 1225        /// device's location service. Typical values might be 22m for GPS/Wi-Fi, 380m
 1226        /// for cell tower triangulation, and 18,000m for reverse IP lookup. ts
 1227        /// (optional): The UTC UNIX timestamp of when the client was at the location.
 1228        /// (The UNIX timestamp is the number of seconds since January 1, 1970.) head
 1229        /// (optional): The client's relative heading or direction of travel. Specify
 1230        /// the direction of travel as degrees from 0 through 360, counting clockwise
 1231        /// relative to true north. Specify this key only if the sp key is nonzero. sp
 1232        /// (optional): The horizontal velocity (speed), in meters per second, that the
 1233        /// client device is traveling. alt (optional): The altitude of the client
 1234        /// device, in meters. are (optional): The radius, in meters, that specifies
 1235        /// the vertical accuracy of the coordinates. Specify this key only if you
 1236        /// specify the alt key. Although many of the keys are optional, the more
 1237        /// information that you provide, the more accurate the location results are.
 1238        /// Although optional, you are encouraged to always specify the user's
 1239        /// geographical location. Providing the location is especially important if
 1240        /// the client's IP address does not accurately reflect the user's physical
 1241        /// location (for example, if the client uses VPN). For optimal results, you
 1242        /// should include this header and the X-MSEdge-ClientIP header, but at a
 1243        /// minimum, you should include this header.
 1244        /// </param>
 1245        /// <param name='countryCode'>
 1246        /// A 2-character country code of the country where the results come from. This
 1247        /// API supports only the United States market. If you specify this query
 1248        /// parameter, it must be set to us. If you set this parameter, you must also
 1249        /// specify the Accept-Language header. Bing uses the first supported language
 1250        /// it finds from the languages list, and combine that language with the
 1251        /// country code that you specify to determine the market to return results
 1252        /// for. If the languages list does not include a supported language, Bing
 1253        /// finds the closest language and market that supports the request, or it may
 1254        /// use an aggregated or default market for the results instead of a specified
 1255        /// one. You should use this query parameter and the Accept-Language query
 1256        /// parameter only if you specify multiple languages; otherwise, you should use
 1257        /// the mkt and setLang query parameters. This parameter and the mkt query
 1258        /// parameter are mutually exclusive—do not specify both.
 1259        /// </param>
 1260        /// <param name='market'>
 1261        /// The market where the results come from. Typically, mkt is the country where
 1262        /// the user is making the request from. However, it could be a different
 1263        /// country if the user is not located in a country where Bing delivers
 1264        /// results. The market must be in the form &lt;language code&gt;-&lt;country
 1265        /// code&gt;. For example, en-US. The string is case insensitive. For a list of
 1266        /// possible market values, see [Market
 1267        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#market-codes)
 1268        /// NOTE: If known, you are encouraged to always specify the market. Specifying
 1269        /// the market helps Bing route the request and return an appropriate and
 1270        /// optimal response. If you specify a market that is not listed in [Market
 1271        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#market-codes)
 1272        /// Bing uses a best fit market code based on an internal mapping that is
 1273        /// subject to change. This parameter and the
 1274        /// [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#cc)
 1275        /// query parameter are mutually exclusive—do not specify both.
 1276        /// </param>
 1277        /// <param name='safeSearch'>
 1278        /// Filter videos for adult content. The following are the possible filter
 1279        /// values. Off: If the request is through the Video Search API, the response
 1280        /// includes adult videos and the thumbnail images of the videos are clear
 1281        /// (non-fuzzy). If the request is through the Web Search API, the response
 1282        /// includes adult videos but the thumbnail images of the videos are pixelated
 1283        /// (fuzzy). Moderate: If the request is through the Video Search API, the
 1284        /// response does not include videos with adult content. If the request is
 1285        /// through the Web Search API, the response may include videos with adult
 1286        /// content but the thumbnail images of the videos are pixelated (fuzzy).
 1287        /// Strict: Does not return videos with adult content. The default is Moderate.
 1288        /// If the request comes from a market that Bing's adult policy requires that
 1289        /// safeSearch is set to Strict, Bing ignores the safeSearch value and uses
 1290        /// Strict. If you use the site: query operator, there is the chance that the
 1291        /// response may contain adult content regardless of what the safeSearch query
 1292        /// parameter is set to. Use site: only if you are aware of the content on the
 1293        /// site and your scenario supports the possibility of adult content. Possible
 1294        /// values include: 'Off', 'Moderate', 'Strict'
 1295        /// </param>
 1296        /// <param name='setLang'>
 1297        /// The language to use for user interface strings. Specify the language using
 1298        /// the ISO 639-1 2-letter language code. For example, the language code for
 1299        /// English is EN. The default is EN (English). Although optional, you should
 1300        /// always specify the language. Typically, you set setLang to the same
 1301        /// language specified by mkt unless the user wants the user interface strings
 1302        /// displayed in a different language. This parameter and the
 1303        /// [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#ac
 1304        /// header are mutually exclusive; do not specify both. A user interface string
 1305        /// is a string that's used as a label in a user interface. There are few user
 1306        /// interface strings in the JSON response objects. Also, any links to Bing.com
 1307        /// properties in the response objects apply the specified language.
 1308        /// </param>
 1309        /// <param name='textDecorations'>
 1310        /// A Boolean value that determines whether display strings contain decoration
 1311        /// markers such as hit highlighting characters. If true, the strings may
 1312        /// include markers. The default is false. To specify whether to use Unicode
 1313        /// characters or HTML tags as the markers, see the
 1314        /// [textFormat](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#textfor
 1315        /// query parameter. For information about hit highlighting, see [Hit
 1316        /// Highlighting](https://docs.microsoft.com/azure/cognitive-services/bing-news-search/hit-highlighting).
 1317        /// </param>
 1318        /// <param name='textFormat'>
 1319        /// The type of markers to use for text decorations (see the textDecorations
 1320        /// query parameter). Possible values are Raw—Use Unicode characters to mark
 1321        /// content that needs special formatting. The Unicode characters are in the
 1322        /// range E000 through E019. For example, Bing uses E000 and E001 to mark the
 1323        /// beginning and end of query terms for hit highlighting. HTML—Use HTML tags
 1324        /// to mark content that needs special formatting. For example, use &lt;b&gt;
 1325        /// tags to highlight query terms in display strings. The default is Raw. For
 1326        /// display strings that contain escapable HTML characters such as &lt;, &gt;,
 1327        /// and &amp;, if textFormat is set to HTML, Bing escapes the characters as
 1328        /// appropriate (for example, &lt; is escaped to &amp;lt;). Possible values
 1329        /// include: 'Raw', 'Html'
 1330        /// </param>
 1331        /// <param name='customHeaders'>
 1332        /// Headers that will be added to request.
 1333        /// </param>
 1334        /// <param name='cancellationToken'>
 1335        /// The cancellation token.
 1336        /// </param>
 1337        /// <exception cref="ErrorResponseException">
 1338        /// Thrown when the operation returned an invalid status code
 1339        /// </exception>
 1340        /// <exception cref="SerializationException">
 1341        /// Thrown when unable to deserialize the response
 1342        /// </exception>
 1343        /// <exception cref="ValidationException">
 1344        /// Thrown when a required parameter is null
 1345        /// </exception>
 1346        /// <exception cref="System.ArgumentNullException">
 1347        /// Thrown when a required parameter is null
 1348        /// </exception>
 1349        /// <return>
 1350        /// A response object containing the response body and response headers.
 1351        /// </return>
 1352        public async Task<HttpOperationResponse<TrendingVideos>> TrendingWithHttpMessagesAsync(string acceptLanguage = d
 1353        {
 21354            if (Client.Endpoint == null)
 1355            {
 01356                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
 1357            }
 21358            string xBingApisSDK = "true";
 1359            // Tracing
 21360            bool _shouldTrace = ServiceClientTracing.IsEnabled;
 21361            string _invocationId = null;
 21362            if (_shouldTrace)
 1363            {
 01364                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
 01365                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
 01366                tracingParameters.Add("xBingApisSDK", xBingApisSDK);
 01367                tracingParameters.Add("acceptLanguage", acceptLanguage);
 01368                tracingParameters.Add("userAgent", userAgent);
 01369                tracingParameters.Add("clientId", clientId);
 01370                tracingParameters.Add("clientIp", clientIp);
 01371                tracingParameters.Add("location", location);
 01372                tracingParameters.Add("countryCode", countryCode);
 01373                tracingParameters.Add("market", market);
 01374                tracingParameters.Add("safeSearch", safeSearch);
 01375                tracingParameters.Add("setLang", setLang);
 01376                tracingParameters.Add("textDecorations", textDecorations);
 01377                tracingParameters.Add("textFormat", textFormat);
 01378                tracingParameters.Add("cancellationToken", cancellationToken);
 01379                ServiceClientTracing.Enter(_invocationId, this, "Trending", tracingParameters);
 1380            }
 1381            // Construct URL
 21382            var _baseUrl = Client.BaseUri;
 21383            var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "videos/trending";
 21384            _url = _url.Replace("{Endpoint}", Client.Endpoint);
 21385            List<string> _queryParameters = new List<string>();
 21386            if (countryCode != null)
 1387            {
 01388                _queryParameters.Add(string.Format("cc={0}", System.Uri.EscapeDataString(countryCode)));
 1389            }
 21390            if (market != null)
 1391            {
 01392                _queryParameters.Add(string.Format("mkt={0}", System.Uri.EscapeDataString(market)));
 1393            }
 21394            if (safeSearch != null)
 1395            {
 01396                _queryParameters.Add(string.Format("safeSearch={0}", System.Uri.EscapeDataString(Rest.Serialization.Safe
 1397            }
 21398            if (setLang != null)
 1399            {
 01400                _queryParameters.Add(string.Format("setLang={0}", System.Uri.EscapeDataString(setLang)));
 1401            }
 21402            if (textDecorations != null)
 1403            {
 01404                _queryParameters.Add(string.Format("textDecorations={0}", System.Uri.EscapeDataString(Rest.Serialization
 1405            }
 21406            if (textFormat != null)
 1407            {
 01408                _queryParameters.Add(string.Format("textFormat={0}", System.Uri.EscapeDataString(Rest.Serialization.Safe
 1409            }
 21410            if (_queryParameters.Count > 0)
 1411            {
 01412                _url += "?" + string.Join("&", _queryParameters);
 1413            }
 1414            // Create HTTP transport objects
 21415            var _httpRequest = new HttpRequestMessage();
 21416            HttpResponseMessage _httpResponse = null;
 21417            _httpRequest.Method = new HttpMethod("GET");
 21418            _httpRequest.RequestUri = new System.Uri(_url);
 1419            // Set Headers
 21420            if (xBingApisSDK != null)
 1421            {
 21422                if (_httpRequest.Headers.Contains("X-BingApis-SDK"))
 1423                {
 01424                    _httpRequest.Headers.Remove("X-BingApis-SDK");
 1425                }
 21426                _httpRequest.Headers.TryAddWithoutValidation("X-BingApis-SDK", xBingApisSDK);
 1427            }
 21428            if (acceptLanguage != null)
 1429            {
 01430                if (_httpRequest.Headers.Contains("Accept-Language"))
 1431                {
 01432                    _httpRequest.Headers.Remove("Accept-Language");
 1433                }
 01434                _httpRequest.Headers.TryAddWithoutValidation("Accept-Language", acceptLanguage);
 1435            }
 21436            if (userAgent != null)
 1437            {
 01438                if (_httpRequest.Headers.Contains("User-Agent"))
 1439                {
 01440                    _httpRequest.Headers.Remove("User-Agent");
 1441                }
 01442                _httpRequest.Headers.TryAddWithoutValidation("User-Agent", userAgent);
 1443            }
 21444            if (clientId != null)
 1445            {
 01446                if (_httpRequest.Headers.Contains("X-MSEdge-ClientID"))
 1447                {
 01448                    _httpRequest.Headers.Remove("X-MSEdge-ClientID");
 1449                }
 01450                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientID", clientId);
 1451            }
 21452            if (clientIp != null)
 1453            {
 01454                if (_httpRequest.Headers.Contains("X-MSEdge-ClientIP"))
 1455                {
 01456                    _httpRequest.Headers.Remove("X-MSEdge-ClientIP");
 1457                }
 01458                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientIP", clientIp);
 1459            }
 21460            if (location != null)
 1461            {
 01462                if (_httpRequest.Headers.Contains("X-Search-Location"))
 1463                {
 01464                    _httpRequest.Headers.Remove("X-Search-Location");
 1465                }
 01466                _httpRequest.Headers.TryAddWithoutValidation("X-Search-Location", location);
 1467            }
 1468
 1469
 21470            if (customHeaders != null)
 1471            {
 01472                foreach(var _header in customHeaders)
 1473                {
 01474                    if (_httpRequest.Headers.Contains(_header.Key))
 1475                    {
 01476                        _httpRequest.Headers.Remove(_header.Key);
 1477                    }
 01478                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
 1479                }
 1480            }
 1481
 1482            // Serialize Request
 21483            string _requestContent = null;
 1484            // Set Credentials
 21485            if (Client.Credentials != null)
 1486            {
 21487                cancellationToken.ThrowIfCancellationRequested();
 21488                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 1489            }
 1490            // Send Request
 21491            if (_shouldTrace)
 1492            {
 01493                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
 1494            }
 21495            cancellationToken.ThrowIfCancellationRequested();
 21496            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 21497            if (_shouldTrace)
 1498            {
 01499                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
 1500            }
 21501            HttpStatusCode _statusCode = _httpResponse.StatusCode;
 21502            cancellationToken.ThrowIfCancellationRequested();
 21503            string _responseContent = null;
 21504            if ((int)_statusCode != 200)
 1505            {
 01506                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _st
 1507                try
 1508                {
 01509                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 01510                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_res
 01511                    if (_errorBody != null)
 1512                    {
 01513                        ex.Body = _errorBody;
 1514                    }
 01515                }
 01516                catch (JsonException)
 1517                {
 1518                    // Ignore the exception
 01519                }
 01520                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
 01521                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
 01522                if (_shouldTrace)
 1523                {
 01524                    ServiceClientTracing.Error(_invocationId, ex);
 1525                }
 01526                _httpRequest.Dispose();
 01527                if (_httpResponse != null)
 1528                {
 01529                    _httpResponse.Dispose();
 1530                }
 01531                throw ex;
 1532            }
 1533            // Create Result
 21534            var _result = new HttpOperationResponse<TrendingVideos>();
 21535            _result.Request = _httpRequest;
 21536            _result.Response = _httpResponse;
 1537            // Deserialize Response
 21538            if ((int)_statusCode == 200)
 1539            {
 21540                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 1541                try
 1542                {
 21543                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<TrendingVideos>(_responseContent
 21544                }
 01545                catch (JsonException ex)
 1546                {
 01547                    _httpRequest.Dispose();
 01548                    if (_httpResponse != null)
 1549                    {
 01550                        _httpResponse.Dispose();
 1551                    }
 01552                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
 1553                }
 1554            }
 21555            if (_shouldTrace)
 1556            {
 01557                ServiceClientTracing.Exit(_invocationId, _result);
 1558            }
 21559            return _result;
 21560        }
 1561
 1562    }
 1563}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:47:14 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
get_Client()
SearchWithHttpMessagesAsync()
DetailsWithHttpMessagesAsync()
TrendingWithHttpMessagesAsync()