Quickstart: Aan de slag met TranslatorQuickstart: Get started with Translator

In deze quickstart leert u hoe u de Translator-service via REST kunt gebruiken.In this quickstart, you learn to use the Translator service via REST. U begint met de basisvoorbeelden en gaat vervolgens verder met een aantal belangrijke configuratie-opties die vaak worden gebruikt tijdens de ontwikkeling, waaronder:You start with basic examples and move onto some core configuration options that are commonly used during development, including:

VereistenPrerequisites

  • Azure-abonnement: Krijg een gratis abonnementAzure subscription - Create one for free
  • Zodra u een Azure-abonnement hebt, maakt u een Translator-resource in Azure Portal om uw sleutel en eindpunt op te halen.Once you have an Azure subscription, create a Translator resource in the Azure portal to get your key and endpoint. Nadat de app is geïmplementeerd, selecteert u Ga naar resource.After it deploys, select Go to resource.
    • U hebt de sleutel en het eindpunt nodig van de resource om de toepassing te verbinden met de Translator-service.You'll need the key and endpoint from the resource to connect your application to the Translator service. Later in de quickstart plakt u uw sleutel en eindpunt in de onderstaande code.You'll paste your key and endpoint into the code below later in the quickstart.
    • U kunt de gratis prijscategorie (F0) gebruiken om de service uit te proberen en later upgraden naar een betaalde laag voor productie.You can use the free pricing tier (F0) to try the service, and upgrade later to a paid tier for production.

Platform instellenPlatform setup

  • Maak een nieuw project: dotnet new console -o your_project_nameCreate a new project: dotnet new console -o your_project_name
  • Vervang Program.cs door de hieronder weergegeven C#-code.Replace Program.cs with the C# code shown below.
  • Stel de abonnementssleutel en eindpuntwaarden in Program.cs in.Set the subscription key and endpoint values in Program.cs.
  • Voeg Newtonsoft.Json toe met behulp van .NET CLI.Add Newtonsoft.Json using .NET CLI.
  • Voer het programma uit vanuit de projectmap: dotnet runRun the program from the project directory: dotnet run

KoptekstenHeaders

Wanneer u de Translator-service via REST aanroept, moet u ervoor zorgen dat de volgende headers in elke aanvraag zijn opgenomen.When calling the Translator service via REST, you'll need to make sure the following headers are included with each request. U vindt de headers in de voorbeeldcode in de volgende secties.Don't worry, we'll include the headers in the sample code in the following sections.

KoptekstenHeaders BeschrijvingDescription
Verificatieheader(s)Authentication header(s) Vereiste aanvraagheader.Required request header.
Ocp-Apim-Subscription-Key

De vereiste aanvraagheader als er een Cognitive Services-resource wordt gebruikt. Optioneel als er een Translator-resource wordt gebruikt.Required request header if using a Cognitive Services Resource. Optional if using a Translator Resource..
Ocp-Apim-Subscription-Region

Zie Beschikbare opties voor verificatie.See available options for authentication.
Content-TypeContent-Type Vereiste aanvraagheader.Required request header.
Hiermee geeft u het inhoudstype van de payload op.Specifies the content type of the payload.
De geaccepteerde waarde is application/json; charset=UTF-8.Accepted value is application/json; charset=UTF-8.
Content-LengthContent-Length Vereiste aanvraagheader.Required request header.
De lengte van de aanvraagtekst.The length of the request body.
X-ClientTraceIdX-ClientTraceId Optioneel.Optional.
Een door de client gegenereerde GUID om de aanvraag op unieke wijze te identificeren.A client-generated GUID to uniquely identify the request. U kunt deze header weglaten als u de tracerings-id in de queryreeks opneemt middels een queryparameter met de naam ClientTraceId.You can omit this header if you include the trace ID in the query string using a query parameter named ClientTraceId.

Sleutels en eindpuntenKeys and endpoints

