Snabb start: kom igång med TranslatorQuickstart: Get started with Translator

I den här snabb starten lär du dig att använda Translator-tjänsten via REST.In this quickstart, you learn to use the Translator service via REST. Du börjar med Basic-exempel och går vidare till några viktiga konfigurations alternativ som ofta används under utvecklingen, inklusive:You start with basic examples and move onto some core configuration options that are commonly used during development, including:

FörutsättningarPrerequisites

  • Azure-prenumeration – skapa en kostnads frittAzure subscription - Create one for free
  • När du har en Azure-prenumeration kan du skapa en översättare-resurs i Azure Portal för att hämta din nyckel och slut punkt.Once you have an Azure subscription, create a Translator resource in the Azure portal to get your key and endpoint. När den har distribuerats väljer du gå till resurs.After it deploys, select Go to resource.
    • Du behöver nyckeln och slut punkten från resursen för att ansluta ditt program till Translator-tjänsten.You'll need the key and endpoint from the resource to connect your application to the Translator service. Du klistrar in nyckeln och slut punkten i koden nedan i snabb starten.You'll paste your key and endpoint into the code below later in the quickstart.
    • Du kan använda den kostnads fria pris nivån (F0) för att testa tjänsten och senare uppgradera till en betald nivå för produktion.You can use the free pricing tier (F0) to try the service, and upgrade later to a paid tier for production.

Plattforms konfigurationPlatform setup

  • Skapa ett nytt projekt: dotnet new console -o your_project_nameCreate a new project: dotnet new console -o your_project_name
  • Ersätt Program.cs med C#-koden som visas nedan.Replace Program.cs with the C# code shown below.
  • Ange prenumerations nyckel och slut punkts värden i Program.cs.Set the subscription key and endpoint values in Program.cs.
  • Lägg till Newtonsoft.Jsmed .net CLI.Add Newtonsoft.Json using .NET CLI.
  • Kör programmet från projekt katalogen: dotnet runRun the program from the project directory: dotnet run

SidhuvudenHeaders

När du anropar Translator-tjänsten via REST måste du se till att följande rubriker ingår i varje begäran.When calling the Translator service via REST, you'll need to make sure the following headers are included with each request. Oroa dig inte, vi inkluderar rubrikerna i exempel koden i följande avsnitt.Don't worry, we'll include the headers in the sample code in the following sections.

SidhuvudenHeaders BeskrivningDescription
Authentication-huvud (er)Authentication header(s) Begär ande huvud för begäran.Required request header.
Ocp-Apim-Subscription-Key

Nödvändigt begär ande huvud om du använder en Cognitive Services-resurs. Valfritt om du använder en översättare-resurs..Required request header if using a Cognitive Services Resource. Optional if using a Translator Resource..
Ocp-Apim-Subscription-Region

Se tillgängliga alternativ för autentisering.See available options for authentication.
Content-TypeContent-Type Begär ande huvud för begäran.Required request header.
Anger nytto lastens innehålls typ.Specifies the content type of the payload.
Accepterat värde är application/json; charset=UTF-8 .Accepted value is application/json; charset=UTF-8.
Innehålls längdContent-Length Begär ande huvud för begäran.Required request header.
Längden på begär ande texten.The length of the request body.
X-ClientTraceIdX-ClientTraceId Valfritt.Optional.
Ett GUID som skapats av klienten för att unikt identifiera begäran.A client-generated GUID to uniquely identify the request. Du kan utelämna det här huvudet om du inkluderar spårnings-ID: t i frågesträngen med hjälp av en frågeparameter med namnet ClientTraceId .You can omit this header if you include the trace ID in the query string using a query parameter named ClientTraceId.

Nycklar och slutpunkterKeys and endpoints

Exempel på den här sidan använder hårdkodade nycklar och slut punkter för enkelhetens skull.The samples on this page use hard-coded keys and endpoints for simplicity. Kom ihåg att ta bort nyckeln från koden när du är klar och publicera den aldrig offentligt.Remember to remove the key from your code when you're done, and never post it publicly. För produktion bör du överväga att använda ett säkert sätt att lagra och komma åt dina autentiseringsuppgifter.For production, consider using a secure way of storing and accessing your credentials. Mer information finns i säkerhets artikeln Cognitive Services.See the Cognitive Services security article for more information.

Översätt textTranslate text

