public override void Translate(ITranslationSession translationSession)
        {
            using (var client = new TerminologyClient(_binding, _endpoint))
            {
                var translationSources = new TranslationSources()
                {
                    TranslationSource.UiStrings
                };
                foreach (var item in translationSession.Items)
                {
                    if (translationSession.IsCanceled)
                    {
                        break;
                    }

                    Contract.Assume(item != null);

                    var targetCulture = item.TargetCulture.Culture ?? translationSession.NeutralResourcesLanguage;
                    if (targetCulture.IsNeutralCulture)
                    {
                        targetCulture = CultureInfo.CreateSpecificCulture(targetCulture.Name);
                    }

                    try
                    {
                        var response = client.GetTranslations(item.Source, translationSession.SourceLanguage.Name,
                                                              targetCulture.Name, SearchStringComparison.CaseInsensitive, SearchOperator.Contains,
                                                              translationSources, false, 5, false, null);

                        if (response != null)
                        {
                            translationSession.Dispatcher.BeginInvoke(() =>
                            {
                                Contract.Requires(item != null);
                                Contract.Requires(response != null);

                                foreach (var match in response)
                                {
                                    Contract.Assume(match != null);
                                    foreach (var trans in match.Translations)
                                    {
                                        item.Results.Add(new TranslationMatch(this, trans.TranslatedText, match.ConfidenceLevel / 100.0));
                                    }
                                }
                            });
                        }
                    }
                    catch (Exception ex)
                    {
                        translationSession.AddMessage(DisplayName + ": " + ex.Message);
                        break;
                    }
                }
            }
        }
        static void Main(string[] args)
        {
            tc = new TerminologyClient();
            ts = new TranslationSources()
            {
                TranslationSource.Terms, TranslationSource.UiStrings
            };

            SearchStringComparison ssc = (args.Length > 3) && args[3] == "usecase" ? SearchStringComparison.CaseSensitive : SearchStringComparison.CaseInsensitive;

            tc.GetTranslationsCompleted += tc_GetTranslationsCompleted;
            tc.GetLanguagesCompleted    += tc_GetLanguagesCompleted;

            if (args.Length < 3)
            {
                tc.GetLanguagesAsync();
                waitForResults = true;
                while (waitForResults)
                {
                    Console.WriteLine("Waiting for languages retrieval results...\n");
                }

                string exeName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
                Console.WriteLine("\n\n\n\nUsage: " + exeName + " \"phrase\"" + " \"source lang\"" + " \"dest lang\"" + " \"");

                //Console.WriteLine("\n\n\n\nPress any key to exit...");
                //Console.ReadKey();
                return;
            }

            Console.WriteLine("Querying Translation Service...\n");

            tc.GetTranslationsAsync(args[0],
                                    args[1],
                                    args[2],
                                    ssc,
                                    SearchOperator.Contains,
                                    ts,
                                    false,
                                    20,
                                    true,
                                    null);

            waitForResults = true;
            while (waitForResults)
            {
                Console.WriteLine("Waiting for translation results...\n");
            }

            //Console.WriteLine("\n\n\n\nPress any key to exit...\n");
            //Console.ReadKey();
        }
        public override void Translate(ITranslationSession translationSession)
        {
            using (var client = new TerminologyClient(_binding, _endpoint))
            {
                var translationSources = new TranslationSources {
                    TranslationSource.UiStrings
                };

                foreach (var item in translationSession.Items)
                {
                    if (translationSession.IsCanceled)
                    {
                        break;
                    }

                    var targetCulture = item.TargetCulture.Culture ?? translationSession.NeutralResourcesLanguage;
                    if (targetCulture.IsNeutralCulture)
                    {
                        targetCulture = CultureInfo.CreateSpecificCulture(targetCulture.Name);
                    }

                    try
                    {
                        var response = client.GetTranslations(item.Source, translationSession.SourceLanguage.Name,
                                                              targetCulture.Name, SearchStringComparison.CaseInsensitive, SearchOperator.Contains,
                                                              translationSources, false, 5, false, null);

                        if (response != null)
                        {
                            var matches = response
                                          .SelectMany(match => match?.Translations?.Select(trans => new TranslationMatch(this, trans?.TranslatedText, match.ConfidenceLevel / 100.0)))
                                          .Where(m => m?.TranslatedText != null)
                                          .Distinct(TranslationMatch.TextComparer);

                            translationSession.Dispatcher.BeginInvoke(() =>
                            {
                                item.Results.AddRange(matches);
                            });
                        }
                    }
                    catch (Exception ex)
                    {
                        translationSession.AddMessage(DisplayName + ": " + ex.Message);
                        break;
                    }
                }
            }
        }
