Schnellstart: Erste Schritte mit der Textübersetzung

In dieser Schnellstartanleitung erfahren Sie, wie Sie den Textübersetzungsdienst mithilfe von REST verwenden. Sie beginnen mit einfachen Beispielen und fahren dann mit einigen Konfigurationsoptionen für den Kern fort, die bei der Entwicklung häufig verwendet werden, darunter:

Voraussetzungen

  • Azure-Abonnement – Erstellen eines kostenlosen Kontos

  • Sobald Sie über ein Azure-Abonnement verfügen, erstellen Sie eine Textübersetzungsressource im Azure-Portal, um Ihren Schlüssel und Endpunkt zu erhalten. Wählen Sie nach Abschluss der Bereitstellung Zu Ressource wechseln aus.

    • Sie benötigen den Schlüssel und Endpunkt der Ressource, um Ihre Anwendung mit dem Textübersetzungsdienst zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt. Diese Werte sind im Azure-Portal auf der Seite Schlüssel und Endpunkt aufgeführt:

      Screenshot: Seite mit Schlüsseln und Endpunkt im Azure-Portal.

  • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Plattformeinrichtung

  • Erstellen Sie ein neues Projekt: dotnet new console -o your_project_name
  • Ersetzen Sie den Code in „Program.cs“ durch den unten abgebildeten C#-Code.
  • Legen Sie die Werte von Abonnementschlüssel und Endpunkt in „Program.cs“ fest.
  • Fügen Sie „Newtonsoft.Json“ mithilfe der .NET-CLI hinzu.
  • Führen Sie das Programm aus dem Projektverzeichnis aus: dotnet run

Header

Beim Aufrufen des Textübersetzungsdiensts über REST müssen Sie sicherstellen, dass jede Anforderung die folgenden Header enthält. Keine Sorge, wir fügen die Header in den folgenden Abschnitten in den Beispielcode ein.

Header BESCHREIBUNG
Authentifizierungsheader Erforderlicher Anforderungsheader.
Ocp-Apim-Subscription-Key

Erforderlicher Anforderungsheader bei Verwendung einer Cognitive Services-Ressource. Optional, wenn eine Textübersetzungsressource verwendet wird..
Ocp-Apim-Subscription-Region

Weitere Informationen finden Sie in den verfügbaren Optionen für die Authentifizierung.
Content-Type Erforderlicher Anforderungsheader.
Gibt den Inhaltstyp der Nutzlast an.
Der zulässige Wert ist application/json; charset=UTF-8.
Content-Length Erforderlicher Anforderungsheader.
Die Länge des Anforderungstexts.
X-ClientTraceId Optional:
Eine vom Client erstellte GUID zur eindeutigen Identifizierung der Anforderung. Sie können diesen Header nur weglassen, wenn Sie die Ablaufverfolgungs-ID in die Abfragezeichenfolge über einen Abfrageparameter namens ClientTraceId einschließen.

Keys and endpoints (Schlüssel und Endpunkte)

In den Beispielen auf dieser Seite werden aus Gründen der Einfachheit hartcodierte Schlüssel und Endpunkte verwendet. Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. In der Produktionsumgebung sollten Sie eine sichere Methode zum Speichern Ihrer Anmeldeinformationen sowie zum Zugriff darauf verwenden. Weitere Informationen finden Sie im Cognitive Services-Artikel zur Sicherheit.

Text übersetzen

Der Kernvorgang des Textübersetzungsdiensts besteht im Übersetzen von Text. In diesem Abschnitt erstellen Sie eine Anforderung, die eine einzelne Quelle (from) annimmt und zwei Ausgaben (to) zur Verfügung stellt. Anschließend überprüfen wir einige Parameter, die verwendet werden können, um sowohl die Anforderung als auch die Antwort anzupassen.

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

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen:

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

Sprache erkennen

Wenn Sie wissen, dass Sie eine Übersetzung benötigen, die Sprache des Texts aber nicht kennen, der an den Textübersetzungsdienst gesendet werden soll, können Sie den Sprachenerkennungsvorgang verwenden. Es gibt mehr als eine Möglichkeit, die Sprache des Ausgangstexts zu bestimmen. In diesem Abschnitt erfahren Sie, wie Sie die Sprachenerkennung mithilfe des translate-Endpunkts und des detect-Endpunkts verwenden.

