< Summary

Class:Microsoft.Azure.CognitiveServices.Search.CustomImageSearch.CustomInstance
Assembly:Microsoft.Azure.CognitiveServices.Search.BingCustomImageSearch
File(s):C:\Git\azure-sdk-for-net\sdk\cognitiveservices\Search.BingCustomImageSearch\src\Generated\CustomImageSearch\CustomInstance.cs
Covered lines:79
Uncovered lines:104
Coverable lines:183
Total lines:737
Line coverage:43.1% (79 of 183)
Covered branches:51
Total branches:112
Branch coverage:45.5% (51 of 112)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-80%50%
get_Client()-100%100%
ImageSearchWithHttpMessagesAsync()-41.81%45.45%

File(s)

C:\Git\azure-sdk-for-net\sdk\cognitiveservices\Search.BingCustomImageSearch\src\Generated\CustomImageSearch\CustomInstance.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.CustomImageSearch
 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    /// CustomInstance operations.
 23    /// </summary>
 24    public partial class CustomInstance : IServiceOperations<CustomImageSearchClient>, ICustomInstance
 25    {
 26        /// <summary>
 27        /// Initializes a new instance of the CustomInstance class.
 28        /// </summary>
 29        /// <param name='client'>
 30        /// Reference to the service client.
 31        /// </param>
 32        /// <exception cref="System.ArgumentNullException">
 33        /// Thrown when a required parameter is null
 34        /// </exception>
 235        public CustomInstance(CustomImageSearchClient client)
 36        {
 237            if (client == null)
 38            {
 039                throw new System.ArgumentNullException("client");
 40            }
 241            Client = client;
 242        }
 43
 44        /// <summary>
 45        /// Gets a reference to the CustomImageSearchClient
 46        /// </summary>
 1647        public CustomImageSearchClient Client { get; private set; }
 48
 49        /// <summary>
 50        /// The Custom Image Search API lets you send an image search query to Bing and
 51        /// get image results found in your custom view of the web.
 52        /// </summary>
 53        /// <param name='customConfig'>
 54        /// The identifier for the custom search configuration
 55        /// </param>
 56        /// <param name='query'>
 57        /// The user's search query term. The term cannot be empty. The term may
 58        /// contain [Bing Advanced
 59        /// Operators](http://msdn.microsoft.com/library/ff795620.aspx). For example,
 60        /// to limit images to a specific domain, use the
 61        /// [site:](http://msdn.microsoft.com/library/ff795613.aspx) operator. To help
 62        /// improve relevance of an insights query (see
 63        /// [insightsToken](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#ins
 64        /// you should always include the user's query term. Use this parameter only
 65        /// with the Image Search API.Do not specify this parameter when calling the
 66        /// Trending Images API.
 67        /// </param>
 68        /// <param name='acceptLanguage'>
 69        /// A comma-delimited list of one or more languages to use for user interface
 70        /// strings. The list is in decreasing order of preference. For additional
 71        /// information, including expected format, see
 72        /// [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). This
 73        /// header and the
 74        /// [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#setlang)
 75        /// query parameter are mutually exclusive; do not specify both. If you set
 76        /// this header, you must also specify the
 77        /// [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#cc)
 78        /// query parameter. To determine the market to return results for, Bing uses
 79        /// the first supported language it finds from the list and combines it with
 80        /// the cc parameter value. If the list does not include a supported language,
 81        /// Bing finds the closest language and market that supports the request or it
 82        /// uses an aggregated or default market for the results. To determine the
 83        /// market that Bing used, see the BingAPIs-Market header. Use this header and
 84        /// the cc query parameter only if you specify multiple languages. Otherwise,
 85        /// use the
 86        /// [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#mkt)
 87        /// and
 88        /// [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#setlang)
 89        /// query parameters. A user interface string is a string that's used as a
 90        /// label in a user interface. There are few user interface strings in the JSON
 91        /// response objects. Any links to Bing.com properties in the response objects
 92        /// apply the specified language.
 93        /// </param>
 94        /// <param name='userAgent'>
 95        /// The user agent originating the request. Bing uses the user agent to provide
 96        /// mobile users with an optimized experience. Although optional, you are
 97        /// encouraged to always specify this header. The user-agent should be the same
 98        /// string that any commonly used browser sends. For information about user
 99        /// agents, see [RFC
 100        /// 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The
 101        /// following are examples of user-agent strings. Windows Phone: Mozilla/5.0
 102        /// (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM;
 103        /// Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0 (Linux; U; Android 2.3.5;
 104        /// en - us; SCH - I500 Build / GINGERBREAD) AppleWebKit / 533.1 (KHTML; like
 105        /// Gecko) Version / 4.0 Mobile Safari / 533.1. iPhone: Mozilla / 5.0 (iPhone;
 106        /// CPU iPhone OS 6_1 like Mac OS X) AppleWebKit / 536.26 (KHTML; like Gecko)
 107        /// Mobile / 10B142 iPhone4; 1 BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0
 108        /// (Windows NT 6.3; WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad:
 109        /// Mozilla / 5.0 (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1
 110        /// (KHTML, like Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53
 111        /// </param>
 112        /// <param name='clientId'>
 113        /// Bing uses this header to provide users with consistent behavior across Bing
 114        /// API calls. Bing often flights new features and improvements, and it uses
 115        /// the client ID as a key for assigning traffic on different flights. If you
 116        /// do not use the same client ID for a user across multiple requests, then
 117        /// Bing may assign the user to multiple conflicting flights. Being assigned to
 118        /// multiple conflicting flights can lead to an inconsistent user experience.
 119        /// For example, if the second request has a different flight assignment than
 120        /// the first, the experience may be unexpected. Also, Bing can use the client
 121        /// ID to tailor web results to that client ID’s search history, providing a
 122        /// richer experience for the user. Bing also uses this header to help improve
 123        /// result rankings by analyzing the activity generated by a client ID. The
 124        /// relevance improvements help with better quality of results delivered by
 125        /// Bing APIs and in turn enables higher click-through rates for the API
 126        /// consumer. IMPORTANT: Although optional, you should consider this header
 127        /// required. Persisting the client ID across multiple requests for the same
 128        /// end user and device combination enables 1) the API consumer to receive a
 129        /// consistent user experience, and 2) higher click-through rates via better
 130        /// quality of results from the Bing APIs. Each user that uses your application
 131        /// on the device must have a unique, Bing generated client ID. If you do not
 132        /// include this header in the request, Bing generates an ID and returns it in
 133        /// the X-MSEdge-ClientID response header. The only time that you should NOT
 134        /// include this header in a request is the first time the user uses your app
 135        /// on that device. Use the client ID for each Bing API request that your app
 136        /// makes for this user on the device. Persist the client ID. To persist the ID
 137        /// in a browser app, use a persistent HTTP cookie to ensure the ID is used
 138        /// across all sessions. Do not use a session cookie. For other apps such as
 139        /// mobile apps, use the device's persistent storage to persist the ID. The
 140        /// next time the user uses your app on that device, get the client ID that you
 141        /// persisted. Bing responses may or may not include this header. If the
 142        /// response includes this header, capture the client ID and use it for all
 143        /// subsequent Bing requests for the user on that device. If you include the
 144        /// X-MSEdge-ClientID, you must not include cookies in the request.
 145        /// </param>
 146        /// <param name='clientIp'>
 147        /// The IPv4 or IPv6 address of the client device. The IP address is used to
 148        /// discover the user's location. Bing uses the location information to
 149        /// determine safe search behavior. Although optional, you are encouraged to
 150        /// always specify this header and the X-Search-Location header. Do not
 151        /// obfuscate the address (for example, by changing the last octet to 0).
 152        /// Obfuscating the address results in the location not being anywhere near the
 153        /// device's actual location, which may result in Bing serving erroneous
 154        /// results.
 155        /// </param>
 156        /// <param name='location'>
 157        /// A semicolon-delimited list of key/value pairs that describe the client's
 158        /// geographical location. Bing uses the location information to determine safe
 159        /// search behavior and to return relevant local content. Specify the key/value
 160        /// pair as &lt;key&gt;:&lt;value&gt;. The following are the keys that you use
 161        /// to specify the user's location. lat (required): The latitude of the
 162        /// client's location, in degrees. The latitude must be greater than or equal
 163        /// to -90.0 and less than or equal to +90.0. Negative values indicate southern
 164        /// latitudes and positive values indicate northern latitudes. long (required):
 165        /// The longitude of the client's location, in degrees. The longitude must be
 166        /// greater than or equal to -180.0 and less than or equal to +180.0. Negative
 167        /// values indicate western longitudes and positive values indicate eastern
 168        /// longitudes. re (required): The radius, in meters, which specifies the
 169        /// horizontal accuracy of the coordinates. Pass the value returned by the
 170        /// device's location service. Typical values might be 22m for GPS/Wi-Fi, 380m
 171        /// for cell tower triangulation, and 18,000m for reverse IP lookup. ts
 172        /// (optional): The UTC UNIX timestamp of when the client was at the location.
 173        /// (The UNIX timestamp is the number of seconds since January 1, 1970.) head
 174        /// (optional): The client's relative heading or direction of travel. Specify
 175        /// the direction of travel as degrees from 0 through 360, counting clockwise
 176        /// relative to true north. Specify this key only if the sp key is nonzero. sp
 177        /// (optional): The horizontal velocity (speed), in meters per second, that the
 178        /// client device is traveling. alt (optional): The altitude of the client
 179        /// device, in meters. are (optional): The radius, in meters, that specifies
 180        /// the vertical accuracy of the coordinates. Specify this key only if you
 181        /// specify the alt key. Although many of the keys are optional, the more
 182        /// information that you provide, the more accurate the location results are.
 183        /// Although optional, you are encouraged to always specify the user's
 184        /// geographical location. Providing the location is especially important if
 185        /// the client's IP address does not accurately reflect the user's physical
 186        /// location (for example, if the client uses VPN). For optimal results, you
 187        /// should include this header and the X-MSEdge-ClientIP header, but at a
 188        /// minimum, you should include this header.
 189        /// </param>
 190        /// <param name='aspect'>
 191        /// Filter images by the following aspect ratios. All: Do not filter by
 192        /// aspect.Specifying this value is the same as not specifying the aspect
 193        /// parameter. Square: Return images with standard aspect ratio. Wide: Return
 194        /// images with wide screen aspect ratio. Tall: Return images with tall aspect
 195        /// ratio. Possible values include: 'All', 'Square', 'Wide', 'Tall'
 196        /// </param>
 197        /// <param name='color'>
 198        /// Filter images by the following color options. ColorOnly: Return color
 199        /// images. Monochrome: Return black and white images. Return images with one
 200        /// of the following dominant colors: Black, Blue, Brown, Gray, Green, Orange,
 201        /// Pink, Purple, Red, Teal, White, Yellow. Possible values include:
 202        /// 'ColorOnly', 'Monochrome', 'Black', 'Blue', 'Brown', 'Gray', 'Green',
 203        /// 'Orange', 'Pink', 'Purple', 'Red', 'Teal', 'White', 'Yellow'
 204        /// </param>
 205        /// <param name='countryCode'>
 206        /// A 2-character country code of the country where the results come from. For
 207        /// a list of possible values, see [Market
 208        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes
 209        /// If you set this parameter, you must also specify the
 210        /// [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#a
 211        /// header. Bing uses the first supported language it finds from the languages
 212        /// list, and combine that language with the country code that you specify to
 213        /// determine the market to return results for. If the languages list does not
 214        /// include a supported language, Bing finds the closest language and market
 215        /// that supports the request, or it may use an aggregated or default market
 216        /// for the results instead of a specified one. You should use this query
 217        /// parameter and the Accept-Language query parameter only if you specify
 218        /// multiple languages; otherwise, you should use the mkt and setLang query
 219        /// parameters. This parameter and the
 220        /// [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#mkt)
 221        /// query parameter are mutually exclusive—do not specify both.
 222        /// </param>
 223        /// <param name='count'>
 224        /// The number of images to return in the response. The actual number delivered
 225        /// may be less than requested. The default is 35. The maximum value is 150.
 226        /// You use this parameter along with the offset parameter to page results.For
 227        /// example, if your user interface displays 20 images per page, set count to
 228        /// 20 and offset to 0 to get the first page of results.For each subsequent
 229        /// page, increment offset by 20 (for example, 0, 20, 40). Use this parameter
 230        /// only with the Image Search API.Do not specify this parameter when calling
 231        /// the Insights, Trending Images, or Web Search APIs.
 232        /// </param>
 233        /// <param name='freshness'>
 234        /// Filter images by the following discovery options. Day: Return images
 235        /// discovered by Bing within the last 24 hours. Week: Return images discovered
 236        /// by Bing within the last 7 days. Month: Return images discovered by Bing
 237        /// within the last 30 days. Possible values include: 'Day', 'Week', 'Month'
 238        /// </param>
 239        /// <param name='height'>
 240        /// Filter images that have the specified height, in pixels. You may use this
 241        /// filter with the size filter to return small images that have a height of
 242        /// 150 pixels.
 243        /// </param>
 244        /// <param name='id'>
 245        /// An ID that uniquely identifies an image. Use this parameter to ensure that
 246        /// the specified image is the first image in the list of images that Bing
 247        /// returns. The
 248        /// [Image](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#image)
 249        /// object's imageId field contains the ID that you set this parameter to.
 250        /// </param>
 251        /// <param name='imageContent'>
 252        /// Filter images by the following content types. Face: Return images that show
 253        /// only a person's face. Portrait: Return images that show only a person's
 254        /// head and shoulders. Possible values include: 'Face', 'Portrait'
 255        /// </param>
 256        /// <param name='imageType'>
 257        /// Filter images by the following image types. AnimatedGif: Return only
 258        /// animated GIFs. Clipart: Return only clip art images. Line: Return only line
 259        /// drawings. Photo: Return only photographs(excluding line drawings, animated
 260        /// Gifs, and clip art). Shopping: Return only images that contain items where
 261        /// Bing knows of a merchant that is selling the items. This option is valid in
 262        /// the en - US market only.Transparent: Return only images with a transparent
 263        /// background. Possible values include: 'AnimatedGif', 'Clipart', 'Line',
 264        /// 'Photo', 'Shopping', 'Transparent'
 265        /// </param>
 266        /// <param name='license'>
 267        /// Filter images by the following license types. All: Do not filter by license
 268        /// type.Specifying this value is the same as not specifying the license
 269        /// parameter. Any: Return images that are under any license type. The response
 270        /// doesn't include images that do not specify a license or the license is
 271        /// unknown. Public: Return images where the creator has waived their exclusive
 272        /// rights, to the fullest extent allowed by law. Share: Return images that may
 273        /// be shared with others. Changing or editing the image might not be allowed.
 274        /// Also, modifying, sharing, and using the image for commercial purposes might
 275        /// not be allowed. Typically, this option returns the most images.
 276        /// ShareCommercially: Return images that may be shared with others for
 277        /// personal or commercial purposes. Changing or editing the image might not be
 278        /// allowed. Modify: Return images that may be modified, shared, and used.
 279        /// Changing or editing the image might not be allowed. Modifying, sharing, and
 280        /// using the image for commercial purposes might not be allowed.
 281        /// ModifyCommercially: Return images that may be modified, shared, and used
 282        /// for personal or commercial purposes. Typically, this option returns the
 283        /// fewest images. For more information about these license types, see [Filter
 284        /// Images By License Type](http://go.microsoft.com/fwlink/?LinkId=309768).
 285        /// Possible values include: 'All', 'Any', 'Public', 'Share',
 286        /// 'ShareCommercially', 'Modify', 'ModifyCommercially'
 287        /// </param>
 288        /// <param name='market'>
 289        /// The market where the results come from. Typically, mkt is the country where
 290        /// the user is making the request from. However, it could be a different
 291        /// country if the user is not located in a country where Bing delivers
 292        /// results. The market must be in the form &lt;language code&gt;-&lt;country
 293        /// code&gt;. For example, en-US. The string is case insensitive. For a list of
 294        /// possible market values, see [Market
 295        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes
 296        /// NOTE: If known, you are encouraged to always specify the market. Specifying
 297        /// the market helps Bing route the request and return an appropriate and
 298        /// optimal response. If you specify a market that is not listed in [Market
 299        /// Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes
 300        /// Bing uses a best fit market code based on an internal mapping that is
 301        /// subject to change. This parameter and the
 302        /// [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#cc)
 303        /// query parameter are mutually exclusive—do not specify both.
 304        /// </param>
 305        /// <param name='maxFileSize'>
 306        /// Filter images that are less than or equal to the specified file size. The
 307        /// maximum file size that you may specify is 520,192 bytes. If you specify a
 308        /// larger value, the API uses 520,192. It is possible that the response may
 309        /// include images that are slightly larger than the specified maximum. You may
 310        /// specify this filter and minFileSize to filter images within a range of file
 311        /// sizes.
 312        /// </param>
 313        /// <param name='maxHeight'>
 314        /// Filter images that have a height that is less than or equal to the
 315        /// specified height. Specify the height in pixels. You may specify this filter
 316        /// and minHeight to filter images within a range of heights. This filter and
 317        /// the height filter are mutually exclusive.
 318        /// </param>
 319        /// <param name='maxWidth'>
 320        /// Filter images that have a width that is less than or equal to the specified
 321        /// width. Specify the width in pixels. You may specify this filter and
 322        /// maxWidth to filter images within a range of widths. This filter and the
 323        /// width filter are mutually exclusive.
 324        /// </param>
 325        /// <param name='minFileSize'>
 326        /// Filter images that are greater than or equal to the specified file size.
 327        /// The maximum file size that you may specify is 520,192 bytes. If you specify
 328        /// a larger value, the API uses 520,192. It is possible that the response may
 329        /// include images that are slightly smaller than the specified minimum. You
 330        /// may specify this filter and maxFileSize to filter images within a range of
 331        /// file sizes.
 332        /// </param>
 333        /// <param name='minHeight'>
 334        /// Filter images that have a height that is greater than or equal to the
 335        /// specified height. Specify the height in pixels. You may specify this filter
 336        /// and maxHeight to filter images within a range of heights. This filter and
 337        /// the height filter are mutually exclusive.
 338        /// </param>
 339        /// <param name='minWidth'>
 340        /// Filter images that have a width that is greater than or equal to the
 341        /// specified width. Specify the width in pixels. You may specify this filter
 342        /// and maxWidth to filter images within a range of widths. This filter and the
 343        /// width filter are mutually exclusive.
 344        /// </param>
 345        /// <param name='offset'>
 346        /// The zero-based offset that indicates the number of images to skip before
 347        /// returning images. The default is 0. The offset should be less than
 348        /// ([totalEstimatedMatches](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-refe
 349        /// - count). Use this parameter along with the count parameter to page
 350        /// results. For example, if your user interface displays 20 images per page,
 351        /// set count to 20 and offset to 0 to get the first page of results. For each
 352        /// subsequent page, increment offset by 20 (for example, 0, 20, 40). It is
 353        /// possible for multiple pages to include some overlap in results. To prevent
 354        /// duplicates, see
 355        /// [nextOffset](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#nextof
 356        /// Use this parameter only with the Image API. Do not specify this parameter
 357        /// when calling the Trending Images API or the Web Search API.
 358        /// </param>
 359        /// <param name='safeSearch'>
 360        /// Filter images for adult content. The following are the possible filter
 361        /// values. Off: May return images with adult content. If the request is
 362        /// through the Image Search API, the response includes thumbnail images that
 363        /// are clear (non-fuzzy). However, if the request is through the Web Search
 364        /// API, the response includes thumbnail images that are pixelated (fuzzy).
 365        /// Moderate: If the request is through the Image Search API, the response
 366        /// doesn't include images with adult content. If the request is through the
 367        /// Web Search API, the response may include images with adult content (the
 368        /// thumbnail images are pixelated (fuzzy)). Strict: Do not return images with
 369        /// adult content. The default is Moderate. If the request comes from a market
 370        /// that Bing's adult policy requires that safeSearch is set to Strict, Bing
 371        /// ignores the safeSearch value and uses Strict. If you use the site: query
 372        /// operator, there is the chance that the response may contain adult content
 373        /// regardless of what the safeSearch query parameter is set to. Use site: only
 374        /// if you are aware of the content on the site and your scenario supports the
 375        /// possibility of adult content. Possible values include: 'Off', 'Moderate',
 376        /// 'Strict'
 377        /// </param>
 378        /// <param name='size'>
 379        /// Filter images by the following sizes. All: Do not filter by size.
 380        /// Specifying this value is the same as not specifying the size parameter.
 381        /// Small: Return images that are less than 200x200 pixels. Medium: Return
 382        /// images that are greater than or equal to 200x200 pixels but less than
 383        /// 500x500 pixels. Large: Return images that are 500x500 pixels or larger.
 384        /// Wallpaper: Return wallpaper images. You may use this parameter along with
 385        /// the height or width parameters. For example, you may use height and size to
 386        /// request small images that are 150 pixels tall. Possible values include:
 387        /// 'All', 'Small', 'Medium', 'Large', 'Wallpaper'
 388        /// </param>
 389        /// <param name='setLang'>
 390        /// The language to use for user interface strings. Specify the language using
 391        /// the ISO 639-1 2-letter language code. For example, the language code for
 392        /// English is EN. The default is EN (English). Although optional, you should
 393        /// always specify the language. Typically, you set setLang to the same
 394        /// language specified by mkt unless the user wants the user interface strings
 395        /// displayed in a different language. This parameter and the
 396        /// [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#a
 397        /// header are mutually exclusive; do not specify both. A user interface string
 398        /// is a string that's used as a label in a user interface. There are few user
 399        /// interface strings in the JSON response objects. Also, any links to Bing.com
 400        /// properties in the response objects apply the specified language.
 401        /// </param>
 402        /// <param name='width'>
 403        /// Filter images that have the specified width, in pixels. You may use this
 404        /// filter with the size filter to return small images that have a width of 150
 405        /// pixels.
 406        /// </param>
 407        /// <param name='customHeaders'>
 408        /// Headers that will be added to request.
 409        /// </param>
 410        /// <param name='cancellationToken'>
 411        /// The cancellation token.
 412        /// </param>
 413        /// <exception cref="ErrorResponseException">
 414        /// Thrown when the operation returned an invalid status code
 415        /// </exception>
 416        /// <exception cref="SerializationException">
 417        /// Thrown when unable to deserialize the response
 418        /// </exception>
 419        /// <exception cref="ValidationException">
 420        /// Thrown when a required parameter is null
 421        /// </exception>
 422        /// <exception cref="System.ArgumentNullException">
 423        /// Thrown when a required parameter is null
 424        /// </exception>
 425        /// <return>
 426        /// A response object containing the response body and response headers.
 427        /// </return>
 428        public async Task<HttpOperationResponse<Images>> ImageSearchWithHttpMessagesAsync(string customConfig, string qu
 429        {
 2430            if (Client.Endpoint == null)
 431            {
 0432                throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
 433            }
 2434            if (customConfig == null)
 435            {
 0436                throw new ValidationException(ValidationRules.CannotBeNull, "customConfig");
 437            }
 2438            if (query == null)
 439            {
 0440                throw new ValidationException(ValidationRules.CannotBeNull, "query");
 441            }
 2442            string xBingApisSDK = "true";
 443            // Tracing
 2444            bool _shouldTrace = ServiceClientTracing.IsEnabled;
 2445            string _invocationId = null;
 2446            if (_shouldTrace)
 447            {
 0448                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
 0449                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
 0450                tracingParameters.Add("xBingApisSDK", xBingApisSDK);
 0451                tracingParameters.Add("acceptLanguage", acceptLanguage);
 0452                tracingParameters.Add("userAgent", userAgent);
 0453                tracingParameters.Add("clientId", clientId);
 0454                tracingParameters.Add("clientIp", clientIp);
 0455                tracingParameters.Add("location", location);
 0456                tracingParameters.Add("customConfig", customConfig);
 0457                tracingParameters.Add("aspect", aspect);
 0458                tracingParameters.Add("color", color);
 0459                tracingParameters.Add("countryCode", countryCode);
 0460                tracingParameters.Add("count", count);
 0461                tracingParameters.Add("freshness", freshness);
 0462                tracingParameters.Add("height", height);
 0463                tracingParameters.Add("id", id);
 0464                tracingParameters.Add("imageContent", imageContent);
 0465                tracingParameters.Add("imageType", imageType);
 0466                tracingParameters.Add("license", license);
 0467                tracingParameters.Add("market", market);
 0468                tracingParameters.Add("maxFileSize", maxFileSize);
 0469                tracingParameters.Add("maxHeight", maxHeight);
 0470                tracingParameters.Add("maxWidth", maxWidth);
 0471                tracingParameters.Add("minFileSize", minFileSize);
 0472                tracingParameters.Add("minHeight", minHeight);
 0473                tracingParameters.Add("minWidth", minWidth);
 0474                tracingParameters.Add("offset", offset);
 0475                tracingParameters.Add("query", query);
 0476                tracingParameters.Add("safeSearch", safeSearch);
 0477                tracingParameters.Add("size", size);
 0478                tracingParameters.Add("setLang", setLang);
 0479                tracingParameters.Add("width", width);
 0480                tracingParameters.Add("cancellationToken", cancellationToken);
 0481                ServiceClientTracing.Enter(_invocationId, this, "ImageSearch", tracingParameters);
 482            }
 483            // Construct URL
 2484            var _baseUrl = Client.BaseUri;
 2485            var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "images/search";
 2486            _url = _url.Replace("{Endpoint}", Client.Endpoint);
 2487            List<string> _queryParameters = new List<string>();
 2488            if (customConfig != null)
 489            {
 2490                _queryParameters.Add(string.Format("customConfig={0}", System.Uri.EscapeDataString(customConfig)));
 491            }
 2492            if (aspect != null)
 493            {
 0494                _queryParameters.Add(string.Format("aspect={0}", System.Uri.EscapeDataString(aspect)));
 495            }
 2496            if (color != null)
 497            {
 0498                _queryParameters.Add(string.Format("color={0}", System.Uri.EscapeDataString(color)));
 499            }
 2500            if (countryCode != null)
 501            {
 0502                _queryParameters.Add(string.Format("cc={0}", System.Uri.EscapeDataString(countryCode)));
 503            }
 2504            if (count != null)
 505            {
 0506                _queryParameters.Add(string.Format("count={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonC
 507            }
 2508            if (freshness != null)
 509            {
 0510                _queryParameters.Add(string.Format("freshness={0}", System.Uri.EscapeDataString(freshness)));
 511            }
 2512            if (height != null)
 513            {
 0514                _queryParameters.Add(string.Format("height={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJson
 515            }
 2516            if (id != null)
 517            {
 0518                _queryParameters.Add(string.Format("id={0}", System.Uri.EscapeDataString(id)));
 519            }
 2520            if (imageContent != null)
 521            {
 0522                _queryParameters.Add(string.Format("imageContent={0}", System.Uri.EscapeDataString(imageContent)));
 523            }
 2524            if (imageType != null)
 525            {
 0526                _queryParameters.Add(string.Format("imageType={0}", System.Uri.EscapeDataString(imageType)));
 527            }
 2528            if (license != null)
 529            {
 0530                _queryParameters.Add(string.Format("license={0}", System.Uri.EscapeDataString(license)));
 531            }
 2532            if (market != null)
 533            {
 0534                _queryParameters.Add(string.Format("mkt={0}", System.Uri.EscapeDataString(market)));
 535            }
 2536            if (maxFileSize != null)
 537            {
 0538                _queryParameters.Add(string.Format("maxFileSize={0}", System.Uri.EscapeDataString(Rest.Serialization.Saf
 539            }
 2540            if (maxHeight != null)
 541            {
 0542                _queryParameters.Add(string.Format("maxHeight={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJ
 543            }
 2544            if (maxWidth != null)
 545            {
 0546                _queryParameters.Add(string.Format("maxWidth={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJs
 547            }
 2548            if (minFileSize != null)
 549            {
 0550                _queryParameters.Add(string.Format("minFileSize={0}", System.Uri.EscapeDataString(Rest.Serialization.Saf
 551            }
 2552            if (minHeight != null)
 553            {
 0554                _queryParameters.Add(string.Format("minHeight={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJ
 555            }
 2556            if (minWidth != null)
 557            {
 0558                _queryParameters.Add(string.Format("minWidth={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJs
 559            }
 2560            if (offset != null)
 561            {
 0562                _queryParameters.Add(string.Format("offset={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJson
 563            }
 2564            if (query != null)
 565            {
 2566                _queryParameters.Add(string.Format("q={0}", System.Uri.EscapeDataString(query)));
 567            }
 2568            if (safeSearch != null)
 569            {
 0570                _queryParameters.Add(string.Format("safeSearch={0}", System.Uri.EscapeDataString(safeSearch)));
 571            }
 2572            if (size != null)
 573            {
 0574                _queryParameters.Add(string.Format("size={0}", System.Uri.EscapeDataString(size)));
 575            }
 2576            if (setLang != null)
 577            {
 0578                _queryParameters.Add(string.Format("setLang={0}", System.Uri.EscapeDataString(setLang)));
 579            }
 2580            if (width != null)
 581            {
 0582                _queryParameters.Add(string.Format("width={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonC
 583            }
 2584            if (_queryParameters.Count > 0)
 585            {
 2586                _url += "?" + string.Join("&", _queryParameters);
 587            }
 588            // Create HTTP transport objects
 2589            var _httpRequest = new HttpRequestMessage();
 2590            HttpResponseMessage _httpResponse = null;
 2591            _httpRequest.Method = new HttpMethod("GET");
 2592            _httpRequest.RequestUri = new System.Uri(_url);
 593            // Set Headers
 2594            if (xBingApisSDK != null)
 595            {
 2596                if (_httpRequest.Headers.Contains("X-BingApis-SDK"))
 597                {
 0598                    _httpRequest.Headers.Remove("X-BingApis-SDK");
 599                }
 2600                _httpRequest.Headers.TryAddWithoutValidation("X-BingApis-SDK", xBingApisSDK);
 601            }
 2602            if (acceptLanguage != null)
 603            {
 0604                if (_httpRequest.Headers.Contains("Accept-Language"))
 605                {
 0606                    _httpRequest.Headers.Remove("Accept-Language");
 607                }
 0608                _httpRequest.Headers.TryAddWithoutValidation("Accept-Language", acceptLanguage);
 609            }
 2610            if (userAgent != null)
 611            {
 0612                if (_httpRequest.Headers.Contains("User-Agent"))
 613                {
 0614                    _httpRequest.Headers.Remove("User-Agent");
 615                }
 0616                _httpRequest.Headers.TryAddWithoutValidation("User-Agent", userAgent);
 617            }
 2618            if (clientId != null)
 619            {
 0620                if (_httpRequest.Headers.Contains("X-MSEdge-ClientID"))
 621                {
 0622                    _httpRequest.Headers.Remove("X-MSEdge-ClientID");
 623                }
 0624                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientID", clientId);
 625            }
 2626            if (clientIp != null)
 627            {
 0628                if (_httpRequest.Headers.Contains("X-MSEdge-ClientIP"))
 629                {
 0630                    _httpRequest.Headers.Remove("X-MSEdge-ClientIP");
 631                }
 0632                _httpRequest.Headers.TryAddWithoutValidation("X-MSEdge-ClientIP", clientIp);
 633            }
 2634            if (location != null)
 635            {
 0636                if (_httpRequest.Headers.Contains("X-Search-Location"))
 637                {
 0638                    _httpRequest.Headers.Remove("X-Search-Location");
 639                }
 0640                _httpRequest.Headers.TryAddWithoutValidation("X-Search-Location", location);
 641            }
 642
 643
 2644            if (customHeaders != null)
 645            {
 0646                foreach(var _header in customHeaders)
 647                {
 0648                    if (_httpRequest.Headers.Contains(_header.Key))
 649                    {
 0650                        _httpRequest.Headers.Remove(_header.Key);
 651                    }
 0652                    _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
 653                }
 654            }
 655
 656            // Serialize Request
 2657            string _requestContent = null;
 658            // Set Credentials
 2659            if (Client.Credentials != null)
 660            {
 2661                cancellationToken.ThrowIfCancellationRequested();
 2662                await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 663            }
 664            // Send Request
 2665            if (_shouldTrace)
 666            {
 0667                ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
 668            }
 2669            cancellationToken.ThrowIfCancellationRequested();
 2670            _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
 2671            if (_shouldTrace)
 672            {
 0673                ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
 674            }
 2675            HttpStatusCode _statusCode = _httpResponse.StatusCode;
 2676            cancellationToken.ThrowIfCancellationRequested();
 2677            string _responseContent = null;
 2678            if ((int)_statusCode != 200)
 679            {
 0680                var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _st
 681                try
 682                {
 0683                    _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 0684                    ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_res
 0685                    if (_errorBody != null)
 686                    {
 0687                        ex.Body = _errorBody;
 688                    }
 0689                }
 0690                catch (JsonException)
 691                {
 692                    // Ignore the exception
 0693                }
 0694                ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
 0695                ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
 0696                if (_shouldTrace)
 697                {
 0698                    ServiceClientTracing.Error(_invocationId, ex);
 699                }
 0700                _httpRequest.Dispose();
 0701                if (_httpResponse != null)
 702                {
 0703                    _httpResponse.Dispose();
 704                }
 0705                throw ex;
 706            }
 707            // Create Result
 2708            var _result = new HttpOperationResponse<Images>();
 2709            _result.Request = _httpRequest;
 2710            _result.Response = _httpResponse;
 711            // Deserialize Response
 2712            if ((int)_statusCode == 200)
 713            {
 2714                _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
 715                try
 716                {
 2717                    _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<Images>(_responseContent, Client
 2718                }
 0719                catch (JsonException ex)
 720                {
 0721                    _httpRequest.Dispose();
 0722                    if (_httpResponse != null)
 723                    {
 0724                        _httpResponse.Dispose();
 725                    }
 0726                    throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
 727                }
 728            }
 2729            if (_shouldTrace)
 730            {
 0731                ServiceClientTracing.Exit(_invocationId, _result);
 732            }
 2733            return _result;
 2734        }
 735
 736    }
 737}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:47:14 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
get_Client()
ImageSearchWithHttpMessagesAsync()