Avvio rapido: Introduzione a Traduttore

In questo argomento di avvio rapido si apprenderà come usare il servizio Traduttore tramite REST. Si inizierà con esempi di base per poi passare ad alcune delle principali opzioni di configurazione comunemente usate durante lo sviluppo, tra cui:

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito

  • Dopo aver creato una sottoscrizione di Azure, creare una risorsa Traduttore nel portale di Azure per ottenere la chiave e l'endpoint. Al termine della distribuzione, fare clic su Vai alla risorsa.

    • La chiave e l'endpoint della risorsa sono necessari per connettere l'applicazione al servizio Traduttore. La chiave e l'endpoint verranno incollati nel codice riportato di seguito nell'argomento di avvio rapido. È possibile trovare questi valori nella pagina portale di Azure chiavi ed endpoint seguenti:

      Screenshot: portale di Azure chiavi ed endpoint.

  • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Impostazione della piattaforma

Intestazioni

Quando si chiama il servizio Traduttore tramite REST, è necessario verificare che le intestazioni seguenti siano incluse in ogni richiesta. Nel codice di esempio queste intestazioni sono già incluse nelle sezioni seguenti.

Intestazioni Descrizione
Intestazioni di autenticazione Intestazione della richiesta obbligatoria.
Ocp-Apim-Subscription-Key

Intestazione della richiesta obbligatoria se si usa una risorsa di Servizi cognitivi. Facoltativa se si usa una risorsa di Traduttore..
Ocp-Apim-Subscription-Region

Vedere le opzioni disponibili per l'autenticazione.
Content-Type Intestazione della richiesta obbligatoria.
Specifica il tipo di contenuto del payload.
Il valore accettato è application/json; charset=UTF-8.
Content-Length Intestazione della richiesta obbligatoria.
Lunghezza del corpo della richiesta.
X-ClientTraceId Facoltativo.
GUID generato dal client che identifica in modo univoco la richiesta. È possibile omettere questa intestazione se nella stringa della query si include l'ID traccia usando un parametro di query denominato ClientTraceId.

Keys and endpoints (Chiavi ed endpoint)

Gli esempi in questa pagina usano chiavi ed endpoint hardcoded per semplicità. Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, è consigliabile usare un modo sicuro per archiviare e accedere alle credenziali, Per altre informazioni, vedere l'articolo sulla sicurezza di Servizi cognitivi.

Traduci testo