Erkennen der Quellsprache während der Übersetzung

Wenn Sie den from-Parameter nicht in Ihre Übersetzungsanforderung aufnehmen, versucht der Textübersetzungsdienst, die Sprache des Ausgangstexts zu erkennen. In der Antwort erhalten Sie die erkannte Sprache (language) und eine Vertrauensbewertung (score). Je näher score an 1.0 liegt, desto zuverlässiger wurde die Sprache richtig erkannt.

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

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen:

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

Erkennen der Quellsprache ohne Übersetzung

Es ist möglich, den Textübersetzungsdienst zum Erkennen der Sprache von Quelltext zu verwenden, ohne eine Übersetzung durchzuführen. Zu diesem Zweck verwenden Sie den /detect-Endpunkt.

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

Beim Verwenden des /detect-Endpunkts enthält die Antwort alternative erkannte Sprachen und informiert Sie darüber, ob Übersetzung und Transliteration für alle erkannten Sprachen unterstützt werden. Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen:

[

    {

        "language": "de",

        "score": 1.0,

        "isTranslationSupported": true,

        "isTransliterationSupported": false

    }

]

Transliteration von Text

Transliteration ist der Vorgang der Umwandlung eines Worts oder Ausdrucks aus der Schrift (Alphabet) einer Sprache in eine andere, ausgehend von der phonetischen Ähnlichkeit. Beispielsweise können Sie Transliteration verwenden, um „สวัสดี“ (thai) in „sawatdi“ (latn) zu konvertieren. Es gibt mehrere Möglichkeiten zum Durchführen von Transliteration. In diesem Abschnitt erfahren Sie, wie Sie die Sprachenerkennung mithilfe des translate-Endpunkts und des transliterate-Endpunkts verwenden.

Transliteration während der Übersetzung

Wenn Sie in eine Sprache übersetzen, die ein anderes Alphabet (oder andere Phoneme) als ihre Quelle verwendet, benötigen Sie möglicherweise Transliteration. In diesem Beispiel wird „Hello“ von Englisch in Thailändisch übersetzt. Über das Ergebnis einer Übersetzung ins Thailändische hinaus erhalten Sie eine Transliteration des übersetzten Satzes, die das lateinische Alphabet verwendet.

Zum Abrufen einer Übersetzung vom translate-Endpunkt verwenden Sie den Parameter toScript.

Hinweis

Eine vollständige Liste der verfügbaren Sprachen und Transliterationen finden Sie unter Sprachunterstützung.

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

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen. Beachten Sie, dass die Antwort vom translate-Endpunkt die erkannte Ausgangssprache mit einer Vertrauensbewertung, eine Übersetzung im Alphabet der Zielsprache und eine Transliteration unter Verwendung des lateinischen Alphabets umfasst.

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

Transliteration ohne Übersetzung

Sie können ferner den transliterate-Endpunkt verwenden, um eine Transliteration abzurufen. Beim Verwenden des Transliterationsendpunkts müssen Sie die Ausgangssprache (language), die Ausgangsschrift/das Ausgangsalphabet (fromScript) und die Zielschrift/das Zielalphabet (toScript) als Parameter angeben. In diesem Beispiel rufen wir die Transliteration für สวัสดี ab.

Hinweis

Eine vollständige Liste der verfügbaren Sprachen und Transliterationen finden Sie unter Sprachunterstützung.

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

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen. Im Gegensatz zu einem Aufruf des translate-Endpunkts gibt transliterate nur die script und den Ausgabe-text zurück.

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

Abrufen der Satzlänge

Mit dem Textübersetzungsdienst können Sie die Zeichenanzahl für einen Satz oder eine Reihe von Sätzen bestimmen. Die Antwort wird als Array zurückgegeben, das die Zeichenanzahl für jeden erkannten Satz enthält. Sie können Satzlängen mit den Endpunkten translate und breaksentence abrufen.

