private async Task <TextAnalyticsServiceResult> GetResult(HttpResponseMessage response)
        {
            TextAnalyticsServiceResult result = null;

            if (response == null || !response.IsSuccessStatusCode)
            {
                return(result);
            }

            try
            {
                string responseContent = await response.Content.ReadAsStringAsync();

                result = JsonConvert.DeserializeObject <TextAnalyticsServiceResult>(responseContent);

                result.Succeeded      = response.IsSuccessStatusCode;
                result.ServiceMessage = response.ReasonPhrase;
            }
            catch (Exception ex)
            {
                // TODO log exception

                result = null;
            }

            return(result);
        }
        private async Task <TextAnalyticsServiceResult> ProcessWorker(string apiUrl, HttpContent content)
        {
            HttpClient httpClient = GetHttpClient(apiUrl);

            HttpResponseMessage response = await httpClient.PostAsync(string.Empty, content);

            TextAnalyticsServiceResult result = await GetResult(response);

            return(result);
        }
        public async Task <TextAnalyticsServiceResult> ProcessAsync(string text, string language = "en", bool processSentiment = true, bool processLanguages = true, bool processKeyPhrases = true, bool processEntities = true)
        {
            TextAnalyticsServiceResult result = new TextAnalyticsServiceResult();

            if (string.IsNullOrWhiteSpace(text))
            {
                return(result);
            }

            TextAnalyticsRequest request = new TextAnalyticsRequest()
            {
                Id = "1", Language = language, Text = text
            };

            TextAnalyticsRequest[] requests = { request };

            HttpContent content = GetRequestContent(requests);

            TextAnalyticsResponse response = new TextAnalyticsResponse();

            response.Request = request;

            if (processSentiment)
            {
                TextAnalyticsServiceResult sentimentResult = await ProcessSentiment(content);

                result.Errors.AddRange(sentimentResult.Errors.Select(e0 => new TextAnalyticsError()
                {
                    Id = e0.Id, Message = "Sentiment: " + e0.Message
                }));

                response.SentimentScore = sentimentResult.Responses[0].SentimentScore;
            }

            if (processLanguages)
            {
                TextAnalyticsServiceResult languagesResult = await ProcessLanguages(content);

                result.Errors.AddRange(languagesResult.Errors.Select(e0 => new TextAnalyticsError()
                {
                    Id = e0.Id, Message = "Languages: " + e0.Message
                }));

                response.DetectedLanguages.AddRange(languagesResult.Responses[0].DetectedLanguages);
            }

            if (processKeyPhrases)
            {
                TextAnalyticsServiceResult keyPhrasesResult = await ProcessKeyPhrases(content);

                result.Errors.AddRange(keyPhrasesResult.Errors.Select(e0 => new TextAnalyticsError()
                {
                    Id = e0.Id, Message = "Key Phrases: " + e0.Message
                }));

                response.KeyPhrases.AddRange(keyPhrasesResult.Responses[0].KeyPhrases);
            }

            if (processEntities)
            {
                TextAnalyticsServiceResult entitiesResult = await ProcessEntities(content);

                result.Errors.AddRange(entitiesResult.Errors.Select(e0 => new TextAnalyticsError()
                {
                    Id = e0.Id, Message = "Entities: " + e0.Message
                }));

                response.Entities.AddRange(entitiesResult.Responses[0].Entities);
            }

            result.Responses.Add(response);

            result.Succeeded = (result.Errors.Count == 0);

            return(result);
        }