多线程翻译

Question

The following loop translates the English word "Welcome" to a couple other languages.

var result = "";

foreach (var toLanguage in OtherLanguages)
{
   result += LanguageUtils.Translate("Welcome", English, toLanguage);
}

return result;

LanguageUtils.Translate() is a static method that uses Microsoft Translator V2 engine. Everything works fine so far. Except for the performance.

I was wondering if I could speed things up a little bit by using multiple threads inside my loop. So, instead of translating one language after another (as I do) I would run multiple translations at the same time.

Now, I read a couple post and tutorials about MultiThreading (eg http://www.albahari.com/threading/ ), but to be honest with you, I'm quite confused after all. That's the first time I was dealing with multi threading ... and probably the last time. So I was hoping if anybody experienced could help me out with some piece of code that shows me how to convert my given code snippet into a multi threading approach.

Thanks very much!

Answer 1

use parallel linq as available in .NET 4:

    return OtherLanguages.AsParallel()
                         .Select(toLanguage => LanguageUtils.Translate("Welcome", English, toLanguage));

Answer 2

ConcurrentBag<string> results = new ConcurrentBag<string>();
Parallel.ForEach(OtherLanguages,toLanguage =>
{
    results.Add(LanguageUtils.Translate("Welcome", English, toLanguage));
});

or

ConcurrentDictionary<string,string> results = new ConcurrentDictionary<string,string>();
Parallel.ForEach(OtherLanguages, toLanguage =>
{
    results.TryAdd(toLanguage, LanguageUtils.Translate("Welcome", English, toLanguage));
});

Answer 3

Using .NET 4.0 you can do:

 
 
 
  
  volatile StringBuilder result = new StringBuilder(); void Magic() { Parallel.ForEach(OtherLanguages, toLanguage => { var resultIn = result; var txt = LanguageUtils.Translate("Welcome", English, toLanguage); do Thread.SpinWait(25); while (Interlocked.CompareExchange(ref result, result.Append(txt), resultIn) != result); }); }
 
  

UPDATE: DON'T USE THE CODE ABOVE

The code isn't treadsafe, as result.Append modifies the result reference object in-place without proper locking. Also, because Append returns the same StringBuilder reference, Interlocked.CompareExchange doesn't actually do anything, except perhaps cause the call to Append to be repeated.

The code above introduces a huge perfomance bottleneck, since result.Append(txt) needs to evaluate BEFORE CompareExchange can be called. So each time a Thread has to spin, it also has to evaluate result.Append(txt) again.

An alternative suggested by @sehe:

string.Join(", ", langs.AsParallel().Select(l => Translate("Welcome", English, l)));

Answer 4

In my own freeware tool to edit and translate string resources ( this one ) I provide both interfaces to Google Translate (discontinued as of december 2011) and Microsoft Bing Translator.

From my own experiences as well as what users reported me, Bing is rather pettish when it comes to too much requests and/or pseudo spam detection.

So I pretty much assume that you can do complicated multi-threaded constructs in your code and still gain nothing since you will receive "too many requests" and the like exceptions then.

An alternative approach could be to build up your own lookup database (in-memory or persistent, just as what fits best your requirements) and look up subsequent translations first from your database and if it is not found there, go over to Bing.