De voorbeelden op deze pagina gebruiken voor het gemak in code vastgelegde sleutels en eindpunten.The samples on this page use hard-coded keys and endpoints for simplicity. Vergeet niet de sleutel uit uw code te verwijderen wanneer u klaar bent, en maak deze sleutel nooit openbaar.Remember to remove the key from your code when you're done, and never post it publicly. Overweeg om voor productie een veilige manier te gebruiken voor het opslaan en openen van uw referenties.For production, consider using a secure way of storing and accessing your credentials. Zie het artikel Cognitive Services Beveiliging voor meer informatie.See the Cognitive Services security article for more information.

Tekst vertalenTranslate text

De belangrijkste functie van de Translator-service is het vertalen van tekst.The core operation of the Translator service is to translate text. In deze sectie maakt u een aanvraag met één bron (from) en twee uitvoerwaarden (to).In this section, you'll build a request that takes a single source (from) and provides two outputs (to). Vervolgens bekijken we enkele parameters die kunnen worden gebruikt om zowel de aanvraag als het antwoord aan te passen.Then we'll review some parameters that can be used to adjust both the request and the response.

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);
        }
    }
}

Na een geslaagde aanroep ziet u het volgende antwoord:After a successful call, you should see the following response:

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

Taal detecterenDetect language

Als u weet dat u een vertaling nodig hebt, maar de taal van de tekst die naar de Translator-service wordt verzonden, niet kent, kunt u de taaldetectiefunctie gebruiken.If you know that you'll need translation, but don't know the language of the text that will be sent to the Translator service, you can use the language detection operation. Er zijn verschillende manieren om de taal van de brontekst te identificeren.There's more than one way to identify the source text language. In deze sectie leert u hoe u taaldetectie kunt gebruiken met behulp van het translate-eindpunt en het detect-eindpunt.In this section, you'll learn how to use language detection using the translate endpoint, and the detect endpoint.

Brontaal detecteren tijdens de vertalingDetect source language during translation

Als u de parameter from niet in uw vertaalaanvraag opneemt, probeert de Translator-service de taal van de brontekst zelf te detecteren.If you don't include the from parameter in your translation request, the Translator service will attempt to detect the source text's language. In het antwoord wordt de gedetecteerde taal (language) en een betrouwbaarheidsscore (score) weergeven.In the response, you'll get the detected language (language) and a confidence score (score). Hoe dichter de score bij 1.0 ligt, hoe groter de kans is dat de gedetecteerde taal juist is.The closer the score is to 1.0, means that there is increased confidence that the detection is correct.

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);
        }
    }
}

Na een geslaagde aanroep ziet u het volgende antwoord:After a successful call, you should see the following response:

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

Brontaal detecteren zonder vertalingDetect source language without translation

Het is mogelijk de Translator-service te gebruiken om de taal van de brontekst te detecteren zonder een vertaling uit te voeren.It's possible to use the Translator service to detect the language of source text without performing a translation. U kunt dit doen door het /detect-eindpunt te gebruiken.To do this, you'll use the /detect endpoint.

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);
        }
    }
}

Wanneer het /detect-eind punt wordt gebruikt, bevat het antwoord alternatieve detecties en kunt u zien of vertaling en transliteratie worden ondersteund voor de gedetecteerde talen.When using the /detect endpoint, the response will include alternate detections, and will let you know if translation and transliteration are supported for all of the detected languages. Na een geslaagde aanroep ziet u het volgende antwoord:After a successful call, you should see the following response:

[
    {
        "alternatives": [
            {
                "isTranslationSupported": true,
                "isTransliterationSupported": false,
                "language": "nl",
                "score": 0.92
            },
            {
                "isTranslationSupported": true,
                "isTransliterationSupported": false,
                "language": "sk",
                "score": 0.77
            }
        ],
        "isTranslationSupported": true,
        "isTransliterationSupported": false,
        "language": "de",
        "score": 1.0
    }
]

Tekst transcriberenTransliterate text

Transliteratie is het proces waarbij een woord of woordgroep van het script (alfabet) van de ene taal naar de andere wordt omgezet op basis van de fonetische gelijkenis.Transliteration is the process of converting a word or phrase from the script (alphabet) of one language to another based on phonetic similarity. U kunt bijvoorbeeld transliteratie gebruiken om ' สวัสดี ' (thai) om te zetten naar 'sawatdi' (latn).For example, you could use transliteration to convert "สวัสดี" (thai) to "sawatdi" (latn). Er is meer dan één manier om transliteratie uit te voeren.There's more than one way to perform transliteration. In deze sectie leert u hoe u taaldetectie kunt gebruiken met behulp van het translate-eindpunt en het transliterate-eindpunt.In this section, you'll learn how to use language detection using the translate endpoint, and the transliterate endpoint.

