Best practice

Ok, I have a question on what would be the best practice for a translator...

If you have 5 languages: English, Chinese, German, French, and Swedish and you have different methods for converting each one into each other what would bet he best practice

Heres an example: If you selected Chinese as the starting Language and English as the Ending Language it'll return "zh-CN%7Cen" as the code needed to post.

I'm thinking i'll create an enum to store all the languages and then create
a struct that takes the enum twice, once for starting and once for ending, and then a value.

so i'll have something like

struct LanguagePairs
{
Lang langStart;
Lang langEnd;
String code;
}
and then a list that holds them all

List<LangPairs> list = new List<LangPairs>();

list.AddRange(new LangPair[]
{
new LangPair(Lang.Chinese, Lang.English, "zh-CN%7Cen"),
new LangPair(Lang.English, Lang.Chinese, "en%7zh-CN")
}

is there a better way to do this

Answer this question

Best practice

Joseph Stalin
This is the code i've came up with so far, Let me know if you guys have better ideas

using System;
using System.Data;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.IO;
using System.Web;
namespace SontekNET.Google
{
public enum Language
{
English,
German,
Spanish,
French,
Italian,
Portuguese,
Japanese,
Korean,
Chinese
}
public struct LanguagePair
{
private Language language;
public Language Language
{
get { return language; }
set { language = value; }
}
private string code;
public string Code
{
get { return code; }
set { code = value; }
}
public LanguagePair(Language lang, string value)
{
this.language = lang;
this.code = value;
}

}
public struct AvailableConversion
{
private Language startingLanguage;
public Language StartingLanguage
{
get { return startingLanguage; }
set { startingLanguage = value; }
}

private Language endingLanguage;
public Language EndingLanguage
{
get { return endingLanguage; }
set { endingLanguage = value; }
}
public AvailableConversion(Language start, Language end)
{
this.startingLanguage = start;
this.endingLanguage = end;
}
}
public class Translator
{
private string GetURL(string text, string langPair)
{
string value = HttpUtility.UrlEncode(text);
string pair = HttpUtility.UrlEncode(langPair);
string temp = String.Format(@"http://translate.google.com/translate_t text={0}&langpair={1}", value, pair);
return temp;
}
public List<LanguagePair> languages;
public List<AvailableConversion> conversions;
public Translator()
{
PopulateLanguages();
PopulateConversions();
}
#region <-- Screen Scraping -->
public List<DictionaryEntry> GetTranslatedText(Language startLanguage, string text)
{
List<DictionaryEntry> translations = new List<DictionaryEntry>();
foreach (AvailableConversion conv in conversions)
{
if (conv.StartingLanguage == startLanguage)
{
translations.Add(GetTranslatedText(text, conv.StartingLanguage, conv.EndingLanguage));
}
}
return translations;
}
public DictionaryEntry GetTranslatedText(string text, Language start, Language end)
{
string url = GetURL(text, GetLangPair(start, end));
WebRequest request = WebRequest.Create(url);
WebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string content = reader.ReadToEnd();

int startIndex = content.IndexOf("<textarea");
int startIndex2 = content.IndexOf(">", startIndex);
int endIndex = content.IndexOf("</textarea>", startIndex2);

string temp = content.Substring(startIndex2+1, endIndex - startIndex2-1);
return new DictionaryEntry(end, temp);
}
private string GetLangPair(Language start, Language end)
{
string code1 = String.Empty;
string code2 = String.Empty;
foreach (LanguagePair lang in languages)
{
if (lang.Language == start)
code1 = lang.Code;
if (lang.Language == end)
code2 = lang.Code;
}
return String.Format("{0}|{1}", code1, code2);
}
#endregion
#region <-- Populating Information -->
private void PopulateConversions()
{
conversions = new List<AvailableConversion>();

AddConversion(Language.English, Language.German, Language.Spanish,
Language.French, Language.Italian, Language.Portuguese,
Language.Korean, Language.Chinese);

AddConversion(Language.German, Language.French);
}
private void PopulateLanguages()
{
languages = new List<LanguagePair>();
languages.AddRange(new LanguagePair[]
{
new LanguagePair(Language.Chinese, "zh-CN"),
new LanguagePair(Language.English, "en"),
new LanguagePair(Language.French, "fr"),
new LanguagePair(Language.German, "de"),
new LanguagePair(Language.Italian, "it"),
new LanguagePair(Language.Japanese, "ja"),
new LanguagePair(Language.Korean, "ko"),
new LanguagePair(Language.Portuguese, "pt"),
new LanguagePair(Language.Spanish, "es")
});
}
private void AddConversion(Language lang1, params Language[] langs)
{
foreach (Language lang in langs)
{
conversions.Add(new AvailableConversion(lang1, lang));
conversions.Add(new AvailableConversion(lang, lang1));
}
}
#endregion
}
}
Nicorombe
You got a very long question. :) If it works, then you're set.
dalek

From a brief look: In general, classes are preferred to structs.
Best practice

Answer this question

Best practice

Hot Topic

Visual C#

Best practice

Best practice

Joseph Stalin

Nicorombe

dalek