示例#4
0
        public override async Task Translate(ITranslationSession translationSession)
        {
            using (var client = new TerminologyClient(_binding, _endpoint))
            {
                var translationSources = new TranslationSources {
                    TranslationSource.UiStrings
                };

                foreach (var item in translationSession.Items)
                {
                    if (translationSession.IsCanceled)
                    {
                        break;
                    }

                    var targetCulture = item.TargetCulture.Culture ?? translationSession.NeutralResourcesLanguage;
                    if (targetCulture.IsNeutralCulture)
                    {
                        targetCulture = CultureInfo.CreateSpecificCulture(targetCulture.Name);
                    }

                    try
                    {
                        var response = await client.GetTranslationsAsync(
                            item.Source, translationSession.SourceLanguage.Name,
                            targetCulture.Name, SearchStringComparison.CaseInsensitive, SearchOperator.Contains,
                            translationSources, false, 5, false, null)
                                       .ConfigureAwait(false);

                        if (response != null)
                        {
                            var matches = response
                                          .SelectMany(match => match?.Translations?.Select(trans => new TranslationMatch(this, trans?.TranslatedText, match.ConfidenceLevel / 100.0)))
                                          .Where(m => m?.TranslatedText != null)
                                          .Distinct(TranslationMatch.TextComparer);

#pragma warning disable CS4014 // Because this call is not awaited ... => just push out results, no need to wait.
                            translationSession.MainThread.StartNew(() => item.Results.AddRange(matches));
                        }
                    }
                    catch (Exception ex)
                    {
                        translationSession.AddMessage(DisplayName + ": " + ex.Message);
                        break;
                    }
                }
            }
        }
        /// <summary>
        /// Create a new instance of the GroupShare API v1 client using the specified connection.
        /// </summary>
        /// <param name="connection">The underlying <seealso cref="IConnection"/> used to make requests</param>
        public GroupShareClient(IConnection connection)
        {
            Ensure.ArgumentNotNull(connection, "connection");

            Connection = connection;
            var apiConnection = new ApiConnection(connection);

            Project             = new ProjectClient(apiConnection);
            User                = new UserClient(apiConnection);
            Organization        = new OrganizationClient(apiConnection);
            Authenticate        = new AuthenticateClient(apiConnection);
            Role                = new RoleClient(apiConnection);
            Permission          = new PermissionClient(apiConnection);
            ModuleClient        = new ModuleClient(apiConnection);
            License             = new LicenseClient(apiConnection);
            TranslationMemories = new TranslationMemoriesClient(apiConnection);
            Terminology         = new TerminologyClient(apiConnection);
        }
示例#6
0
        protected override async Task Translate(ITranslationSession translationSession)
        {
            using (var client = new TerminologyClient(_binding, _endpoint))
            {
                var translationSources = new TranslationSources {
                    TranslationSource.UiStrings
                };

                foreach (var item in translationSession.Items)
                {
                    if (translationSession.IsCanceled)
                    {
                        break;
                    }

                    var targetCulture = item.TargetCulture.Culture ?? translationSession.NeutralResourcesLanguage;
                    if (targetCulture.IsNeutralCulture)
                    {
                        targetCulture = CultureInfo.CreateSpecificCulture(targetCulture.Name);
                    }

                    var response = await client.GetTranslationsAsync(
                        item.Source, translationSession.SourceLanguage.Name,
                        targetCulture.Name, SearchStringComparison.CaseInsensitive, SearchOperator.Contains,
                        translationSources, false, 5, false, null)
                                   .ConfigureAwait(false);

                    if (response != null)
                    {
                        var matches = response
                                      .SelectMany(match => match?.Translations?.Select(trans => new TranslationMatch(this, trans?.TranslatedText, Ranking * match.ConfidenceLevel / 100.0)))
                                      .Where(m => m?.TranslatedText != null)
                                      .Distinct(TranslationMatch.TextComparer);

                        await translationSession.MainThread.StartNew(() => item.Results.AddRange(matches)).ConfigureAwait(false);
                    }
                }
            }
        }