/// <summary>Snippet for DetectLanguageAsync</summary>
public async Task DetectLanguageAsync()
{
// Snippet: DetectLanguageAsync(string,string,string,IDictionary<string, string>,CallSettings)
// Additional: DetectLanguageAsync(string,string,string,IDictionary<string, string>,CancellationToken)
// Create client
TranslationServiceClient translationServiceClient = await TranslationServiceClient.CreateAsync();
// Initialize request argument(s)
string formattedParent = new LocationName("[PROJECT]", "[LOCATION]").ToString();
string model = "";
string mimeType = "";
IDictionary <string, string> labels = new Dictionary <string, string>();
// Make the request
DetectLanguageResponse response = await translationServiceClient.DetectLanguageAsync(formattedParent, model, mimeType, labels);
// End snippet
}
/// <summary>Snippet for ListGlossaries</summary>
public void ListGlossaries_RequestObject()
{
// Snippet: ListGlossaries(ListGlossariesRequest,CallSettings)
// Create client
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
// Initialize request argument(s)
ListGlossariesRequest request = new ListGlossariesRequest
{
Parent = new LocationName("[PROJECT]", "[LOCATION]").ToString(),
};
// Make the request
PagedEnumerable <ListGlossariesResponse, Glossary> response =
translationServiceClient.ListGlossaries(request);
// Iterate over all response items, lazily performing RPCs as required
foreach (Glossary item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListGlossariesResponse page in response.AsRawResponses())
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Glossary item in page)
{
Console.WriteLine(item);
}
}
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <Glossary> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Glossary item in singlePage)
{
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
/// <summary>Snippet for GetGlossaryAsync</summary>
public async Task GetGlossaryAsync_RequestObject()
{
// Snippet: GetGlossaryAsync(GetGlossaryRequest,CallSettings)
// Additional: GetGlossaryAsync(GetGlossaryRequest,CancellationToken)
// Create client
TranslationServiceClient translationServiceClient = await TranslationServiceClient.CreateAsync();
// Initialize request argument(s)
GetGlossaryRequest request = new GetGlossaryRequest
{
Name = new GlossaryName("[PROJECT]", "[LOCATION]", "[GLOSSARY]").ToString(),
};
// Make the request
Glossary response = await translationServiceClient.GetGlossaryAsync(request);
// End snippet
}
/// <summary>Snippet for GetSupportedLanguagesAsync</summary>
public async Task GetSupportedLanguagesAsync_RequestObject()
{
// Snippet: GetSupportedLanguagesAsync(GetSupportedLanguagesRequest,CallSettings)
// Additional: GetSupportedLanguagesAsync(GetSupportedLanguagesRequest,CancellationToken)
// Create client
TranslationServiceClient translationServiceClient = await TranslationServiceClient.CreateAsync();
// Initialize request argument(s)
GetSupportedLanguagesRequest request = new GetSupportedLanguagesRequest
{
Parent = new LocationName("[PROJECT]", "[LOCATION]").ToString(),
};
// Make the request
SupportedLanguages response = await translationServiceClient.GetSupportedLanguagesAsync(request);
// End snippet
}
/// <summary>
/// Lists all the glossaries for a given project.
/// </summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
public static void ListGlossariesSample(string projectId = "[Google Cloud Project ID]")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
ListGlossariesRequest request = new ListGlossariesRequest
{
ParentAsLocationName = new LocationName(projectId, "us-central1"),
};
PagedEnumerable <ListGlossariesResponse, Glossary> response = translationServiceClient.ListGlossaries(request);
// Iterate over glossaries and display each glossary's details.
foreach (Glossary item in response)
{
Console.WriteLine($"Glossary name: {item.Name}");
Console.WriteLine($"Entry count: {item.EntryCount}");
Console.WriteLine($"Input URI: {item.InputConfig.GcsSource.InputUri}");
}
}
/// <summary>Snippet for ListGlossariesAsync</summary>
public async Task ListGlossariesAsync()
{
// Snippet: ListGlossariesAsync(LocationName,string,string,int?,CallSettings)
// Create client
TranslationServiceClient translationServiceClient = await TranslationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = new LocationName("[PROJECT]", "[LOCATION]");
string filter = "";
// Make the request
PagedAsyncEnumerable <ListGlossariesResponse, Glossary> response =
translationServiceClient.ListGlossariesAsync(parent, filter);
// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Glossary item) =>
{
// Do something with each item
Console.WriteLine(item);
});
// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListGlossariesResponse page) =>
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Glossary item in page)
{
Console.WriteLine(item);
}
});
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <Glossary> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Glossary item in singlePage)
{
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
public async static Task <String> googleTranslateApiV3(String textToTranslate, String targetLanguage, String projectName, ILogger logger, IOptions <GoogleTranslateApiCredentials> googleTranslateApiCredentials)
{
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT").Equals("Development"))
{
//var credential = GoogleCredential.GetApplicationDefaultAsync();
//Hostirano lokalno
TranslationServiceClientBuilder translationServiceClientBuilder = new TranslationServiceClientBuilder();
translationServiceClientBuilder.JsonCredentials = JsonConvert.SerializeObject(googleTranslateApiCredentials.Value);
TranslationServiceClient translationServiceClient = await translationServiceClientBuilder.BuildAsync();
TranslateTextRequest request = new TranslateTextRequest
{
Contents =
{
// The content to translate.
textToTranslate,
},
TargetLanguageCode = targetLanguage,
ParentAsLocationName = new LocationName(projectName, "global"),
};
TranslateTextResponse response = await translationServiceClient.TranslateTextAsync(request);
return(response.Translations[0].TranslatedText);
}
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT").Equals("Production"))
{
TranslationServiceClient translationServiceClient = await TranslationServiceClient.CreateAsync();
TranslateTextRequest request = new TranslateTextRequest
{
Contents =
{
// The content to translate.
textToTranslate,
},
TargetLanguageCode = targetLanguage,
ParentAsLocationName = new LocationName(projectName, "global"),
};
TranslateTextResponse response = await translationServiceClient.TranslateTextAsync(request);
return(response.Translations[0].TranslatedText);
}
return(null);
}
/// <summary>
/// Listing supported languages with target language code.
/// </summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="languageCode">Target Language Code.</param>
public static void GetSupportedLanguagesForTargetSample(string languageCode = "en",
string projectId = "[Google Cloud Project ID]")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
GetSupportedLanguagesRequest request = new GetSupportedLanguagesRequest
{
ParentAsLocationName = new LocationName(projectId, "global"),
DisplayLanguageCode = languageCode,
};
SupportedLanguages response = translationServiceClient.GetSupportedLanguages(request);
// List language codes of supported languages
foreach (SupportedLanguage language in response.Languages)
{
Console.WriteLine($"Language Code: {language.LanguageCode}");
Console.WriteLine($"Display Name: {language.DisplayName}");
}
}
public static string Translate(string text, string targetLanguage, string sourceLanguage)
{
var credentialsPath = Path.Combine(Directory.GetCurrentDirectory(), "service-account.json");
Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", credentialsPath);
var projectId = JObject.Parse(File.ReadAllText(credentialsPath)).SelectToken("project_id").ToString();
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
TranslateTextRequest request = new TranslateTextRequest
{
Contents = { text },
TargetLanguageCode = targetLanguage,
SourceLanguageCode = sourceLanguage,
ParentAsLocationName = new LocationName(projectId, "global")
};
TranslateTextResponse response = translationServiceClient.TranslateText(request);
return(response.Translations.FirstOrDefault()?.TranslatedText);
}
public static IEnumerable <string> GetTranslate(string projectID, string locationID, Language sourceLanguage, Language targetLanguage, string text, string modelID = "general/nmt")
{
TranslationServiceClient client = TranslationServiceClient.Create();
LocationName locationName = new LocationName(projectId: projectID, locationId: locationID);
TranslateTextRequest request = new TranslateTextRequest()
{
Parent = locationName.ToString(),
MimeType = "text/plain",
SourceLanguageCode = LanguageDic[sourceLanguage],
TargetLanguageCode = LanguageDic[targetLanguage],
Model = modelID,
Contents = { text },
};
TranslateTextResponse response = client.TranslateText(request);
return(response.Translations.Select(result => result.TranslatedText));
}
/// <summary>Snippet for TranslateTextAsync</summary>
public async Task TranslateTextAsync_RequestObject()
{
// Snippet: TranslateTextAsync(TranslateTextRequest,CallSettings)
// Additional: TranslateTextAsync(TranslateTextRequest,CancellationToken)
// Create client
TranslationServiceClient translationServiceClient = await TranslationServiceClient.CreateAsync();
// Initialize request argument(s)
TranslateTextRequest request = new TranslateTextRequest
{
Contents = { },
TargetLanguageCode = "",
ParentAsLocationName = new LocationName("[PROJECT]", "[LOCATION]"),
};
// Make the request
TranslateTextResponse response = await translationServiceClient.TranslateTextAsync(request);
// End snippet
}
/// <summary>
/// Translates a batch of texts on GCS and stores the result in a GCS location.
/// </summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="location">Region.</param>
/// <param name="inputUri">The GCS path where input configuration is stored.</param>
/// <param name="outputUri">The GCS path for translation output.</param>
/// <param name="sourceLanguage">Source language code.</param>
/// <param name="targetLanguage">Target language code.</param>
public static void BatchTranslateTextSample(string inputUri = "gs://cloud-samples-data/text.txt",
string outputUri = "gs://YOUR_BUCKET_ID/path_to_store_results/",
string projectId = "[Google Cloud Project ID]",
string location = "us-central1",
string sourceLanguage = "en",
string targetLanguage = "ja")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
BatchTranslateTextRequest request = new BatchTranslateTextRequest
{
ParentAsLocationName = new LocationName(projectId, location),
SourceLanguageCode = sourceLanguage,
TargetLanguageCodes =
{
targetLanguage,
},
InputConfigs =
{
new InputConfig
{
GcsSource = new GcsSource
{
InputUri = inputUri,
},
MimeType = "text/plain",
},
},
OutputConfig = new OutputConfig
{
GcsDestination = new GcsDestination
{
OutputUriPrefix = outputUri,
},
},
};
// Poll until the returned long-running operation is completed.
BatchTranslateResponse response = translationServiceClient.BatchTranslateText(request).PollUntilCompleted().Result;
Console.WriteLine($"Total Characters: {response.TotalCharacters}");
Console.WriteLine($"Translated Characters: {response.TranslatedCharacters}");
}
/// <summary>Snippet for BatchTranslateTextAsync</summary>
public async Task BatchTranslateTextAsync_RequestObject()
{
// Snippet: BatchTranslateTextAsync(BatchTranslateTextRequest,CallSettings)
// Create client
TranslationServiceClient translationServiceClient = await TranslationServiceClient.CreateAsync();
// Initialize request argument(s)
BatchTranslateTextRequest request = new BatchTranslateTextRequest
{
ParentAsLocationName = new LocationName("[PROJECT]", "[LOCATION]"),
SourceLanguageCode = "",
TargetLanguageCodes = { },
InputConfigs = { },
OutputConfig = new OutputConfig(),
};
// Make the request
Operation <BatchTranslateResponse, BatchTranslateMetadata> response =
await translationServiceClient.BatchTranslateTextAsync(request);
// Poll until the returned long-running operation is complete
Operation <BatchTranslateResponse, BatchTranslateMetadata> completedResponse =
await response.PollUntilCompletedAsync();
// Retrieve the operation result
BatchTranslateResponse result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <BatchTranslateResponse, BatchTranslateMetadata> retrievedResponse =
await translationServiceClient.PollOnceBatchTranslateTextAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
BatchTranslateResponse retrievedResult = retrievedResponse.Result;
}
// End snippet
}
private static string TranslateTo(string language, string source)
{
if (source == String.Empty || source == " ")
{
return(source);
}
Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS",
Environment.CurrentDirectory + "/../../../fresh-rampart-310520-4eafed6542f9.json");
TranslationServiceClient client = TranslationServiceClient.Create();
TranslateTextRequest request = new TranslateTextRequest
{
SourceLanguageCode = "en",
Contents = { IgnoreList.ReplaceIgnoreWords(source) },
TargetLanguageCode = language,
Parent = "projects/fresh-rampart-310520",
MimeType = "text/plain"
};
string xlation = "";
try
{
xlation = client.TranslateText(request).Translations[0].TranslatedText;
}
catch (Exception ex)
{
Console.Write(ex.Message);
Environment.Exit(-1);
}
// total hack. Google translate is removing trailing spaces
// c# API is very poorly documented, so this hack will have to do
// for now. Same with the HtmlDecode happening in the next line.
// Apparently you can tell the translator to use text instead of
// html, but again, not obvious where/how it the C# APIs.
if (source.EndsWith(" "))
{
xlation += " ";
}
return(HttpUtility.HtmlDecode(IgnoreList.ReAaddIgnoreWords(xlation)));
}
/// <summary>
/// Detects the language of a given text.
/// </summary>
/// <param name="text">The text string for performing language detection</param>
/// <param name="projectId">Your Google Cloud Project ID.</param>
public static void DetectLanguageSample(string text = "[TEXT_STRING_FOR_DETECTION]",
string projectId = "[Google Cloud Project ID]")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
DetectLanguageRequest request = new DetectLanguageRequest
{
ParentAsLocationName = new LocationName(projectId, "global"),
Content = text,
MimeType = "text/plain",
};
DetectLanguageResponse response = translationServiceClient.DetectLanguage(request);
// Display list of detected languages sorted by detection confidence.
// The most probable language is first.
foreach (DetectedLanguage language in response.Languages)
{
// The language detected
Console.WriteLine($"Language code: {language.LanguageCode}");
// Confidence of detection result for this language
Console.WriteLine($"Confidence: {language.Confidence}");
}
}
public static async Task <TranslationServiceClient> GetTranslationServiceClientAsync()
{
var path = Properties.Settings.Default.CredentialsPath;
if (!TranslationServiceClientCache.TryGetTarget(out var tuple) ||
tuple.CredentialsPath != path)
{
var client = string.IsNullOrWhiteSpace(path)
? await TranslationServiceClient.CreateAsync()
: await new TranslationServiceClientBuilder
{
CredentialsPath = path
}
.BuildAsync();
tuple = new TranslationServiceClientTuple {
Client = client, CredentialsPath = path
};
TranslationServiceClientCache.SetTarget(tuple);
}
return(tuple.Client);
}
/// <summary>
/// Translates a given text to a target language with glossary and custom model.
/// </summary>
/// <param name="modelId">Translation Model ID.</param>
/// <param name="glossaryId">Translation Glossary ID.</param>
/// <param name="text">The content to translate in string format</param>
/// <param name="targetLanguage">Required. Target language code.</param>
/// <param name="sourceLanguage">Optional. Source language code.</param>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="location"> Region.</param>
public static void TranslateTextWithGlossaryAndModelSample(
string modelId = "[YOUR_MODEL_ID]",
string glossaryId = "[YOUR_GLOSSARY_ID]",
string text = "[TEXT_TO_TRANSLATE]",
string targetLanguage = "ja",
string sourceLanguage = "en",
string projectId = "[Google Cloud Project ID]",
string location = "us-central1")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
string modelPath = $"projects/{projectId}/locations/{location}/models/{modelId}";
string glossaryPath = $"projects/{projectId}/locations/{location}/glossaries/{glossaryId}";
TranslateTextRequest request = new TranslateTextRequest
{
Contents =
{
// The content to translate.
text,
},
TargetLanguageCode = targetLanguage,
ParentAsLocationName = new LocationName(projectId, location),
Model = modelPath,
GlossaryConfig = new TranslateTextGlossaryConfig
{
// Translation Glossary path.
Glossary = glossaryPath,
},
SourceLanguageCode = sourceLanguage,
MimeType = "text/plain",
};
TranslateTextResponse response = translationServiceClient.TranslateText(request);
// Display the translation from given content using glossary and custom model.
foreach (Translation translation in response.GlossaryTranslations)
{
Console.WriteLine($"Translated text: {translation.TranslatedText}");
}
}
public async Task <ActionResult <IList <SupportedLanguage> > > GetGoogleTranslateLanguages()
{
TranslationServiceClient service = await translateServiceAccessor.InitializeServiceAsync();
string[] displayLanguageCodeList = { "en" };
#region Accept Header
if (Request.Headers.TryGetValue("Accept-Language", out StringValues value))
{
string[] accept_language_values = value.ToString().Split(',');
}
#endregion
int i = 0; // iterate over display language code list
IList <SupportedLanguage> response = null;
while (response == null)
{
string displayLanguageCode = (i < displayLanguageCodeList.Length) ? displayLanguageCodeList[i] : null;
if (displayLanguageCode == null)
{
break;
}
try {
SupportedLanguages temp = await service.GetSupportedLanguagesAsync(new GetSupportedLanguagesRequest {
Parent = GoogleCloudTranslateServiceAccessor.PARENT,
DisplayLanguageCode = displayLanguageCode,
});
response = temp.Languages;
} catch (Grpc.Core.RpcException) {
i++;
}
}
return(new ActionResult <IList <SupportedLanguage> >(response));
}
/// <summary>
/// Translates a given text to a target language.
/// </summary>
/// <param name="text">The content to translate.</param>
/// <param name="targetLanguage">Required. Target language code.</param>
/// <param name="projectId">Your Google Cloud Project ID.</param>
public static void TranslateTextSample(string text = "[TEXT_TO_TRANSLATE]",
string targetLanguage = "ja",
string projectId = "[Google Cloud Project ID]")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
TranslateTextRequest request = new TranslateTextRequest
{
Contents =
{
// The content to translate.
text,
},
TargetLanguageCode = targetLanguage,
ParentAsLocationName = new LocationName(projectId, "global"),
};
TranslateTextResponse response = translationServiceClient.TranslateText(request);
// Display the translation for each input text provided
foreach (Translation translation in response.Translations)
{
Console.WriteLine($"Translated text: {translation.TranslatedText}");
}
}
/// <summary>Snippet for CreateGlossaryAsync</summary>
public async Task CreateGlossaryAsync_RequestObject()
{
// Snippet: CreateGlossaryAsync(CreateGlossaryRequest,CallSettings)
// Create client
TranslationServiceClient translationServiceClient = await TranslationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateGlossaryRequest request = new CreateGlossaryRequest
{
ParentAsLocationName = new LocationName("[PROJECT]", "[LOCATION]"),
Glossary = new Glossary(),
};
// Make the request
Operation <Glossary, CreateGlossaryMetadata> response =
await translationServiceClient.CreateGlossaryAsync(request);
// Poll until the returned long-running operation is complete
Operation <Glossary, CreateGlossaryMetadata> completedResponse =
await response.PollUntilCompletedAsync();
// Retrieve the operation result
Glossary result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Glossary, CreateGlossaryMetadata> retrievedResponse =
await translationServiceClient.PollOnceCreateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Glossary retrievedResult = retrievedResponse.Result;
}
// End snippet
}
/// <summary>
/// Create Glossary.
/// </summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="glossaryId">Glossary ID.</param>
/// <param name="inputUri">Google Cloud Storage URI where glossary is stored in csv format.</param>
public static void CreateGlossarySample(string projectId = "[Google Cloud Project ID]",
string glossaryId = "[YOUR_GLOSSARY_ID]",
string inputUri = "gs://cloud-samples-data/translation/glossary_ja.csv")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
CreateGlossaryRequest request = new CreateGlossaryRequest
{
ParentAsLocationName = new LocationName(projectId, "us-central1"),
Parent = new LocationName(projectId, "us-central1").ToString(),
Glossary = new Glossary
{
Name = new GlossaryName(projectId, "us-central1", glossaryId).ToString(),
LanguageCodesSet = new Glossary.Types.LanguageCodesSet
{
LanguageCodes =
{
"en", // source lang
"ja", // target lang
},
},
InputConfig = new GlossaryInputConfig
{
GcsSource = new GcsSource
{
InputUri = inputUri,
},
},
},
};
// Poll until the returned long-running operation is complete
Glossary response = translationServiceClient.CreateGlossary(request).PollUntilCompleted().Result;
Console.WriteLine("Created Glossary.");
Console.WriteLine($"Glossary name: {response.Name}");
Console.WriteLine($"Entry count: {response.EntryCount}");
Console.WriteLine($"Input URI: {response.InputConfig.GcsSource.InputUri}");
}
public void GettingStarted()
{
string projectId = TestEnvironment.GetTestProjectId();
// Sample: GettingStarted
TranslationServiceClient client = TranslationServiceClient.Create();
TranslateTextRequest request = new TranslateTextRequest
{
Contents = { "It is raining." },
TargetLanguageCode = "fr-FR",
Parent = new ProjectName(projectId).ToString()
};
TranslateTextResponse response = client.TranslateText(request);
// response.Translations will have one entry, because request.Contents has one entry.
Translation translation = response.Translations[0];
Console.WriteLine($"Detected language: {translation.DetectedLanguageCode}");
Console.WriteLine($"Translated text: {translation.TranslatedText}");
// End sample
Assert.Equal(1, response.Translations.Count);
Assert.Equal("en", translation.DetectedLanguageCode);
Assert.Equal("Il pleut.", translation.TranslatedText);
}
public async Task <IReadOnlyList <TranslationResult> > TranslateAsync(IEnumerable <string> texts, string targetLanguage, string sourceLanguage = null, CancellationToken ct = default)
{
var results = new List <TranslationResult>();
if (string.IsNullOrWhiteSpace(options.ProjectId))
{
for (var i = 0; i < texts.Count(); i++)
{
results.Add(TranslationResult.NotConfigured);
}
return(results);
}
if (!texts.Any())
{
return(results);
}
if (service == null)
{
service = new TranslationServiceClientBuilder().Build();
}
var request = new TranslateTextRequest
{
Parent = $"projects/{options.ProjectId}"
};
foreach (var text in texts)
{
request.Contents.Add(text);
}
request.TargetLanguageCode = GetLanguageCode(targetLanguage);
if (sourceLanguage != null)
{
request.SourceLanguageCode = GetLanguageCode(sourceLanguage);
}
request.MimeType = "text/plain";
try
{
var response = await service.TranslateTextAsync(request, ct);
foreach (var translation in response.Translations)
{
var language = GetSourceLanguage(translation.DetectedLanguageCode, sourceLanguage);
results.Add(new TranslationResult(translation.TranslatedText, language));
}
}
catch (RpcException ex)
{
var result = GetResult(ex.Status);
for (var i = 0; i < texts.Count(); i++)
{
results.Add(result);
}
}
return(results);
}
/// <summary>
/// Translates a batch of texts on GCS and stores the result in a GCS location.
/// Glossary is applied for translation.
/// A model is used for translation. Can be AutoML or General (built-in) Model.
/// </summary>
/// <param name="targetLanguage">Target language code.</param>
/// <param name="sourceLanguage">Source language code.</param>
/// <param name="modelId">Translation model ID.</param>
/// <param name="glossaryId">Translation Glossary ID.</param>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="location"> Region.</param>
/// <param name="inputUri">The GCS path where input configuration is stored.</param>
/// <param name="outputUri">The GCS path for translation output.</param>
public static void BatchTranslateTextWithGlossaryAndModelSample(
string inputUri = "gs://cloud-samples-data/translation/text_with_custom_model_and_glossary.txt",
string outputUri = "gs://YOUR_BUCKET_ID/path_to_store_results/",
string projectId = "[Google Cloud Project ID]",
string location = "us-central1",
string targetLanguage = "ja",
string sourceLanguage = "en",
string modelId = "[YOUR-MODEL-ID]",
string glossaryId = "[YOUR_GLOSSARY_ID]")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
string modelPath = $"projects/{projectId}/locations/{location}/models/{modelId}";
string glossaryPath = $"projects/{projectId}/locations/{location}/glossaries/{glossaryId}";
BatchTranslateTextRequest request = new BatchTranslateTextRequest
{
ParentAsLocationName = new LocationName(projectId, location),
SourceLanguageCode = sourceLanguage,
TargetLanguageCodes =
{
// Target language code.
targetLanguage,
},
InputConfigs =
{
new InputConfig
{
GcsSource = new GcsSource
{
InputUri = inputUri,
},
MimeType = "text/plain",
},
},
OutputConfig = new OutputConfig
{
GcsDestination = new GcsDestination
{
OutputUriPrefix = outputUri,
},
},
Models =
{
// A model is used for Translation.
{ targetLanguage, modelPath },
},
Glossaries =
{
{
targetLanguage, new TranslateTextGlossaryConfig
{
Glossary = glossaryPath,
}
},
},
};
// Poll until the returned long-running operation is completed.
BatchTranslateResponse response = translationServiceClient.BatchTranslateText(request).PollUntilCompleted().Result;
Console.WriteLine($"Total Characters: {response.TotalCharacters}");
Console.WriteLine($"Translated Characters: {response.TranslatedCharacters}");
}
