Westwind.Globalization.DbResXConverter.GetResourcesNormalizedForLocale C# (CSharp) Method

    public Dictionary<string, object> GetResourcesNormalizedForLocale(ResourceManager resourceManager, string localeId)
    {        
        var resDict = new Dictionary<string, object>();

        var culture = Thread.CurrentThread.CurrentUICulture;
        if (localeId == null)
            culture = CultureInfo.CurrentUICulture;
        else if(localeId == string.Empty)
            culture = CultureInfo.InvariantCulture;
        else if (culture.IetfLanguageTag != localeId)
            culture = CultureInfo.GetCultureInfoByIetfLanguageTag(localeId);
        
        try
        {
            IDictionaryEnumerator enumerator;
            var resSet = resourceManager.GetResourceSet(CultureInfo.InvariantCulture, true, true);            
            enumerator = resSet.GetEnumerator();
            while (enumerator.MoveNext())
            {
                var resItem = (DictionaryEntry)enumerator.Current;
                resDict.Add((string)resItem.Key, null);
            }
            var keys = resDict.Keys.ToList();
            foreach (var key in keys)
            {
                resDict[key] = resourceManager.GetObject(key,culture);
            }            
        }
        catch (Exception ex)
        {
            return null;
        }

        return resDict;
    }

        public void ProcessRequest(HttpContext context)
        {
            HttpRequest Request = HttpContext.Current.Request;
            HttpResponse Response = HttpContext.Current.Response;

            string resourceSet = Request.Params["ResourceSet"];
            string localeId = Request.Params["LocaleId"] ?? "auto";
            string resourceType = Request.Params["ResourceType"] ?? "Resx";   // Resx/ResDb
            bool includeControls = (Request.Params["IncludeControls"] ?? "") != "";
            string varname = Request.Params["VarName"] ?? "resources";
            string resourceMode = (Request.Params["ResourceMode"] ?? "0");

            // varname is embedded into script so validate to avoid script injection
            // it's gotta be a valid C# and valid JavaScript name
            Match match = Regex.Match(varname, @"^[\w|\d|_|$|@|\.]*$");
            if (match.Length < 1 || match.Groups[0].Value != varname)
                SendErrorResponse("Invalid variable name passed.");

            if (string.IsNullOrEmpty(resourceSet))
                SendErrorResponse("Invalid ResourceSet specified.");

            // pick current UI Culture
            if (localeId == "auto")
                localeId = Thread.CurrentThread.CurrentUICulture.IetfLanguageTag;

            Dictionary<string, object> resDict = null;

            if (string.IsNullOrEmpty(resourceType) || resourceType == "auto")
            {
                if (DbResourceProvider.ProviderLoaded || DbSimpleResourceProvider.ProviderLoaded)
                    resourceType = "resdb";
                else
                    resourceType = "resx";
            }


            if (resourceType.ToLower() == "resdb")
            {                
                // use existing/cached resource manager if previously used
                // so database is accessed only on first hit
                var resManager = DbRes.GetResourceManager(resourceSet);

                DbResXConverter converter = new DbResXConverter(context.Server.MapPath(DbResourceConfiguration.Current.ResxBaseFolder));
                resDict = converter.GetResourcesNormalizedForLocale(resManager, localeId);

                //resDict = manager.GetResourceSetNormalizedForLocaleId(localeId, resourceSet);
                if (resDict == null || resDict.Keys.Count < 1)
                {
                    // try resx instead
                    string resxPath = converter.FormatResourceSetPath(resourceSet);
                    resDict = converter.GetResXResourcesNormalizedForLocale(resxPath, localeId);
                }
            }
            else  // Resx Resources
            {
                string basePath = context.Server.MapPath(DbResourceConfiguration.Current.ResxBaseFolder);
                DbResXConverter converter = new DbResXConverter(basePath);

                resDict = converter.GetCompiledResourcesNormalizedForLocale(resourceSet, 
                    DbResourceConfiguration.Current.ResourceBaseNamespace, 
                    localeId);

                if (resDict == null)
                {
                    // check for .resx disk resources
                    string resxPath = converter.FormatResourceSetPath(resourceSet);
                    resDict = converter.GetResXResourcesNormalizedForLocale(resxPath, localeId);
                }
                else
                    resDict = resDict.OrderBy(kv => kv.Key).ToDictionary(k => k.Key, v => v.Value);
            }


            if (resourceMode == "0" && !includeControls)
            {
                // filter the list to strip out controls (anything that contains a . in the ResourceId 
                // is considered a control value
                resDict = resDict.Where(res => !res.Key.Contains('.') && res.Value is string)
                                 .ToDictionary(dict => dict.Key, dict => dict.Value);
            }
            else
            {
                // return all resource strings
                resDict = resDict.Where(res => res.Value is string)
                           .ToDictionary(dict => dict.Key, dict => dict.Value);
            }

            string javaScript = SerializeResourceDictionary(resDict, varname);


            // client cache
            if (!HttpContext.Current.IsDebuggingEnabled)
            {
                Response.ExpiresAbsolute = DateTime.UtcNow.AddDays(1);                
                Response.AppendHeader("Accept-Ranges", "bytes");
                Response.AppendHeader("Vary", "Accept-Encoding");
                Response.Cache.SetETag("\"" + javaScript.GetHashCode().ToString("x") + "\"");
                Response.Cache.SetLastModified(DateTime.UtcNow);

                // OutputCache settings
                HttpCachePolicy cache = Response.Cache;

                cache.VaryByParams["ResourceSet"] = true;
                cache.VaryByParams["LocaleId"] = true;
                cache.VaryByParams["ResoureType"] = true;
                cache.VaryByParams["IncludeControls"] = true;
                cache.VaryByParams["VarName"] = true;
                cache.VaryByParams["ResourceMode"] = true;
                //cache.SetOmitVaryStar(true);

                DateTime now = DateTime.Now;
                cache.SetCacheability(HttpCacheability.Public);
                cache.SetExpires(now + TimeSpan.FromDays(1));
                cache.SetValidUntilExpires(true);
                cache.SetLastModified(now);
            }

            SendTextOutput(javaScript, "text/javascript");
        }