C# Language.ToString方法代码示例

    public static void changeLanguageTo(Language lang)
    {
        RedMetricsManager.get ().sendEvent(TrackingEvent.CONFIGURE, new CustomData(CustomDataTag.LANGUAGE, lang.ToString()));

        Localization.instance.currentLanguage = lang.ToString();

        MemoryManager.get ().configuration.language = lang;
        
        foreach(UILocalize localize in GameObject.FindObjectsOfType<UILocalize>()) {
            localize.Localize();
        }
    }

		public static CodeDomProvider CreateProvider(Language language, CompilerVersion version)
		{
			var providerOptions = GetProviderOptions(version);
			var provider = CodeDomProvider.CreateProvider(language.ToString(), providerOptions);

			return provider;
		}

        /// <summary>
        /// 获取用户基本信息（包括UnionID机制）
        /// </summary>
        /// <param name="accessToken"></param>
        /// <param name="openId">普通用户的标识，对当前公众号唯一</param>
        /// <param name="lang">zh_CN 简体，zh_TW 繁体，en 英语</param>
        /// <returns></returns>
        public static UserInfoJson User_Info(string accessToken, string openId, Language lang = Language.zh_CN)
        {
            string url = string.Format("https://api.weixin.qq.com/cgi-bin/user/info?access_token={0}&openid={1}&lang={2}",
                accessToken, openId, lang.ToString());
            return HTTPGet.GetJson<UserInfoJson>(url);

            //错误时微信会返回错误码等信息，JSON数据包示例如下（该示例为AppID无效错误）:
            //{"errcode":40013,"errmsg":"invalid appid"}
        }

	public void LoadLanguage(Language language) {
        currentLang = language;
        Debug.Log("Loading Language: " + language.ToString());
		strings.Clear ();
		string line;
		string[] splitLine = new string[2];
		Debug.Log(Application.dataPath);
		System.IO.StreamReader file = new System.IO.StreamReader(Application.dataPath + "/Translation/" + language.ToString() + ".txt");
		Debug.Log (file == null);
		while((line = file.ReadLine()) != null) {
			if (line.StartsWith ("#") || line.Length == 0) {
				continue;
			}
			splitLine = line.Split('=');
			strings.Add(splitLine[0], splitLine[1]);
		}
		file.Close();
       // PrintMap();
    }

        /// <summary>
        /// 获取用户信息
        /// </summary>
        /// <param name="accessTokenOrAppId">调用接口凭证</param>
        /// <param name="openId">普通用户的标识，对当前公众号唯一</param>
        /// <param name="lang">返回国家地区语言版本，zh_CN 简体，zh_TW 繁体，en 英语</param>
        /// <returns></returns>
        public static UserInfoJson Info(string accessTokenOrAppId, string openId, Language lang = Language.zh_CN)
        {
            return ApiHandlerWapper.TryCommonApi(accessToken =>
            {
                string url = string.Format("https://api.weixin.qq.com/cgi-bin/user/info?access_token={0}&openid={1}&lang={2}",
                    accessToken.AsUrlData(), openId.AsUrlData(), lang.ToString("g").AsUrlData());
                return HttpUtility.Get.GetJson<UserInfoJson>(url);

        //错误时微信会返回错误码等信息，JSON数据包示例如下（该示例为AppID无效错误）:
        //{"errcode":40013,"errmsg":"invalid appid"}

    }, accessTokenOrAppId);
        }

 /// <summary>
 /// Get a list of all runes asynchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="runeData">Data to retrieve.</param>
 /// <param name="language">Language of the data to be retrieved.</param>
 /// <returns>A RuneListStatic object containing all runes.</returns>
 public async Task<RuneListStatic> GetRunesAsync(Region region, RuneData runeData = RuneData.none,
     Language language = Language.en_US)
 {
     var wrapper = Cache.Get<RuneListStaticWrapper>(RunesCacheKey);
     if (wrapper != null && !(language != wrapper.Language | runeData != wrapper.RuneData))
     {
         return wrapper.RuneListStatic;
     }
     var json = await requester.CreateRequestAsync(
         string.Format(RuneRootUrl, region.ToString()),
         RootDomain,
         new List<string>
         {
             string.Format("locale={0}", language.ToString()),
             runeData == RuneData.none ?
                 string.Empty :
                 string.Format("runeListData={0}", runeData.ToString())
         });
     var runes = await Task.Factory.StartNew(() =>
         JsonConvert.DeserializeObject<RuneListStatic>(json));
     wrapper = new RuneListStaticWrapper(runes, language, runeData);
     Cache.Add(RunesCacheKey, wrapper);
     return wrapper.RuneListStatic;
 }

 /// <summary>
 /// Get a list of all runes synchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="runeData">Data to retrieve.</param>
 /// <param name="language">Language of the data to be retrieved.</param>
 /// <returns>A RuneListStatic object containing all runes.</returns>
 public RuneListStatic GetRunes(Region region, RuneData runeData = RuneData.none
     , Language language = Language.en_US)
 {
     var wrapper = Cache.Get<RuneListStaticWrapper>(RunesCacheKey);
     if (wrapper == null || language != wrapper.Language || runeData != wrapper.RuneData)
     {
         var json = requester.CreateRequest(
             string.Format(RuneRootUrl, region.ToString()),
             RootDomain,
             new List<string>
             {
                 string.Format("locale={0}", language.ToString()),
                 runeData == RuneData.none ?
                 string.Empty :
                 string.Format("runeListData={0}", runeData.ToString())
             });
         var runes = JsonConvert.DeserializeObject<RuneListStatic>(json);
         wrapper = new RuneListStaticWrapper(runes, language, runeData);
         Cache.Add(RunesCacheKey, wrapper);
     }
     return wrapper.RuneListStatic;
 }

 /// <summary>
 /// Get a mastery asynchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="masteryId">Id of the mastery to retrieve.</param>
 /// <param name="masteryData">Data to retrieve.</param>
 /// <param name="language">Language of th data to be retrieved.</param>
 /// <returns>A mastery.</returns>
 public async Task<MasteryStatic> GetMasteryAsync(Region region, int masteryId,
     MasteryData masteryData = MasteryData.none, Language language = Language.en_US)
 {
     var wrapper = Cache.Get<MasteryStaticWrapper>(MasteryCacheKey + masteryId);
     if (wrapper != null && wrapper.Language == language && wrapper.MasteryData == masteryData)
     {
         return wrapper.MasteryStatic;
     }
     var listWrapper = Cache.Get<MasteryListStaticWrapper>(MasteriesCacheKey);
     if (listWrapper != null && listWrapper.Language == language && listWrapper.MasteryData == masteryData)
     {
         return listWrapper.MasteryListStatic.Masteries.ContainsKey(masteryId) ? listWrapper.MasteryListStatic.Masteries[masteryId] : null;
     }
     var json = await requester.CreateRequestAsync(
         string.Format(MasteryRootUrl, region.ToString()) + string.Format(IdUrl, masteryId.ToString()),
         RootDomain,
         new List<string>
         {
             string.Format("locale={0}", language.ToString()),
             masteryData == MasteryData.none ?
                 string.Empty :
                 string.Format("masteryData={0}", masteryData.ToString())
         });
     var mastery = await Task.Factory.StartNew(() =>
         JsonConvert.DeserializeObject<MasteryStatic>(json));
     Cache.Add(MasteryCacheKey + masteryId
         , new MasteryStaticWrapper(mastery, language, masteryData));
     return mastery;
 }

        /// <summary>
        /// This method is to get the unique key for a UsingExpressionAst. The key is a base64 
        /// encoded string based on the text of the UsingExpressionAst.
        /// 
        /// This method is used when handling a script block that contains $using for Invoke-Command.
        /// 
        /// When run Invoke-Command targeting a machine that runs PSv3 or above, we pass a dictionary
        /// to the remote end that contains the key of each UsingExpressionAst and its value. This method
        /// is used to generate the key.
        /// </summary>
        /// <param name="usingAst">A using expression</param>
        /// <returns>Base64 encoded string as the key of the UsingExpressionAst</returns>
        internal static string GetUsingExpressionKey(Language.UsingExpressionAst usingAst)
        {
            Diagnostics.Assert(usingAst != null, "Caller makes sure the parameter is not null");

            // We cannot call ToLowerInvariant unconditionally, because usingAst might 
            // contain IndexExpressionAst in its SubExpression, such as
            //   $using:bar["AAAA"]
            // and the index "AAAA" might not get us the same value as "aaaa".
            //
            // But we do want a unique key to represent the same UsingExpressionAst's as much
            // as possible, so as to avoid sending redundant key-value's to remote machine. 
            // As a workaround, we call ToLowerInvariant when the SubExpression of usingAst 
            // is a VariableExpressionAst, because:
            //   (1) Variable name is case insensitive;
            //   (2) People use $using to refer to a variable most of the time.
            string usingAstText = usingAst.ToString();
            if (usingAst.SubExpression is Language.VariableExpressionAst)
            {
                usingAstText = usingAstText.ToLowerInvariant();
            }
            return StringToBase64Converter.StringToBase64String(usingAstText);
        }

 /// <summary>
 /// Get a summoner spell asynchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="summonerSpell">Summoner spell to retrieve.</param>
 /// <param name="summonerSpellData">Data to retrieve.</param>
 /// <param name="language">Language of the data to be retrieved.</param>
 /// <returns>A summoner spell.</returns>
 public async Task<SummonerSpellStatic> GetSummonerSpellAsync(Region region, SummonerSpell summonerSpell,
     SummonerSpellData summonerSpellData = SummonerSpellData.none, Language language = Language.en_US)
 {
     var wrapper = Cache.Get<SummonerSpellStaticWrapper>(SummonerSpellCacheKey +
         summonerSpell.ToCustomString());
     if (wrapper != null && wrapper.SummonerSpellData == summonerSpellData && wrapper.Language == language)
     {
         return wrapper.SummonerSpellStatic;
     }
     var listWrapper = Cache.Get<SummonerSpellListStaticWrapper>(SummonerSpellsCacheKey);
     if (listWrapper != null && listWrapper.SummonerSpellData == summonerSpellData
         && listWrapper.Language == language)
     {
         return listWrapper.SummonerSpellListStatic.SummonerSpells.ContainsKey(summonerSpell.ToCustomString()) ?
             listWrapper.SummonerSpellListStatic.SummonerSpells[summonerSpell.ToCustomString()] : null;
     }
     var json = await requester.CreateRequestAsync(
         string.Format(SummonerSpellRootUrl, region.ToString()) +
         string.Format(IdUrl, (int)summonerSpell),
         RootDomain,
         new List<string>
         {
             string.Format("locale={0}", language.ToString()),
             summonerSpellData == SummonerSpellData.none ?
                 string.Empty :
                 string.Format("spellData={0}", summonerSpellData.ToString())
         });
     var spell = await Task.Factory.StartNew(() =>
         JsonConvert.DeserializeObject<SummonerSpellStatic>(json));
     Cache.Add(SummonerSpellCacheKey + summonerSpell.ToCustomString(),
         new SummonerSpellStaticWrapper(spell, language, summonerSpellData));
     return spell;
 }

 /// <summary>
 /// Get a list of all summoner spells synchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="summonerSpellData">Data to retrieve.</param>
 /// <param name="language">Language of the data to be retrieved.</param>
 /// <returns>A SummonerSpellListStatic object containing all summoner spells.</returns>
 public SummonerSpellListStatic GetSummonerSpells(Region region,
     SummonerSpellData summonerSpellData = SummonerSpellData.none, Language language = Language.en_US)
 {
     var wrapper = Cache.Get<SummonerSpellListStaticWrapper>(SummonerSpellsCacheKey);
     if (wrapper == null || wrapper.Language != language || wrapper.SummonerSpellData != summonerSpellData)
     {
         var json = requester.CreateRequest(
             string.Format(SummonerSpellRootUrl, region.ToString()),
             RootDomain,
             new List<string>
             {
                 string.Format("locale={0}", language.ToString()),
                 summonerSpellData == SummonerSpellData.none ?
                 string.Empty :
                 string.Format("spellData={0}", summonerSpellData.ToString())
             });
         var spells = JsonConvert.DeserializeObject<SummonerSpellListStatic>(json);
         wrapper = new SummonerSpellListStaticWrapper(spells, language, summonerSpellData);
         Cache.Add(SummonerSpellsCacheKey, wrapper);
     }
     return wrapper.SummonerSpellListStatic;
 }

 /// <summary>
 /// Get maps synchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="language">Language of the data to be retrieved.</param>
 /// <param name="version">Version of the dragon API.</param>
 /// <returns>A list of objects representing maps.</returns>
 public List<MapStatic> GetMaps(Region region, Language language = Language.en_US, string version = "5.3.1")
 {
     var json = requester.CreateRequest(string.Format(MapRootUrl, region.ToString()), RootDomain,
         new List<string> {
             string.Format("locale={0}", language.ToString()),
             string.Format("version={0}", version)
         });
     return JsonConvert.DeserializeObject<MapStaticWrapper>(json).Data.Values.ToList();
 }

 /// <summary>
 /// Retrieve language strings synchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="language">Language of the data to be retrieved.</param>
 /// <param name="version">Version of the dragon API.</param>
 /// <returns>A object containing the language strings.</returns>
 public LanguageStringsData GetLanguageStrings(Region region, Language language = Language.en_US,
     string version = "5.3.1")
 {
     var json = requester.CreateRequest(string.Format(LanguageStringsRootUrl, region.ToString()), RootDomain,
         new List<string> {
             string.Format("locale={0}", language.ToString()),
             string.Format("version={0}", version)
         });
     return JsonConvert.DeserializeObject<LanguageStringsData>(json);
 }

 /// <summary>
 /// Get an item asynchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="itemId">Id of the item to retrieve.</param>
 /// <param name="itemData">Data to retrieve.</param>
 /// <param name="language">Language of the data to be retrieved.</param>
 /// <returns>An item.</returns>
 public async Task<ItemStatic> GetItemAsync(Region region, int itemId, ItemData itemData = ItemData.none,
     Language language = Language.en_US)
 {
     var wrapper = Cache.Get<ItemStaticWrapper>(ItemCacheKey + itemId);
     if (wrapper != null && wrapper.Language == language && wrapper.ItemData == itemData)
     {
         return wrapper.ItemStatic;
     }
     var listWrapper = Cache.Get<ItemListStaticWrapper>(ItemsCacheKey);
     if (listWrapper != null && listWrapper.Language == language && listWrapper.ItemData == itemData)
     {
         return listWrapper.ItemListStatic.Items.ContainsKey(itemId) ? listWrapper.ItemListStatic.Items[itemId] : null;
     }
     var json = await requester.CreateRequestAsync(
         string.Format(ItemRootUrl, region.ToString()) + string.Format(IdUrl, itemId),
         RootDomain,
         new List<string>
         {
             string.Format("locale={0}", language.ToString()),
             itemData == ItemData.none ?
                 string.Empty :
                 string.Format("itemData={0}", itemData.ToString())
         });
     var item = await Task.Factory.StartNew(() =>
         JsonConvert.DeserializeObject<ItemStatic>(json));
     Cache.Add(ItemCacheKey + itemId,
         new ItemStaticWrapper(item, language, itemData));
     return item;
 }

 /// <summary>
 /// Get a list of all items synchronously.
 /// </summary>
 /// <param name="region">Region from which to retrieve the data.</param>
 /// <param name="itemData">Data to retrieve.</param>
 /// <param name="language">Language of the data to be retrieved.</param>
 /// <returns>An ItemListStatic object containing all items.</returns>
 public async Task<ItemListStatic> GetItemsAsync(Region region, ItemData itemData = ItemData.none,
     Language language = Language.en_US)
 {
     var wrapper = Cache.Get<ItemListStaticWrapper>(ItemsCacheKey);
     if (wrapper != null && language == wrapper.Language && itemData == wrapper.ItemData)
     {
         return wrapper.ItemListStatic;
     }
     var json = await requester.CreateRequestAsync(
         string.Format(ItemRootUrl, region.ToString()),
         RootDomain,
         new List<string>
         {
             string.Format("locale={0}", language.ToString()),
             itemData == ItemData.none ?
                 string.Empty :
                 string.Format("itemListData={0}", itemData.ToString())
         });
     var items = await Task.Factory.StartNew(() =>
         JsonConvert.DeserializeObject<ItemListStatic>(json));
     wrapper = new ItemListStaticWrapper(items, language, itemData);
     Cache.Add(ItemsCacheKey, wrapper);
     return wrapper.ItemListStatic;
 }