protected override ResourceSet InternalGetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents)
        {
            ResourceSet resourceSet = (ResourceSet)ResourceSets[culture];

            if (resourceSet == null)
            {
                // Lazy-load default language (without caring about duplicate assignment in race conditions, no harm done);
                if (neutralResourcesCulture == null)
                {
                    neutralResourcesCulture = GetNeutralResourcesLanguage(MainAssembly);
                }

                // If we're asking for the default language, then ask for the invariant (non-specific) resources.
                if (neutralResourcesCulture.Equals(culture))
                {
                    culture = CultureInfo.InvariantCulture;
                }

                string resourceFileName = GetResourceFileName(culture);
                Stream store            = MainAssembly.GetManifestResourceStream(contextTypeInfo, resourceFileName);

                // If we found the appropriate resources in the local assembly...
                if (store != null)
                {
                    resourceSet = new ResourceSet(store);
                    // Save for later.
                    AddResourceSet(ResourceSets, culture, ref resourceSet);
                }
                else
                {
                    resourceSet = base.InternalGetResourceSet(culture, createIfNotExists, tryParents);
                }
            }
            return(resourceSet);
        }
        protected override ResourceSet InternalGetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents)
        {
            ResourceSet rs;

            if (!Resources.TryGetValue(culture, out rs))
            {
                if (m_neutralResourcesCulture == null)
                {
                    m_neutralResourcesCulture = GetNeutralResourcesLanguage(MainAssembly);
                }
                if (m_neutralResourcesCulture.Equals(culture))
                {
                    culture = CultureInfo.InvariantCulture;
                }
                string resourceFileName = GetResourceFileName(culture);
                Stream resStream        = MainAssembly.GetManifestResourceStream(resourceFileName);

                if (resStream == null && !culture.IsNeutralCulture)
                {
                    // try two-letter culture
                    resourceFileName = GetResourceFileName(culture.Parent);
                    resStream        = MainAssembly.GetManifestResourceStream(resourceFileName);
                }
                if (resStream == null)
                {
                    rs = base.InternalGetResourceSet(culture, createIfNotExists, tryParents);
                }
                else
                {
                    using (resStream)
                    {
                        rs = new ResourceSet(resStream);
                    }
                }
                if (rs != null)
                {
                    lock (Resources)
                    {
                        ResourceSet ex;
                        if (!Resources.TryGetValue(culture, out ex))
                        {
                            Resources.Add(culture, rs);
                        }
                        else if (!object.ReferenceEquals(ex, rs))
                        {
                            rs.Dispose();
                            rs = ex;
                        }
                    }
                }
            }
            return(rs);
        }
Example #3
0
    protected override ResourceSet InternalGetResourceSet(CultureInfo culture,
                                                          bool createIfNotExists, bool tryParents)
    {
        var rs = (ResourceSet)ResourceSets[culture];

        if (rs == null)
        {
            Stream store            = null;
            string resourceFileName = null;

            //lazy-load default language (without caring about duplicate assignment in race conditions, no harm done);
            if (_neutralResourcesCulture == null)
            {
                _neutralResourcesCulture =
                    GetNeutralResourcesLanguage(MainAssembly);
            }

            // if we're asking for the default language, then ask for the
            // invariant (non-specific) resources.
            if (_neutralResourcesCulture.Equals(culture))
            {
                culture = CultureInfo.InvariantCulture;
            }
            resourceFileName = GetResourceFileName(culture);

            store = MainAssembly.GetManifestResourceStream(
                _contextTypeInfo, resourceFileName);

            // Try looking for the neutral culture if the specific culture was not found
            if (store == null && !culture.IsNeutralCulture)
            {
                resourceFileName = GetResourceFileName(culture.Parent);

                store = MainAssembly.GetManifestResourceStream(
                    _contextTypeInfo, resourceFileName);
            }

            // If we found the appropriate resources in the local assembly
            if (store != null)
            {
                rs = new ResourceSet(store);
                // save for later.
                AddResourceSet(ResourceSets, culture, ref rs);
            }
            else
            {
                rs = base.InternalGetResourceSet(culture, createIfNotExists, tryParents);
            }
        }
        return(rs);
    }
        protected override ResourceSet InternalGetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents)
        {
            ResourceSet resource;

            // search for specific resource file in the assembly resources
            string cultureName = culture.Name;

            if (cultureName.IsEmpty())
            {
                resource = EmptyResourceSet.Instance;
            }
            else
            {
                string resourceFileName = BaseName + "." + cultureName + ".resources";
                if (!resources.TryGetValue(resourceFileName, out resource))
                {
                    lock (lockingobject) {
                        if (!resources.TryGetValue(resourceFileName, out resource))
                        {
                            Stream s = MainAssembly.GetManifestResourceStream(resourceFileName);
                            if (s != null)
                            {
                                resource = new ResourceSet(s);
                            }
                            else
                            {
                                // delegate in parent
                                resource = base.InternalGetResourceSet(culture, createIfNotExists, tryParents);
                            }
                            resources[resourceFileName] = resource;
                        }
                    }
                }
            }
            return(resource);
        }