Översättnings tjänstens kärn åtgärd är att översätta text.The core operation of the Translator service is to translate text. I det här avsnittet skapar du en begäran som tar en enda källa ( from ) och ger två utdata ( to ).In this section, you'll build a request that takes a single source (from) and provides two outputs (to). Sedan granskar vi vissa parametrar som kan användas för att justera både begäran och svaret.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);
        }
    }
}

Efter ett lyckat anrop bör du se följande svar:After a successful call, you should see the following response:

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

Identifiera språkDetect language

Om du vet att du behöver översättning, men inte känner till språket i texten som ska skickas till Translator-tjänsten, kan du använda språk identifierings åtgärden.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. Det finns mer än ett sätt att identifiera käll text språket.There's more than one way to identify the source text language. I det här avsnittet får du lära dig hur du använder språk identifiering med hjälp av translate slut punkten och detect slut punkten.In this section, you'll learn how to use language detection using the translate endpoint, and the detect endpoint.

Identifiera käll språk under översättningDetect source language during translation

Om du inte inkluderar from parametern i din översättnings förfrågan, försöker Translator-tjänsten identifiera käll textens språk.If you don't include the from parameter in your translation request, the Translator service will attempt to detect the source text's language. I svaret får du det identifierade språket ( language ) och en förtroende poäng ( score ).In the response, you'll get the detected language (language) and a confidence score (score). Det närmare score är att det 1.0 innebär ökad säkerhet att identifieringen är korrekt.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);
        }
    }
}

Efter ett lyckat anrop bör du se följande svar: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"
            }
        ]
    }
]

Identifiera käll språk utan ÖversättningDetect source language without translation

Du kan använda tjänsten Translator för att identifiera språket i käll texten utan att utföra en översättning.It's possible to use the Translator service to detect the language of source text without performing a translation. Om du vill göra det använder du /detect slut punkten.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);
        }
    }
}

När du använder /detect slut punkten inkluderar svaret alternativa identifieringar och kommer att meddela dig om översättning och transkriberingsspråk stöds för alla identifierade språk.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. Efter ett lyckat anrop bör du se följande svar: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
    }
]

Transkribera textTransliterate text

Transkriberingsspråk är en process för att konvertera ett ord eller en fras från skriptet (alfabetet) från ett språk till ett annat baserat på fonetisk likhet.Transliteration is the process of converting a word or phrase from the script (alphabet) of one language to another based on phonetic similarity. Du kan till exempel använda transkriberingsspråk för att konvertera "สวัสดี" ( thai ) till "sawatdi" ( latn ).For example, you could use transliteration to convert "สวัสดี" (thai) to "sawatdi" (latn). Det finns mer än ett sätt att utföra transkriberingsspråk.There's more than one way to perform transliteration. I det här avsnittet får du lära dig hur du använder språk identifiering med hjälp av translate slut punkten och transliterate slut punkten.In this section, you'll learn how to use language detection using the translate endpoint, and the transliterate endpoint.

Omtranslittererad under översättningTransliterate during translation

Om du översätter till ett språk som använder ett annat alfabet (eller fonem) än din källa kan du behöva en transkriberingsspråk.If you're translating into a language that uses a different alphabet (or phonemes) than your source, you might need a transliteration. I det här exemplet översätter vi "Hello" från engelska till Thai.In this example, we translate "Hello" from English to Thai. Förutom att hämta översättningen i Thai får du en transkriberingsspråk av den översatta frasen med hjälp av det latinska alfabetet.In addition to getting the translation in Thai, you'll get a transliteration of the translated phrase using the Latin alphabet.

Använd parametern för att hämta en transkriberingsspråk från translate slut punkten toScript .To get a transliteration from the translate endpoint, use the toScript parameter.

Anteckning

En fullständig lista över tillgängliga språk och transkriberingsspråk-alternativ finns i språk stöd.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);
        }
    }
}

Efter ett lyckat anrop bör du se följande svar.After a successful call, you should see the following response. Tänk på att svar från translate slut punkten inkluderar det identifierade käll språket med en förtroende poäng, en översättning som använder alfabetet i utmatnings språket och en transkriberingsspråk med hjälp av det latinska alfabetet.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"
                }
            }
        ]
    }
]

Translittererad utan ÖversättningTransliterate without translation