Transliteratie tijdens de vertalingTransliterate during translation

Als u tekst naar een taal wilt vertalen die gebruikmaakt van een ander alfabet (of fonemen) dan uw bron, moet u de tekst mogelijk eerst transliteren.If you're translating into a language that uses a different alphabet (or phonemes) than your source, you might need a transliteration. In dit voorbeeld vertalen we 'Hello' van het Engels naar het Thais.In this example, we translate "Hello" from English to Thai. Naast de vertaling in het Thais, krijgt u een transliteratie van de vertaalde woordgroep met behulp van het Latijnse alfabet.In addition to getting the translation in Thai, you'll get a transliteration of the translated phrase using the Latin alphabet.

Als u een transliteratie wilt met het translate-eindpunt, gebruikt u de parameter toScript .To get a transliteration from the translate endpoint, use the toScript parameter.

Notitie

Zie Taalondersteuning voor een volledige lijst met beschikbare talen en transliteratieopties.For a complete list of available languages and transliteration options, see language support.

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);
        }
    }
}

Na een geslaagde aanroep ziet u het volgende antwoord.After a successful call, you should see the following response. Houd er rekening mee dat het antwoord van het translate-eindpunt de gedetecteerde brontaal bevat met een betrouwbaarheidsscore, een vertaling in het alfabet van de uitvoertaal en een transliteratie in het Latijnse alfabet.Keep in mind that the response from translate endpoint includes the detected source language with a confidence score, a translation using the alphabet of the output language, and a transliteration using the Latin alphabet.

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

Transliteratie zonder vertalingTransliterate without translation

U kunt ook het transliterate-eindpunt gebruiken voor een transliteratie.You can also use the transliterate endpoint to get a transliteration. Wanneer u het eindpunt voor transliteratie gebruikt, moet u de brontaal (language), het bronscript/-alfabet (fromScript) en het uitvoerscript/-alfabet (toScript) als parameters opgeven.When using the transliteration endpoint, you must provide the source language (language), the source script/alphabet (fromScript), and the output script/alphabet (toScript) as parameters. In dit voorbeeld gaan we een transliteratie maken van สวัสดี.In this example, we're going to get the transliteration for สวัสดี.

Notitie

Zie Taalondersteuning voor een volledige lijst met beschikbare talen en transliteratieopties.For a complete list of available languages and transliteration options, see language support.

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);
        }
    }
}

Na een geslaagde aanroep ziet u het volgende antwoord.After a successful call, you should see the following response. In tegenstelling tot de aanroep van het translate-eindpunt, retourneert transliterate alleen de script en de uitvoer text.Unlike the call to the translate endpoint, transliterate only returns the script and the output text.

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

Zinslengte bepalenGet sentence length

Met de Translator-service kunt u het aantal tekens voor een zin of reeks zinnen bepalen.With the Translator service, you can get the character count for a sentence or series of sentences. Het antwoord wordt geretourneerd als een matrix, met het aantal tekens dat voor elke zin is gedetecteerd.The response is returned as an array, with character counts for each sentence detected. U kunt de zinslengte bepalen met de translate- en breaksentence-eindpunten.You can get sentence lengths with the translate and breaksentence endpoints.

Zinslengte bepalen tijdens vertalingGet sentence length during translation

U kunt het aantal tekens voor zowel de brontekst als de vertaaluitvoer bepalen met behulp van het translate-eindpunt.You can get character counts for both source text and translation output using the translate endpoint. Als u de zinslengte wilt retourneren (srcSenLen en transSenLen), moet u de parameter includeSentenceLength instellen op True.To return sentence length (srcSenLen and transSenLen) you must set the includeSentenceLength parameter to 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);
        }
    }
}

