protected override void OnCreateControl()
        {
            base.OnCreateControl();
            LanguageType selected = null;
            LanguageType temp = new LanguageType()
            {
                Language = NetLanguage.CSharp,
                Text = "C#",
            };
            if (ApplicationLanguage == NetLanguage.CSharp)
                selected = temp;

            Items.Add(temp);
            temp = new LanguageType()
            {
                Language = NetLanguage.VbNet,
                Text = "VB.NET",
            };
            if (ApplicationLanguage == NetLanguage.VbNet)
                selected = temp;
            Items.Add(temp);
            this.SelectedItem = selected;

            LanguageChange += new EventHandler<EventLanguage>(LanguageSelector_LanguageChange);
        }

 private static List<RawCompetitor> GetRawCompetitorInt(BrokerType brokerType, LanguageType languageType, SportType sportType, GenderType genderType, string[] names)
 {
     if (genderType == GenderType.Unknown) {
         _logger.Error("{0}: {1}", names.StrJoin(", "), genderType);
     }
     var competitorsRaw = RawCompetitor.DataSource.FilterByLanguage(languageType).FilterBySportType(sportType).FilterByBroker(brokerType)
                                         .FilterByNameCompetitor(names)
                                         .FilterByGender(genderType,
                 RawCompetitor.Fields.CompetitoruniqueID,
                 RawCompetitor.Fields.Name,
                 RawCompetitor.Fields.Linkstatus);
     if (competitorsRaw.Count > 1) {
         var groupBy = competitorsRaw.Where(c => c.CompetitoruniqueID != default(int)).GroupBy(c => c.CompetitoruniqueID).ToArray();
         if (groupBy.Length > 1) {
             _logger.Error("{0} {1} {2} {3} {4} <=> {5}", brokerType, sportType, genderType,
                 competitorsRaw.Select(cr => cr.ID).StrJoin(", "), names.StrJoin(", "), groupBy.Select(g => g.Select(ge => ge.Name).StrJoin(", ")).StrJoin(" | "));
             return groupBy.First().ToList();
         }
         if (groupBy.Length == 1) {
             foreach (var rawCompetitor in competitorsRaw.Where(cr => cr.CompetitoruniqueID == default(int))) {
                 rawCompetitor.CompetitoruniqueID = groupBy[0].Key;
                 rawCompetitor.Save();
             }
         }
     }
     return CreateRawCompetitor(names, competitorsRaw, brokerType, languageType, sportType, genderType);
 }

        private static List<RawCompetitor> CreateRawCompetitor(string[] names, List<RawCompetitor> competitorsRaw, BrokerType brokerType, LanguageType languageType, SportType sportType, GenderType genderType)
        {
            var existNames = competitorsRaw.Select(cr => cr.Name).ToList();
            names = names
                .Where(name => !existNames.Contains(name))
                .ToArray();
            if (names.Any()) {
                var lastCompetitorUniqueID = competitorsRaw.Any()
                    ? competitorsRaw.First().CompetitoruniqueID
                    : default(int);
                var raw = competitorsRaw;
                names
                    .Where(name => !raw.Any(c => c.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)))
                    .Each(name => {
                        RawCompetitor competitorRaw = null;
                        try {
                            competitorRaw = BrokerEntityIfaceCreator.CreateEntity<RawCompetitor>(brokerType, languageType, sportType, genderType, LinkEntityStatus.Unlinked, new[] { name },
                                competitor => {
                                    if (lastCompetitorUniqueID != default(int)) {
                                        competitor.CompetitoruniqueID = lastCompetitorUniqueID;
                                        competitor.Linkstatus = LinkEntityStatus.LinkByStatistics | LinkEntityStatus.Linked;
                                    }
                                });
                            competitorRaw.Save();
                            raw.Add(competitorRaw);
                        } catch (Exception ex) {
                            _logger.Error("{0}\r\n{1}", competitorRaw?.ToString(), ex);
                            throw;
                        }
                    });
            }

            return competitorsRaw;
        }

        public SolutionItem(Connect connect, Solution solution, bool recursive)
        {
            this._subItems = new List<SolutionItem>();
            this._projectType = LanguageType.None;

            if (connect == null)
            {
                throw new ArgumentNullException("connect");
            }

            if (solution == null)
            {
                throw new ArgumentNullException("solution");
            }

            this._incrementSetting = new SolutionItemIncrementSettings(this);
            this._connect = connect;
            this._item = solution;
            this._itemType = SolutionItemType.Solution;
            this._name = Path.GetFileNameWithoutExtension(solution.FileName);
            this._filename = solution.FileName;
            this._uniqueName = this._name;
            this.GetGlobalVariables();
            if (recursive)
            {
                SolutionItem.FillSolutionTree(connect, this, solution.Projects);
            }
        }

		public s_cache_language_pack LanguagePackGet(LanguageType lang)
		{
			if(languagePacks != null)
				return languagePacks[(int)lang];

			return null;
		}

 /// <summary>
 /// Configures the component using the dictionary of attributes specified
 /// in the configuration file.
 /// </summary>
 /// <param name="attributes">The attributes in the configuration element.</param>
 public void Configure(System.Collections.Specialized.StringDictionary attributes)
 {
     if(attributes.ContainsKey(ProjectTypeArgument))
     {
         language = (LanguageType)Enum.Parse(typeof(LanguageType), attributes[ProjectTypeArgument]);
     }
 }

    // Use this for initialization
    void Start()
    {
        if(this.GetComponent<UIPopupList>())
        {
            this.GetComponent<UIPopupList>().eventReceiver=this.gameObject;
            this.GetComponent<UIPopupList>().selection=PlayerPrefs.GetString("language", "English");
        }

        string language = PlayerPrefs.GetString("language", "English");
        if(lang==LanguageType.None)
        {
        if(language=="English")
        {
            lang=LanguageType.English;
        }
        else
        {
            lang=LanguageType.Japanese;
        }
        }

        LanguageChange[] targetObjs = LanguageUI.GetComponentsInChildren<LanguageChange>();

        foreach(LanguageChange lc in targetObjs)
        {
            lc.lang=lang;
            lc.ChangeLanguage();
        }
    }

 internal LanguageInfo(string name, string twoLetterCode, string threeLetterCode, LanguageFamily family, LanguageType type)
 {
     Name = name;
     TwoLetterIsoCode = twoLetterCode;
     ThreeLetterIsoCode = threeLetterCode;
     Family = family;
     Type = type;
 }

        public IHttpActionResult ByLanguage(LanguageType language)
        {
            var codeSnipetTitles = this.data
                .CodeSnipets
                .All()
                .Where(c => c.Language == language)
                .Select(CodeSnipetsPartialDataModel.FromCodeSnipet);

            return Ok(codeSnipetTitles);
        }

        public static async Task<List<string>> GetRandomWordsAsync(LanguageType language, SpeachPartType speachPart, int count) {
#if !NO_REDIS

            var key = GetListKey(language, speachPart);
            int listSize = (int)(await Db.ListLengthAsync(key));
            var startIndex = listSize > count ? new Random().Next(listSize - count) : 0;
            return Db.ListRange(key, startIndex, startIndex + count).Select(v => v.ToString()).ToList<string>();
#endif
            return null;
        }

 public Solution(string name, string text, string ip, int port, int apport, string logindatabase, string loginsolution, LanguageType language)
 {
     _Name = name;
     _Text = text;
     _IP = ip;
     _Port = port;
     _ApPort = apport;
     _LoginDataBase = logindatabase;
     _LoginSolution = loginsolution;
     _Language = language;
 }

 private VkApiLanguage GetVkLanguage(LanguageType language)
 {
     switch (language)
     {
         case LanguageType.Russian:
             return VkApiLanguage.Russian;
         case LanguageType.English:
             return VkApiLanguage.English;
         default:
             return VkApiLanguage.Russian;
     }
 }

 internal async Task<MonthPlanDto> GetMonthPlanDtoAsync(string userId, LanguageType languageType) {
     MonthPlanDto statisticDto = Redis.GetMonthPlan(userId, languageType);
     if (statisticDto == null) {
         MonthPlan monthPlan = await _db.GetThisMonthPlanAsync(userId, languageType);
         if (monthPlan == null) {
             int planedCount = CalculateMonthPlan(userId, languageType);
             monthPlan = await _db.CreateMonthPlanAsync(userId, languageType, planedCount);
         }
         statisticDto = new MonthPlanDto(monthPlan);
     }
     return statisticDto;
 }

 public ActionResult CompetitionItem(LanguageType languagetype, FilterModel<BrokerType> filter, StateFilter state = StateFilter.All)
 {
     var dateTime = DateTime.UtcNow.Date;
     if (filter.date == DateTime.MinValue) {
         filter.FixDates(dateTime, dateTime);
     }
     filter.FixDates(new DateTime(2014, 01, 01), dateTime.AddDays(14));
     return View(new StaticPageBaseModel<WithFilterModel<BrokerType, List<RawCompetitionTransport>>>(this) {
         ControllerModel = new WithFilterModel<BrokerType, List<RawCompetitionTransport>>(new FilterModel<BrokerType>("CompetitionItem", "SystemState", CurrentLanguage, FilterSettings.ToDate, filter, new RouteValueDictionary(new { languagetype, state }))) {
             Data = _provider.GetCompetitionItems(filter.id, languagetype, filter.date, state)
         }
     });
 }

        private async Task AddRandomWordsAsync(List<dynamic> words, LanguageType language, SpeachPartType speachPart, int count) {
#if !NO_REDIS
            List<string> list = await Redis.GetRandomWordsAsync(language, speachPart, count);
            foreach (string word in list) {
                words.Add(new {
                    id = ObjectId.GenerateNewId().ToString(),
                    language = language.ToString(),
                    speachPart = (int)speachPart,
                    word = word
                });
            }
#endif
        }

		public s_cache_language_pack LanguagePackGet(LanguageType lang)
		{
			switch(lang)
			{
				case LanguageType.English:		return English;
				case LanguageType.Japanese:		return Japanese;
				case LanguageType.German:		return German;
				case LanguageType.French:		return French;
				case LanguageType.Spanish:		return Spanish;
				case LanguageType.Italian:		return Italian;
				case LanguageType.Korean:		return Korean;
				case LanguageType.Chinese:		return Chinese;
				case LanguageType.Portuguese:	return Portuguese;
				default:						throw new Debug.Exceptions.UnreachableException(lang);
			}
		}

        public static void Initialize(LanguageType lid)
        {
            List<Language> langs = GetLanguages();

            foreach (Language lang in langs)
            {
                if (lang.ID == lid)
                {
                    Helpers.ConsolePrint("NICEHASH", "Selected language: " + lang.Name);
                    SelectedLanguage = lang;
                    return;
                }
            }
            
            Helpers.ConsolePrint("NICEHASH", "Critical error: missing language");
        }

 static NetLanguageList()
 {
     _Languages = new List<LanguageType>();
     LanguageType temp = new LanguageType()
     {
         Language = NetLanguage.CSharp,
         Text = "C#",
     };
     _Languages.Add(temp);
     temp = new LanguageType()
     {
         Language = NetLanguage.VbNet,
         Text = "VB.NET",
     };
     _Languages.Add(temp);
 }

 public CommandLineParser(string[] argv)
 {
     string tmpString;
     if(ParseCommandLine(argv, "-config", out tmpString)) {
         Helpers.ConsolePrint("CommandLineParser", "-config parameter has been depreciated, run setting from GUI");
     }
     if (ParseCommandLine(argv, "-lang", out tmpString)) {
         IsLang = true;
         int tmp;
         // if parsing fails set to default
         if (Int32.TryParse(tmpString, out tmp)) {
             LangValue = (LanguageType)tmp;
         } else {
             LangValue = LanguageType.En;
         }
     }
 }

        public static string RunReadOnly(string viewName, string providerName, LanguageType lang)
        {
            string templateText = GetTemplateText(TemplateType.ReadOnly, lang);

            //set the provider and tablename
            templateText = templateText.Replace("#VIEW#", viewName);
            templateText = templateText.Replace("#PROVIDER#", providerName);

            string result = string.Empty;
            Template t = new Template(templateText);
            result = t.Render();

            result = SrubOutput(result);

            if (result == string.Empty)
                throw new Exception(t.Error);
            return result;
        }