Du kan också använda transliterate slut punkten för att hämta en transkriberingsspråk.You can also use the transliterate endpoint to get a transliteration. När du använder transkriberingsspråk-slutpunkten måste du ange käll språket ( language ), käll skriptet/alfabetet ( fromScript ) och utdata-skriptet/alfabetet ( toScript ) som parametrar.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. I det här exemplet ska vi hämta transkriberingsspråk för สวัสดี.In this example, we're going to get the transliteration for สวัสดี.

Anteckning

En fullständig lista över tillgängliga språk och transkriberingsspråk-alternativ finns i språk stöd.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);
        }
    }
}

Efter ett lyckat anrop bör du se följande svar.After a successful call, you should see the following response. Till skillnad från anropet till translate slut punkten transliterate returnerar bara script och utdata text .Unlike the call to the translate endpoint, transliterate only returns the script and the output text.

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

Hämta menings längdGet sentence length

Med tjänsten Translator kan du hämta antalet bokstäver för en mening eller en serie med meningar.With the Translator service, you can get the character count for a sentence or series of sentences. Svaret returneras som en matris med antalet characters för varje mening som identifieras.The response is returned as an array, with character counts for each sentence detected. Du kan hämta menings längder med- translate och- breaksentence slut punkterna.You can get sentence lengths with the translate and breaksentence endpoints.

Hämta menings längd under översättningGet sentence length during translation

Du kan hämta antal tecken för både käll text och översättnings utdata med translate slut punkten.You can get character counts for both source text and translation output using the translate endpoint. Om du vill returnera meningens längd ( srcSenLen och transSenLen ) måste du ange includeSentenceLength parametern till 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);
        }
    }
}

Efter ett lyckat anrop bör du se följande svar.After a successful call, you should see the following response. Förutom det identifierade käll språket och översättningen får du antalet träffar för varje identifierad mening för både källan ( srcSentLen ) och översättningen ( 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"
            }
        ]
    }
]

Hämta menings längd utan ÖversättningGet sentence length without translation

Med tjänsten Translator kan du också begära menings längd utan översättning med breaksentence slut punkten.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);
        }
    }
}

Efter ett lyckat anrop bör du se följande svar.After a successful call, you should see the following response. Till skillnad från anropet till translate slut punkten breaksentence returnerar bara antalet tecken för käll texten i en matris som kallas 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
        ]
    }
]

Sökning efter ord listor (alternativa översättningar)Dictionary lookup (alternate translations)

Med slut punkten kan du hämta alternativa översättningar för ett ord eller en fras.With the endpoint, you can get alternate translations for a word or phrase. Vid översättning av ordet "haj" från en till es , returnerar den här slut punkten både "Tiburón" och "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);
        }
    }
}

Efter ett lyckat anrop bör du se följande svar.After a successful call, you should see the following response. Vi tar bort den här åtgärden eftersom JSON är mer komplex än några av de andra exemplen i den här artikeln.Let's break this down since the JSON is more complex than some of the other examples in this article. translationsMatrisen innehåller en lista över översättningar.The translations array includes a list of translations. Varje objekt i den här matrisen innehåller en förtroende poäng ( confidence ), den text som är optimerad för slut användar visning ( displayTarget ), den normaliserade texten ( normalizedText ), delen av tal ( posTag ) och information om tidigare översättning ( 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). Mer information om svaret finns i ord lista för sökningFor 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": ""
            }
        ]
    }
]

Exempel på ord listor (översättningar i sammanhang)Dictionary examples (translations in context)

När du har gjort en ord lista kan du skicka käll texten och översättningen till dictionary/examples slut punkten för att få en lista över exempel som visar båda termerna i en menings eller Frass kontext.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. Genom att skapa i föregående exempel använder du normalizedText och normalizedTarget från Sök efter ord listans svar som text translation respektive.Building on the previous example, you'll use the normalizedText and normalizedTarget from the dictionary lookup response as text and translation respectively. Parametrarna för käll språk ( from ) och utmatnings mål ( to ) måste anges.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);
        }
    }
}

Efter ett lyckat anrop bör du se följande svar.After a successful call, you should see the following response. Mer information om svaret finns i ord lista för sökningFor 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"
    }
]

FelsökningTroubleshooting

Java-användareJava users

Om du stöter på anslutnings problem kan det bero på att ditt SSL-certifikat har upphört att gälla.If you're encountering connection issues, it may be that your SSL certificate has expired. Lös problemet genom att installera DigiCertGlobalRootG2. CRT i ditt privata arkiv.To resolve this issue, install the DigiCertGlobalRootG2.crt to your private store.

Nästa stegNext steps

Se ävenSee also