Abrufen der Satzlänge während der Übersetzung

Sie können die Zeichenanzahl sowohl für den Ausgangstext als auch für die übersetzte Ausgabe mithilfe des translate-Endpunkts abrufen. Um die Satzlänge (srcSenLen und transSenLen) zurückzugeben, müssen Sie den includeSentenceLength-Parameter auf True festlegen.

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

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen. Über die erkannte Ausgangssprache und die Übersetzung hinaus erhalten Sie die Zeichenanzahl für jeden erkannten Satz, sowohl für die Quelle (srcSentLen) als auch für die Übersetzung (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"
            }
        ]
    }
]

Abrufen der Satzlänge ohne Übersetzung

Der Textübersetzungsdienst lässt Sie die Satzlänge auch ohne Übersetzung abrufen, wenn Sie den breaksentence-Endpunkt verwenden.

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

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen. Anders als ein Aufruf des translate-Endpunkts gibt breaksentence nur die Zeichenanzahl für den Ausgangstext in einem Array mit dem Namen sentLen zurück.

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

Wörterbuchsuche (Alternative Übersetzungen)

Mithilfe des -Endpunks können Sie alternative Übersetzungen für ein Wort oder einen Satz abrufen. Wenn Sie beispielsweise das Wort „Shark“ aus en in es übersetzen, gibt dieser Endpunkt sowohl „tiburón“ als auch „escualo“ zurück.

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

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen. Wir möchten dies aufschlüsseln, da der JSON-Code komplexer als viele der anderen Beispiele in diesem Artikel ist. Das Array translations enthält eine Liste mit Übersetzungen. Jedes Objekt in diesem Array umfasst eine Vertrauensbewertung (confidence), den für die Anzeige auf dem Endbenutzerdisplay optimierten Text (displayTarget), den normalisierten Text (normalizedText), den Teil der Sprache (posTag) und Informationen über frühere Übersetzungen (backTranslations). Weitere Informationen über die Antwort finden Sie unter Wörterbuchsuche

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

Wörterbuchbeispiele (Übersetzungen im Kontext)

Nachdem Sie eine Wörterbuchsuche durchgeführt haben, können Sie den Ausgangstext und die Übersetzung an den dictionary/examples-Endpunkt übergeben, um eine Liste mit Beispielen zu erhalten, in denen beide Begriffe im Kontext eines Satzes oder Ausdrucks gezeigt werden. Ausgehend vom vorherigen Beispiel verwenden Sie den normalizedText und das normalizedTarget aus der Antwort der Wörterbuchsuche als text bzw. translation. Die Parameter für die Ausgangssprache (from) und das Ausgabeziel (to) sind erforderlich.

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

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen. Weitere Informationen über die Antwort finden Sie unter Wörterbuchsuche

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

Problembehandlung

Allgemeine HTTP-Statuscodes

HTTP-Statuscode BESCHREIBUNG Mögliche Ursache
200 OK Die Anforderung wurde erfolgreich gesendet.
400 Ungültige Anforderung Ein erforderlicher Parameter fehlt, ist leer oder Null. Oder der an einen erforderlichen oder optionalen Parameter übergebene Wert ist ungültig. Ein häufiges Problem sind zu lange Kopfzeilen.
401 Nicht autorisiert Die Anforderung ist nicht autorisiert. Stellen Sie sicher, dass Ihr Abonnementschlüssel oder -token gültig ist und sich in der richtigen Region befindet. Siehe auch Authentifizierung.
429 Zu viele Anforderungen Sie haben das Kontingent oder die Rate der Anforderungen überschritten, das bzw. die für Ihr Abonnement zulässig ist.
502 Ungültiges Gateway Netzwerk- oder serverseitiges Problem. Kann auch auf ungültige Header hinweisen.

Java-Benutzer

Wenn Verbindungsprobleme auftreten, ist möglicherweise das SSL-Zertifikat abgelaufen. Installieren Sie zum Beheben dieses Problems DigiCertGlobalRootG2.crt im privaten Speicher.

Nächste Schritte