La funzione principale del servizio Traduttore è tradurre testo. In questa sezione si creerà una richiesta che accetta un'unica origine (from) e fornisce due output (to). Si esamineranno quindi alcuni parametri che possono essere usati per modificare sia la richiesta che la risposta.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION";
    
    static async Task Main(string[] args)
    {
        // Input and output languages are defined as parameters.
        string route = "/translate?api-version=3.0&from=en&to=de&to=it";
        string textToTranslate = "Hello, world!";
        object[] body = new object[] { new { Text = textToTranslate } };
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente:

[
    {
        "translations": [
            {
                "text": "Hallo Welt!",
                "to": "de"
            },
            {
                "text": "Salve, mondo!",
                "to": "it"
            }
        ]
    }
]

Rileva lingua

Se si sa che servirà una traduzione, ma non si sa qual è la lingua del testo che verrà inviato al servizio Traduttore, è possibile usare l'operazione di rilevamento della lingua. È possibile identificare la lingua del testo di origine in più modi. In questa sezione viene illustrato come usare il rilevamento della lingua tramite l'endpoint translate e l'endpoint detect.

Rilevare la lingua di origine durante la traduzione

Se non si include il parametro from nella richiesta di traduzione, il servizio Traduttore cercherà di rilevare la lingua del testo di origine. Nella risposta si otterrà la lingua rilevata (language) e un punteggio di attendibilità (score). Più il valore di score è vicino a 1.0, più aumenta la probabilità che il rilevamento sia corretto.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION";
    
    static async Task Main(string[] args)
    {
        // Output languages are defined as parameters, input language detected.
        string route = "/translate?api-version=3.0&to=de&to=it";
        string textToTranslate = "Hello, world!";
        object[] body = new object[] { new { Text = textToTranslate } };
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente:

[
    {
        "detectedLanguage": {
            "language": "en",
            "score": 1.0
        },
        "translations": [
            {
                "text": "Hallo Welt!",
                "to": "de"
            },
            {
                "text": "Salve, mondo!",
                "to": "it"
            }
        ]
    }
]

Rilevare la lingua di origine senza traduzione

È possibile usare il servizio Traduttore per rilevare la lingua del testo di origine senza eseguire una traduzione. A questo scopo occorre usare l'endpoint /detect.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION";    
    
    static async Task Main(string[] args)
    {
        // Just detect language
        string route = "/detect?api-version=3.0";
        string textToLangDetect = "Ich würde wirklich gern Ihr Auto um den Block fahren ein paar Mal.";
        object[] body = new object[] { new { Text = textToLangDetect } };
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Quando si usa l'endpoint /detect, la risposta include rilevamenti alternativi e indica se la traduzione e la traslitterazione sono supportate per tutte le lingue rilevate. Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente:

[

    {

        "language": "de",

        "score": 1.0,

        "isTranslationSupported": true,

        "isTransliterationSupported": false

    }

]

Traslitterare testo

La traslitterazione è il processo di conversione di una parola o di una frase dall'alfabeto di una lingua a quello di un'altra lingua in base alla somiglianza fonetica. Ad esempio, si potrebbe usare la traslitterazione per convertire "สวัสดี" (thai) in "sawatdi" (latn). È possibile eseguire la traslitterazione in più modi. In questa sezione viene illustrato come usare la traslitterazione della lingua tramite l'endpoint translate e l'endpoint transliterate.

Eseguire la traslitterazione durante la traduzione

Se occorre eseguire la traduzione in una lingua che usa un alfabeto (o fonemi) diverso dalla lingua di origine, potrebbe essere necessaria una traslitterazione. In questo esempio si tradurrà la parola "Hello" dall'inglese al thai. Oltre a ottenere la traduzione in thai, si otterrà una traslitterazione della parola tradotta usando l'alfabeto latino.

Per ottenere una traslitterazione dall'endpoint translate, usare il parametro toScript.

Nota

Per un elenco completo delle lingue disponibili e delle opzioni di traslitterazione, vedere Supporto linguistico.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION";    
    
    static async Task Main(string[] args)
    {
        // Output language defined as parameter, with toScript set to latn
        string route = "/translate?api-version=3.0&to=th&toScript=latn";
        string textToTransliterate = "Hello";
        object[] body = new object[] { new { Text = textToTransliterate } };
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente. Tenere presente che la risposta dell'endpoint translate include la lingua di origine rilevata con un punteggio di attendibilità, una traduzione con l'alfabeto della lingua di output e una traslitterazione con l'alfabeto latino.

[
    {
        "detectedLanguage": {
            "language": "en",
            "score": 1.0
        },
        "translations": [
            {
                "text": "สวัสดี",
                "to": "th",
                "transliteration": {
                    "script": "Latn",
                    "text": "sawatdi"
                }
            }
        ]
    }
]

Eseguire la traslitterazione senza traduzione

Si può anche usare l'endpoint transliterate per ottenere una traslitterazione. Quando si usa l'endpoint di traslitterazione, è necessario specificare la lingua di origine (language), l'alfabeto di origine (fromScript) e l'alfabeto di output (toScript) come parametri. In questo esempio si otterrà la traslitterazione di สวัสดี.

Nota

Per un elenco completo delle lingue disponibili e delle opzioni di traslitterazione, vedere Supporto linguistico.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION";   
    
    static async Task Main(string[] args)
    {
        // For a complete list of options, see API reference.
        // Input and output languages are defined as parameters.
        string route = "/translate?api-version=3.0&to=th&toScript=latn";
        string textToTransliterate = "Hello";
        object[] body = new object[] { new { Text = textToTransliterate } };
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente. A differenza della chiamata all'endpoint translate, transliterate restituisce solo lo script e l'output text.

[
    {
        "script": "latn",
        "text": "sawatdi"
    }
]

Ottenere la lunghezza delle frasi

Con il servizio Traduttore è possibile ottenere il numero di caratteri di una frase o di una serie di frasi. La risposta viene restituita in forma di matrice, con il numero di caratteri rilevato per ogni frase. È possibile ottenere la lunghezza delle frasi con gli endpoint translate e breaksentence.

Ottenere la lunghezza delle frasi durante la traduzione

Con l'endpoint translate è possibile ottenere il numero di caratteri sia del testo di origine che dell'output della traduzione. Per restituire la lunghezza delle frasi (srcSenLen e transSenLen) occorre impostare il parametro includeSentenceLength su True.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION";   
    
    static async Task Main(string[] args)
    {
        // Include sentence length details.
        string route = "/translate?api-version=3.0&to=es&includeSentenceLength=true";
        string sentencesToCount = 
                "Can you tell me how to get to Penn Station? Oh, you aren't sure? That's fine.";
        object[] body = new object[] { new { Text = sentencesToCount } };
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente. Oltre alla lingua di origine rilevata e alla traduzione, si otterranno il numero dei caratteri di ogni frase rilevata sia per l'origine (srcSentLen) che per la traduzione (transSentLen).

[
    {
        "detectedLanguage": {
            "language": "en",
            "score": 1.0
        },
        "translations": [
            {
                "sentLen": {
                    "srcSentLen": [
                        44,
                        21,
                        12
                    ],
                    "transSentLen": [
                        48,
                        18,
                        10
                    ]
                },
                "text": "¿Puedes decirme cómo llegar a la estación Penn? ¿No estás seguro? Está bien.",
                "to": "es"
            }
        ]
    }
]

Ottenere la lunghezza delle frasi senza traduzione

Il servizio Traduttore consente anche di richiedere la lunghezza delle frasi senza traduzione, tramite l'endpoint breaksentence.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION";   
    
    static async Task Main(string[] args)
    {
        // Only include sentence length details.
        string route = "/breaksentence?api-version=3.0";
        string sentencesToCount = 
                "Can you tell me how to get to Penn Station? Oh, you aren't sure? That's fine.";
        object[] body = new object[] { new { Text = sentencesToCount } };
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente. A differenza della chiamata all'endpoint translate, breaksentence restituisce solo il numero dei caratteri del testo di origine in una matrice denominata sentLen.

[
    {
        "detectedLanguage": {
            "language": "en",
            "score": 1.0
        },
        "sentLen": [
            44,
            21,
            12
        ]
    }
]

Ricerca nel dizionario (traduzioni alternative)

Con l'endpoint è possibile ottenere traduzioni alternative per una parola o una frase. Ad esempio, se si traduce la parola "shark" da en a es, questo endpoint restituisce sia "tiburón" che "escualo".

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION"; 
    
    static async Task Main(string[] args)
    {
        // See many translation options
        string route = "/dictionary/lookup?api-version=3.0&from=en&to=es";
        string wordToTranslate = "shark";
        object[] body = new object[] { new { Text = wordToTranslate } };
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente. Il codice JSON di questa risposta è più complesso rispetto ad altri esempi riportati in questo articolo. La matrice translations include un elenco di traduzioni. Ogni oggetto nella matrice include un punteggio di attendibilità (confidence), il testo ottimizzato per la visualizzazione da parte dell'utente finale (displayTarget), il testo normalizzato (normalizedText), la parte del discorso (posTag) e le informazioni sulla traduzione precedente (backTranslations). Per altre informazioni sulla risposta, vedere Ricerca nel dizionario.

[
    {
        "displaySource": "shark",
        "normalizedSource": "shark",
        "translations": [
            {
                "backTranslations": [
                    {
                        "displayText": "shark",
                        "frequencyCount": 45,
                        "normalizedText": "shark",
                        "numExamples": 0
                    }
                ],
                "confidence": 0.8182,
                "displayTarget": "tiburón",
                "normalizedTarget": "tiburón",
                "posTag": "OTHER",
                "prefixWord": ""
            },
            {
                "backTranslations": [
                    {
                        "displayText": "shark",
                        "frequencyCount": 10,
                        "normalizedText": "shark",
                        "numExamples": 1
                    }
                ],
                "confidence": 0.1818,
                "displayTarget": "escualo",
                "normalizedTarget": "escualo",
                "posTag": "NOUN",
                "prefixWord": ""
            }
        ]
    }
]

Esempi di dizionario (traduzioni nel contesto)

Dopo aver eseguito una ricerca nel dizionario, è possibile passare il testo di origine e la traduzione all'endpoint dictionary/examples per ottenere un elenco di esempi che mostrano entrambi i termini nel contesto di una frase. Basandosi sull'esempio precedente, si useranno i valori normalizedText e normalizedTarget della risposta della ricerca nel dizionario come text e translation rispettivamente. I parametri della lingua di origine (from) e della destinazione di output (to) sono obbligatori.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json; // Install Newtonsoft.Json with NuGet

class Program
{
    private static readonly string subscriptionKey = "YOUR-SUBSCRIPTION-KEY";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com/";

    // Add your location, also known as region. The default is global.
    // This is required if using a Cognitive Services resource.
    private static readonly string location = "YOUR_RESOURCE_LOCATION"; 
    
    static async Task Main(string[] args)
    {
        // See examples of terms in context
        string route = "/dictionary/examples?api-version=3.0&from=en&to=es";
        object[] body = new object[] { new { Text = "Shark",  Translation = "tiburón" } } ;
        var requestBody = JsonConvert.SerializeObject(body);
    
        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);
    
            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Dopo una chiamata riuscita, si dovrebbe vedere la risposta seguente. Per altre informazioni sulla risposta, vedere Ricerca nel dizionario.

[
    {
        "examples": [
            {
                "sourcePrefix": "More than a match for any ",
                "sourceSuffix": ".",
                "sourceTerm": "shark",
                "targetPrefix": "Más que un fósforo para cualquier ",
                "targetSuffix": ".",
                "targetTerm": "tiburón"
            },
            {
                "sourcePrefix": "Same with the mega ",
                "sourceSuffix": ", of course.",
                "sourceTerm": "shark",
                "targetPrefix": "Y con el mega ",
                "targetSuffix": ", por supuesto.",
                "targetTerm": "tiburón"
            },
            {
                "sourcePrefix": "A ",
                "sourceSuffix": " ate it.",
                "sourceTerm": "shark",
                "targetPrefix": "Te la ha comido un ",
                "targetSuffix": ".",
                "targetTerm": "tiburón"
            }
        ],
        "normalizedSource": "shark",
        "normalizedTarget": "tiburón"
    }
]

Risoluzione dei problemi

Codici di stato HTTP comuni

Codice di stato HTTP Descrizione Possibile motivo
200 OK La richiesta è stata completata.
400 Bad Request Un parametro obbligatorio è mancante, vuoto o Null. In alternativa, il valore passato a un parametro obbligatorio o facoltativo non è valido. Un problema comune è la lunghezza eccessiva dell'intestazione.
401 Non autorizzata La richiesta non è autorizzata. Assicurarsi che la chiave di sottoscrizione o il token sia valido e nell'area corretta. Vedere anche Autenticazione.
429 Troppe richieste È stata superata la quota o la frequenza di richieste consentite per la sottoscrizione.
502 Gateway non valido Problema di rete o lato server. Può anche indicare intestazioni non valide.

Utenti Java

Se si riscontrano problemi di connessione, il certificato SSL potrebbe essere scaduto. Per risolvere questo problema, installare il certificato DigiCertGlobalRootG2.crt nell'archivio privato.

Passaggi successivi