< Summary

Class:Azure.AI.TextAnalytics.ServiceRestClient
Assembly:Azure.AI.TextAnalytics
File(s):C:\Git\azure-sdk-for-net\sdk\textanalytics\Azure.AI.TextAnalytics\src\Generated\ServiceRestClient.cs
Covered lines:41
Uncovered lines:192
Coverable lines:233
Total lines:558
Line coverage:17.5% (41 of 233)
Covered branches:11
Total branches:78
Branch coverage:14.1% (11 of 78)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-85.71%50%
CreateEntitiesRecognitionGeneralRequest(...)-0%0%
EntitiesRecognitionGeneralAsync()-0%0%
EntitiesRecognitionGeneral(...)-0%0%
CreateEntitiesRecognitionPiiRequest(...)-0%0%
EntitiesRecognitionPiiAsync()-0%0%
EntitiesRecognitionPii(...)-0%0%
CreateEntitiesLinkingRequest(...)-0%0%
EntitiesLinkingAsync()-0%0%
EntitiesLinking(...)-0%0%
CreateKeyPhrasesRequest(...)-0%0%
KeyPhrasesAsync()-0%0%
KeyPhrases(...)-0%0%
CreateLanguagesRequest(...)-100%100%
LanguagesAsync()-90%75%
Languages(...)-90%75%
CreateSentimentRequest(...)-0%0%
SentimentAsync()-0%0%
Sentiment(...)-0%0%

File(s)