Na een geslaagde aanroep ziet u het volgende antwoord.After a successful call, you should see the following response. Naast de gedetecteerde brontaal en vertaling krijgt u het aantal tekens voor elke gedetecteerde zin voor zowel de bron (srcSentLen) als de vertaling (transSentLen).In addition to the detected source language and translation, you'll get character counts for each detected sentence for both the source (srcSentLen) and translation (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"
            }
        ]
    }
]

Zinslengte bepalen zonder vertalingGet sentence length without translation

Met de Translator-service kunt u ook de zinslengte bepalen zonder vertaling met behulp van het breaksentence-eindpunt.The Translator service also lets you request sentence length without translation using the breaksentence endpoint.

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);
        }
    }
}

Na een geslaagde aanroep ziet u het volgende antwoord.After a successful call, you should see the following response. In tegenstelling tot de aanroep van het translate-eindpunt, retourneert breaksentence alleen het aantal tekens voor de brontekst in een matrix met de naam sentLen.Unlike the call to the translate endpoint, breaksentence only returns the character counts for the source text in an array called sentLen.

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

Opzoeken in woordenlijst (alternatieve vertalingen)Dictionary lookup (alternate translations)

Met het eindpunt kunt u alternatieve vertalingen voor een woord of woordgroep verkrijgen.With the endpoint, you can get alternate translations for a word or phrase. Wanneer bijvoorbeeld het woord 'haaien' wordt vertaald van en naar es, retourneert dit eindpunt zowel 'tiburón' als 'escualo'.For example, when translating the word "shark" from en to es, this endpoint returns both "tiburón" and "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);
        }
    }
}

Na een geslaagde aanroep ziet u het volgende antwoord.After a successful call, you should see the following response. We zullen hier wat uitgebreider op ingaan, omdat de JSON complexer is dan die van andere voorbeelden in dit artikel.Let's break this down since the JSON is more complex than some of the other examples in this article. De translations-matrix bevat een lijst met vertalingen.The translations array includes a list of translations. Elk object in deze matrix bevat een betrouwbaarheidsscore (confidence), de tekst die is geoptimaliseerd voor weergave aan eindgebruikers (displayTarget), de genormaliseerde tekst (normalizedText), de woordsoort (posTag) en informatie over de vorige vertaling (backTranslations).Each object in this array includes a confidence score (confidence), the text optimized for end-user display (displayTarget), the normalized text (normalizedText), the part of speech (posTag), and information about previous translation (backTranslations). Zie Opzoeken in woordenlijst voor meer informatie over het antwoordFor more information about the response, see Dictionary Lookup

[
    {
        "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": ""
            }
        ]
    }
]

Voorbeelden van woordenlijsten (vertalingen met context)Dictionary examples (translations in context)

Nadat u een woord heeft opgezocht in de woordenlijst, kunt u de brontekst en vertaling doorgeven aan het dictionary/examples-eindpunt om een lijst met voorbeelden te verkrijgen waarin beide termen in de context van een zin of woordgroep worden weergegeven.After you've performed a dictionary lookup, you can pass the source text and translation to the dictionary/examples endpoint to get a list of examples that show both terms in the context of a sentence or phrase. Op basis van het vorige voorbeeld gebruikt u de normalizedText en normalizedTarget uit het antwoord van de zoekopdracht als text en translation.Building on the previous example, you'll use the normalizedText and normalizedTarget from the dictionary lookup response as text and translation respectively. De parameters voor de brontaal (from) en het uitvoerdoel (to) zijn vereist.The source language (from) and output target (to) parameters are required.

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);
        }
    }
}

Na een geslaagde aanroep ziet u het volgende antwoord.After a successful call, you should see the following response. Zie Opzoeken in woordenlijst voor meer informatie over het antwoordFor more information about the response, see Dictionary Lookup

[
    {
        "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"
    }
]

Problemen oplossenTroubleshooting

Java-gebruikersJava users

Als u verbindingsproblemen ondervindt, is uw SSL-certificaat mogelijk verlopen.If you're encountering connection issues, it may be that your SSL certificate has expired. U kunt dit probleem oplossen door de DigiCertGlobalRootG2.crt te installeren in uw privé-archief.To resolve this issue, install the DigiCertGlobalRootG2.crt to your private store.

Volgende stappenNext steps

Zie ookSee also