C:\Git\azure-sdk-for-net\sdk\textanalytics\Azure.AI.TextAnalytics\src\Generated\ServiceRestClient.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4// <auto-generated/>
 5
 6#nullable disable
 7
 8using System;
 9using System.Text.Json;
 10using System.Threading;
 11using System.Threading.Tasks;
 12using Azure;
 13using Azure.AI.TextAnalytics.Models;
 14using Azure.Core;
 15using Azure.Core.Pipeline;
 16
 17namespace Azure.AI.TextAnalytics
 18{
 19    internal partial class ServiceRestClient
 20    {
 21        private string endpoint;
 22        private ClientDiagnostics _clientDiagnostics;
 23        private HttpPipeline _pipeline;
 24
 25        /// <summary> Initializes a new instance of ServiceRestClient. </summary>
 26        /// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
 27        /// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
 28        /// <param name="endpoint"> Supported Cognitive Services endpoints (protocol and hostname, for example: https://
 29        /// <exception cref="ArgumentNullException"> <paramref name="endpoint"/> is null. </exception>
 18030        public ServiceRestClient(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string endpoint)
 31        {
 18032            if (endpoint == null)
 33            {
 034                throw new ArgumentNullException(nameof(endpoint));
 35            }
 36
 18037            this.endpoint = endpoint;
 18038            _clientDiagnostics = clientDiagnostics;
 18039            _pipeline = pipeline;
 18040        }
 41
 42        internal HttpMessage CreateEntitiesRecognitionGeneralRequest(MultiLanguageBatchInput input, string modelVersion,
 43        {
 044            var message = _pipeline.CreateMessage();
 045            var request = message.Request;
 046            request.Method = RequestMethod.Post;
 047            var uri = new RawRequestUriBuilder();
 048            uri.AppendRaw(endpoint, false);
 049            uri.AppendRaw("/text/analytics/v3.1-preview.1", false);
 050            uri.AppendPath("/entities/recognition/general", false);
 051            if (modelVersion != null)
 52            {
 053                uri.AppendQuery("model-version", modelVersion, true);
 54            }
 055            if (showStats != null)
 56            {
 057                uri.AppendQuery("showStats", showStats.Value, true);
 58            }
 059            request.Uri = uri;
 060            request.Headers.Add("Content-Type", "application/json");
 061            var content = new Utf8JsonRequestContent();
 062            content.JsonWriter.WriteObjectValue(input);
 063            request.Content = content;
 064            return message;
 65        }
 66
 67        /// <summary> The API returns a list of general named entities in a given document. For the list of supported en
 68        /// <param name="input"> Collection of documents to analyze. </param>
 69        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 70        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 71        /// <param name="cancellationToken"> The cancellation token to use. </param>
 72        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 73        public async Task<Response<EntitiesResult>> EntitiesRecognitionGeneralAsync(MultiLanguageBatchInput input, strin
 74        {
 075            if (input == null)
 76            {
 077                throw new ArgumentNullException(nameof(input));
 78            }
 79
 080            using var message = CreateEntitiesRecognitionGeneralRequest(input, modelVersion, showStats);
 081            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 082            switch (message.Response.Status)
 83            {
 84                case 200:
 85                    {
 86                        EntitiesResult value = default;
 087                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 088                        value = EntitiesResult.DeserializeEntitiesResult(document.RootElement);
 089                        return Response.FromValue(value, message.Response);
 90                    }
 91                default:
 092                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 93            }
 094        }
 95
 96        /// <summary> The API returns a list of general named entities in a given document. For the list of supported en
 97        /// <param name="input"> Collection of documents to analyze. </param>
 98        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 99        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 100        /// <param name="cancellationToken"> The cancellation token to use. </param>
 101        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 102        public Response<EntitiesResult> EntitiesRecognitionGeneral(MultiLanguageBatchInput input, string modelVersion = 
 103        {
 0104            if (input == null)
 105            {
 0106                throw new ArgumentNullException(nameof(input));
 107            }
 108
 0109            using var message = CreateEntitiesRecognitionGeneralRequest(input, modelVersion, showStats);
 0110            _pipeline.Send(message, cancellationToken);
 0111            switch (message.Response.Status)
 112            {
 113                case 200:
 114                    {
 115                        EntitiesResult value = default;
 0116                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0117                        value = EntitiesResult.DeserializeEntitiesResult(document.RootElement);
 0118                        return Response.FromValue(value, message.Response);
 119                    }
 120                default:
 0121                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 122            }
 0123        }
 124
 125        internal HttpMessage CreateEntitiesRecognitionPiiRequest(MultiLanguageBatchInput input, string modelVersion, boo
 126        {
 0127            var message = _pipeline.CreateMessage();
 0128            var request = message.Request;
 0129            request.Method = RequestMethod.Post;
 0130            var uri = new RawRequestUriBuilder();
 0131            uri.AppendRaw(endpoint, false);
 0132            uri.AppendRaw("/text/analytics/v3.1-preview.1", false);
 0133            uri.AppendPath("/entities/recognition/pii", false);
 0134            if (modelVersion != null)
 135            {
 0136                uri.AppendQuery("model-version", modelVersion, true);
 137            }
 0138            if (showStats != null)
 139            {
 0140                uri.AppendQuery("showStats", showStats.Value, true);
 141            }
 0142            if (domain != null)
 143            {
 0144                uri.AppendQuery("domain", domain, true);
 145            }
 0146            request.Uri = uri;
 0147            request.Headers.Add("Content-Type", "application/json");
 0148            var content = new Utf8JsonRequestContent();
 0149            content.JsonWriter.WriteObjectValue(input);
 0150            request.Content = content;
 0151            return message;
 152        }
 153
 154        /// <summary>
 155        /// The API returns a list of entities with personal information (\&quot;SSN\&quot;, \&quot;Bank Account\&quot; 
 156        /// .
 157        /// </summary>
 158        /// <param name="input"> Collection of documents to analyze. </param>
 159        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 160        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 161        /// <param name="domain"> (Optional) if set to &apos;PHI&apos;, response will contain only PHI entities. </param
 162        /// <param name="cancellationToken"> The cancellation token to use. </param>
 163        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 164        public async Task<Response<EntitiesResult>> EntitiesRecognitionPiiAsync(MultiLanguageBatchInput input, string mo
 165        {
 0166            if (input == null)
 167            {
 0168                throw new ArgumentNullException(nameof(input));
 169            }
 170
 0171            using var message = CreateEntitiesRecognitionPiiRequest(input, modelVersion, showStats, domain);
 0172            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0173            switch (message.Response.Status)
 174            {
 175                case 200:
 176                    {
 177                        EntitiesResult value = default;
 0178                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0179                        value = EntitiesResult.DeserializeEntitiesResult(document.RootElement);
 0180                        return Response.FromValue(value, message.Response);
 181                    }
 182                default:
 0183                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 184            }
 0185        }
 186
 187        /// <summary>
 188        /// The API returns a list of entities with personal information (\&quot;SSN\&quot;, \&quot;Bank Account\&quot; 
 189        /// .
 190        /// </summary>
 191        /// <param name="input"> Collection of documents to analyze. </param>
 192        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 193        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 194        /// <param name="domain"> (Optional) if set to &apos;PHI&apos;, response will contain only PHI entities. </param
 195        /// <param name="cancellationToken"> The cancellation token to use. </param>
 196        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 197        public Response<EntitiesResult> EntitiesRecognitionPii(MultiLanguageBatchInput input, string modelVersion = null
 198        {
 0199            if (input == null)
 200            {
 0201                throw new ArgumentNullException(nameof(input));
 202            }
 203
 0204            using var message = CreateEntitiesRecognitionPiiRequest(input, modelVersion, showStats, domain);
 0205            _pipeline.Send(message, cancellationToken);
 0206            switch (message.Response.Status)
 207            {
 208                case 200:
 209                    {
 210                        EntitiesResult value = default;
 0211                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0212                        value = EntitiesResult.DeserializeEntitiesResult(document.RootElement);
 0213                        return Response.FromValue(value, message.Response);
 214                    }
 215                default:
 0216                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 217            }
 0218        }
 219
 220        internal HttpMessage CreateEntitiesLinkingRequest(MultiLanguageBatchInput input, string modelVersion, bool? show
 221        {
 0222            var message = _pipeline.CreateMessage();
 0223            var request = message.Request;
 0224            request.Method = RequestMethod.Post;
 0225            var uri = new RawRequestUriBuilder();
 0226            uri.AppendRaw(endpoint, false);
 0227            uri.AppendRaw("/text/analytics/v3.1-preview.1", false);
 0228            uri.AppendPath("/entities/linking", false);
 0229            if (modelVersion != null)
 230            {
 0231                uri.AppendQuery("model-version", modelVersion, true);
 232            }
 0233            if (showStats != null)
 234            {
 0235                uri.AppendQuery("showStats", showStats.Value, true);
 236            }
 0237            request.Uri = uri;
 0238            request.Headers.Add("Content-Type", "application/json");
 0239            var content = new Utf8JsonRequestContent();
 0240            content.JsonWriter.WriteObjectValue(input);
 0241            request.Content = content;
 0242            return message;
 243        }
 244
 245        /// <summary> The API returns a list of recognized entities with links to a well-known knowledge base. See the &
 246        /// <param name="input"> Collection of documents to analyze. </param>
 247        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 248        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 249        /// <param name="cancellationToken"> The cancellation token to use. </param>
 250        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 251        public async Task<Response<EntityLinkingResult>> EntitiesLinkingAsync(MultiLanguageBatchInput input, string mode
 252        {
 0253            if (input == null)
 254            {
 0255                throw new ArgumentNullException(nameof(input));
 256            }
 257
 0258            using var message = CreateEntitiesLinkingRequest(input, modelVersion, showStats);
 0259            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0260            switch (message.Response.Status)
 261            {
 262                case 200:
 263                    {
 264                        EntityLinkingResult value = default;
 0265                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0266                        value = EntityLinkingResult.DeserializeEntityLinkingResult(document.RootElement);
 0267                        return Response.FromValue(value, message.Response);
 268                    }
 269                default:
 0270                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 271            }
 0272        }
 273
 274        /// <summary> The API returns a list of recognized entities with links to a well-known knowledge base. See the &
 275        /// <param name="input"> Collection of documents to analyze. </param>
 276        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 277        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 278        /// <param name="cancellationToken"> The cancellation token to use. </param>
 279        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 280        public Response<EntityLinkingResult> EntitiesLinking(MultiLanguageBatchInput input, string modelVersion = null, 
 281        {
 0282            if (input == null)
 283            {
 0284                throw new ArgumentNullException(nameof(input));
 285            }
 286
 0287            using var message = CreateEntitiesLinkingRequest(input, modelVersion, showStats);
 0288            _pipeline.Send(message, cancellationToken);
 0289            switch (message.Response.Status)
 290            {
 291                case 200:
 292                    {
 293                        EntityLinkingResult value = default;
 0294                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0295                        value = EntityLinkingResult.DeserializeEntityLinkingResult(document.RootElement);
 0296                        return Response.FromValue(value, message.Response);
 297                    }
 298                default:
 0299                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 300            }
 0301        }
 302
 303        internal HttpMessage CreateKeyPhrasesRequest(MultiLanguageBatchInput input, string modelVersion, bool? showStats
 304        {
 0305            var message = _pipeline.CreateMessage();
 0306            var request = message.Request;
 0307            request.Method = RequestMethod.Post;
 0308            var uri = new RawRequestUriBuilder();
 0309            uri.AppendRaw(endpoint, false);
 0310            uri.AppendRaw("/text/analytics/v3.1-preview.1", false);
 0311            uri.AppendPath("/keyPhrases", false);
 0312            if (modelVersion != null)
 313            {
 0314                uri.AppendQuery("model-version", modelVersion, true);
 315            }
 0316            if (showStats != null)
 317            {
 0318                uri.AppendQuery("showStats", showStats.Value, true);
 319            }
 0320            request.Uri = uri;
 0321            request.Headers.Add("Content-Type", "application/json");
 0322            var content = new Utf8JsonRequestContent();
 0323            content.JsonWriter.WriteObjectValue(input);
 0324            request.Content = content;
 0325            return message;
 326        }
 327
 328        /// <summary> The API returns a list of strings denoting the key phrases in the input text. See the &lt;a href=&
 329        /// <param name="input"> Collection of documents to analyze. Documents can now contain a language field to indic
 330        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 331        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 332        /// <param name="cancellationToken"> The cancellation token to use. </param>
 333        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 334        public async Task<Response<KeyPhraseResult>> KeyPhrasesAsync(MultiLanguageBatchInput input, string modelVersion 
 335        {
 0336            if (input == null)
 337            {
 0338                throw new ArgumentNullException(nameof(input));
 339            }
 340
 0341            using var message = CreateKeyPhrasesRequest(input, modelVersion, showStats);
 0342            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0343            switch (message.Response.Status)
 344            {
 345                case 200:
 346                    {
 347                        KeyPhraseResult value = default;
 0348                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0349                        value = KeyPhraseResult.DeserializeKeyPhraseResult(document.RootElement);
 0350                        return Response.FromValue(value, message.Response);
 351                    }
 352                default:
 0353                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 354            }
 0355        }
 356
 357        /// <summary> The API returns a list of strings denoting the key phrases in the input text. See the &lt;a href=&
 358        /// <param name="input"> Collection of documents to analyze. Documents can now contain a language field to indic
 359        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 360        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 361        /// <param name="cancellationToken"> The cancellation token to use. </param>
 362        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 363        public Response<KeyPhraseResult> KeyPhrases(MultiLanguageBatchInput input, string modelVersion = null, bool? sho
 364        {
 0365            if (input == null)
 366            {
 0367                throw new ArgumentNullException(nameof(input));
 368            }
 369
 0370            using var message = CreateKeyPhrasesRequest(input, modelVersion, showStats);
 0371            _pipeline.Send(message, cancellationToken);
 0372            switch (message.Response.Status)
 373            {
 374                case 200:
 375                    {
 376                        KeyPhraseResult value = default;
 0377                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0378                        value = KeyPhraseResult.DeserializeKeyPhraseResult(document.RootElement);
 0379                        return Response.FromValue(value, message.Response);
 380                    }
 381                default:
 0382                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 383            }
 0384        }
 385
 386        internal HttpMessage CreateLanguagesRequest(LanguageBatchInput input, string modelVersion, bool? showStats)
 387        {
 52388            var message = _pipeline.CreateMessage();
 52389            var request = message.Request;
 52390            request.Method = RequestMethod.Post;
 52391            var uri = new RawRequestUriBuilder();
 52392            uri.AppendRaw(endpoint, false);
 52393            uri.AppendRaw("/text/analytics/v3.1-preview.1", false);
 52394            uri.AppendPath("/languages", false);
 52395            if (modelVersion != null)
 396            {
 16397                uri.AppendQuery("model-version", modelVersion, true);
 398            }
 52399            if (showStats != null)
 400            {
 20401                uri.AppendQuery("showStats", showStats.Value, true);
 402            }
 52403            request.Uri = uri;
 52404            request.Headers.Add("Content-Type", "application/json");
 52405            var content = new Utf8JsonRequestContent();
 52406            content.JsonWriter.WriteObjectValue(input);
 52407            request.Content = content;
 52408            return message;
 409        }
 410
 411        /// <summary> The API returns the detected language and a numeric score between 0 and 1. Scores close to 1 indic
 412        /// <param name="input"> Collection of documents to analyze. </param>
 413        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 414        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 415        /// <param name="cancellationToken"> The cancellation token to use. </param>
 416        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 417        public async Task<Response<LanguageResult>> LanguagesAsync(LanguageBatchInput input, string modelVersion = null,
 418        {
 26419            if (input == null)
 420            {
 0421                throw new ArgumentNullException(nameof(input));
 422            }
 423
 26424            using var message = CreateLanguagesRequest(input, modelVersion, showStats);
 26425            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 26426            switch (message.Response.Status)
 427            {
 428                case 200:
 429                    {
 430                        LanguageResult value = default;
 24431                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 24432                        value = LanguageResult.DeserializeLanguageResult(document.RootElement);
 24433                        return Response.FromValue(value, message.Response);
 434                    }
 435                default:
 2436                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 437            }
 24438        }
 439
 440        /// <summary> The API returns the detected language and a numeric score between 0 and 1. Scores close to 1 indic
 441        /// <param name="input"> Collection of documents to analyze. </param>
 442        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 443        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 444        /// <param name="cancellationToken"> The cancellation token to use. </param>
 445        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 446        public Response<LanguageResult> Languages(LanguageBatchInput input, string modelVersion = null, bool? showStats 
 447        {
 26448            if (input == null)
 449            {
 0450                throw new ArgumentNullException(nameof(input));
 451            }
 452
 26453            using var message = CreateLanguagesRequest(input, modelVersion, showStats);
 26454            _pipeline.Send(message, cancellationToken);
 26455            switch (message.Response.Status)
 456            {
 457                case 200:
 458                    {
 459                        LanguageResult value = default;
 24460                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 24461                        value = LanguageResult.DeserializeLanguageResult(document.RootElement);
 24462                        return Response.FromValue(value, message.Response);
 463                    }
 464                default:
 2465                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 466            }
 24467        }
 468
 469        internal HttpMessage CreateSentimentRequest(MultiLanguageBatchInput input, string modelVersion, bool? showStats,
 470        {
 0471            var message = _pipeline.CreateMessage();
 0472            var request = message.Request;
 0473            request.Method = RequestMethod.Post;
 0474            var uri = new RawRequestUriBuilder();
 0475            uri.AppendRaw(endpoint, false);
 0476            uri.AppendRaw("/text/analytics/v3.1-preview.1", false);
 0477            uri.AppendPath("/sentiment", false);
 0478            if (modelVersion != null)
 479            {
 0480                uri.AppendQuery("model-version", modelVersion, true);
 481            }
 0482            if (showStats != null)
 483            {
 0484                uri.AppendQuery("showStats", showStats.Value, true);
 485            }
 0486            if (opinionMining != null)
 487            {
 0488                uri.AppendQuery("opinionMining", opinionMining.Value, true);
 489            }
 0490            request.Uri = uri;
 0491            request.Headers.Add("Content-Type", "application/json");
 0492            var content = new Utf8JsonRequestContent();
 0493            content.JsonWriter.WriteObjectValue(input);
 0494            request.Content = content;
 0495            return message;
 496        }
 497
 498        /// <summary> The API returns a detailed sentiment analysis for the input text. The analysis is done in multiple
 499        /// <param name="input"> Collection of documents to analyze. </param>
 500        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 501        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 502        /// <param name="opinionMining"> (Optional) if set to true, response will contain input and document level stati
 503        /// <param name="cancellationToken"> The cancellation token to use. </param>
 504        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 505        public async Task<Response<SentimentResponse>> SentimentAsync(MultiLanguageBatchInput input, string modelVersion
 506        {
 0507            if (input == null)
 508            {
 0509                throw new ArgumentNullException(nameof(input));
 510            }
 511
 0512            using var message = CreateSentimentRequest(input, modelVersion, showStats, opinionMining);
 0513            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0514            switch (message.Response.Status)
 515            {
 516                case 200:
 517                    {
 518                        SentimentResponse value = default;
 0519                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0520                        value = SentimentResponse.DeserializeSentimentResponse(document.RootElement);
 0521                        return Response.FromValue(value, message.Response);
 522                    }
 523                default:
 0524                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 525            }
 0526        }
 527
 528        /// <summary> The API returns a detailed sentiment analysis for the input text. The analysis is done in multiple
 529        /// <param name="input"> Collection of documents to analyze. </param>
 530        /// <param name="modelVersion"> (Optional) This value indicates which model will be used for scoring. If a model
 531        /// <param name="showStats"> (Optional) if set to true, response will contain input and document level statistic
 532        /// <param name="opinionMining"> (Optional) if set to true, response will contain input and document level stati
 533        /// <param name="cancellationToken"> The cancellation token to use. </param>
 534        /// <exception cref="ArgumentNullException"> <paramref name="input"/> is null. </exception>
 535        public Response<SentimentResponse> Sentiment(MultiLanguageBatchInput input, string modelVersion = null, bool? sh
 536        {
 0537            if (input == null)
 538            {
 0539                throw new ArgumentNullException(nameof(input));
 540            }
 541
 0542            using var message = CreateSentimentRequest(input, modelVersion, showStats, opinionMining);
 0543            _pipeline.Send(message, cancellationToken);
 0544            switch (message.Response.Status)
 545            {
 546                case 200:
 547                    {
 548                        SentimentResponse value = default;
 0549                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0550                        value = SentimentResponse.DeserializeSentimentResponse(document.RootElement);
 0551                        return Response.FromValue(value, message.Response);
 552                    }
 553                default:
 0554                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 555            }
 0556        }
 557    }
 558}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:38 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
CreateEntitiesRecognitionGeneralRequest(...)
EntitiesRecognitionGeneralAsync()
EntitiesRecognitionGeneral(...)
CreateEntitiesRecognitionPiiRequest(...)
EntitiesRecognitionPiiAsync()
EntitiesRecognitionPii(...)
CreateEntitiesLinkingRequest(...)
EntitiesLinkingAsync()
EntitiesLinking(...)
CreateKeyPhrasesRequest(...)
KeyPhrasesAsync()
KeyPhrases(...)
CreateLanguagesRequest(...)
LanguagesAsync()
Languages(...)
CreateSentimentRequest(...)
SentimentAsync()
Sentiment(...)