We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Resources \ ResourceManager

SSCLI

// ==++==
//
//
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
//
// ==--==
/*============================================================
**
** Class: ResourceManager
**
**
** Purpose: Default way to access String resources from
** an assembly.
**
**
===========================================================*/
namespace System.Resources
{
using System;
using System.IO;
using System.Globalization;
using System.Collections;
using System.Text;
using System.Reflection;
using System.Runtime.Remoting.Activation;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Threading;
using System.Runtime.InteropServices;
using Microsoft.Win32;
using System.Collections.Generic;
using System.Runtime.Versioning;
// Resource Manager exposes an assembly's resources to an application for
// the correct CultureInfo. An example would be localizing text for a
// user-visible message. Create a set of resource files listing a name
// for a message and its value, compile them using ResGen, put them in
// an appropriate place (your assembly manifest(?)), then create a Resource
// Manager and query for the name of the message you want. The Resource
// Manager will use CultureInfo.GetCurrentUICulture() to look
// up a resource for your user's locale settings.
//
// Users should ideally create a resource file for every culture, or
// at least a meaningful subset. The filenames will follow the naming
// scheme:
//
// basename.culture name.resources
//
// The base name can be the name of your application, or depending on
// the granularity desired, possibly the name of each class. The culture
// name is determined from CultureInfo's Name property.
// An example file name may be MyApp.en-US.resources for
// MyApp's US English resources.
//
[Serializable()]
[System.Runtime.InteropServices.ComVisible(true)]
public class ResourceManager
{
protected string BaseNameField;
// Sets is a many-to-one table of CultureInfos mapped to ResourceSets.
// Don't synchronize ResourceSets - too fine-grained a lock to be effective
protected Hashtable ResourceSets;
private string moduleDir;
// For assembly-ignorant directory location
protected Assembly MainAssembly;
// Need the assembly manifest sometimes.
private Type _locationInfo;
// For Assembly or type-based directory layout
private Type _userResourceSet;
// Which ResourceSet instance to create
private CultureInfo _neutralResourcesCulture;
// For perf optimizations.
private bool _ignoreCase;
// Whether case matters in GetString & GetObject
// When we create a separate FileBasedResourceManager subclass,
// UseManifest can be replaced with "false".
private bool UseManifest;
// Use Assembly manifest, or grovel disk.
// When we create a separate FileBasedResourceManager subclass,
// UseSatelliteAssem can be replaced with "true".
private bool UseSatelliteAssem;
// Are all the .resources files in the
// main assembly, or in satellite assemblies for each culture?
private static Hashtable _installedSatelliteInfo;
// Give the user the option
// to prevent certain satellite assembly probes via a config file.
// Note that config files are per-appdomain, not per-assembly nor process
private static bool _checkedConfigFile;
// Did we read the app's config file?
// Whether to fall back to the main assembly or a particular
// satellite for the neutral resources.
[OptionalField()]
private UltimateResourceFallbackLocation _fallbackLoc;
// Version number of satellite assemblies to look for. May be null.
[OptionalField()]
private Version _satelliteContractVersion;
[OptionalField()]
private bool _lookedForSatelliteContractVersion;
private Assembly _callingAssembly;
// Assembly who created the ResMgr.
public static readonly int MagicNumber = unchecked((int)3203386062u);
// If only hex had a K...
// Version number so ResMgr can get the ideal set of classes for you.
// ResMgr header is:
// 1) MagicNumber (little endian Int32)
// 2) HeaderVersionNumber (little endian Int32)
// 3) Num Bytes to skip past ResMgr header (little endian Int32)
// 4) IResourceReader type name for this file (bytelength-prefixed UTF-8 String)
// 5) ResourceSet type name for this file (bytelength-prefixed UTF8 String)
public static readonly int HeaderVersionNumber = 1;
//
//It would be better if we could use _neutralCulture instead of calling
//CultureInfo.InvariantCulture everywhere, but we run into problems with the .cctor. CultureInfo
//initializes assembly, which initializes ResourceManager, which tries to get a CultureInfo which isn't
//there yet because CultureInfo's class initializer hasn't finished. If we move SystemResMgr off of
//Assembly (or at least make it an internal property) we should be able to circumvent this problem.
//
// private static CultureInfo _neutralCulture = null;
// This is our min required ResourceSet type.
private static readonly Type _minResourceSet = typeof(ResourceSet);
// These Strings are used to avoid using Reflection in CreateResourceSet.
// The first set are used by ResourceWriter. The second are used by
// InternalResGen.
static internal readonly string ResReaderTypeName = typeof(ResourceReader).FullName;
static internal readonly string ResSetTypeName = typeof(RuntimeResourceSet).FullName;
static internal readonly string MscorlibName = typeof(ResourceReader).Assembly.FullName;
internal const string ResFileExtension = ".resources";
internal const int ResFileExtensionLength = 10;
// My private debugging aid. Set to 5 or 6 for verbose output. Set to 3
// for summary level information.
static internal readonly int DEBUG = 0;
protected ResourceManager()
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
_callingAssembly = Assembly.nGetExecutingAssembly(ref stackMark);
}
// Constructs a Resource Manager for files beginning with
// baseName in the directory specified by resourceDir
// or in the current directory. This Assembly-ignorant constructor is
// mostly useful for testing your own ResourceSet implementation.
//
// A good example of a baseName might be "Strings". BaseName
// should not end in ".resources".
//
// Note: System.Windows.Forms uses this method at design time.
//
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
private ResourceManager(string baseName, string resourceDir, Type usingResourceSet)
{
//
// __FileBasedResourceManager: We should move all the file-based functionality into a
// (potentially internal) subclass of ResourceManager. This will simplify
// InternalGetResourceSet a lot. We can also make several fields like UseManifest
// private.
//
if (null == baseName)
throw new ArgumentNullException("baseName");
if (null == resourceDir)
throw new ArgumentNullException("resourceDir");
BaseNameField = baseName;
moduleDir = resourceDir;
_userResourceSet = usingResourceSet;
ResourceSets = new Hashtable();
UseManifest = false;
#if _DEBUG
if (DEBUG >= 3) {
// Detect missing neutral locale resources.
CultureInfo culture = CultureInfo.InvariantCulture;
string defaultResPath = FindResourceFile(culture);
if (defaultResPath == null || !File.Exists(defaultResPath)) {
string defaultResName = GetResourceFileName(culture);
string dir = moduleDir;
if (defaultResPath != null)
dir = Path.GetDirectoryName(defaultResPath);
BCLDebug.Log("While constructing a ResourceManager, your application's neutral " + ResFileExtension + " file couldn't be found. Expected to find a " + ResFileExtension + " file called \"" + defaultResName + "\" in the directory \"" + dir + "\". However, this is optional, and if you're extremely careful, you can ignore this.");
}
else
BCLDebug.Log("ResourceManager found default culture's " + ResFileExtension + " file, " + defaultResPath);
}
#endif
}
public ResourceManager(string baseName, Assembly assembly)
{
if (null == baseName)
throw new ArgumentNullException("baseName");
if (null == assembly)
throw new ArgumentNullException("assembly");
MainAssembly = assembly;
_locationInfo = null;
BaseNameField = baseName;
CommonSatelliteAssemblyInit();
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
_callingAssembly = Assembly.nGetExecutingAssembly(ref stackMark);
if (assembly == typeof(object).Assembly && _callingAssembly != assembly)
_callingAssembly = null;
}
public ResourceManager(string baseName, Assembly assembly, Type usingResourceSet)
{
if (null == baseName)
throw new ArgumentNullException("baseName");
if (null == assembly)
throw new ArgumentNullException("assembly");
MainAssembly = assembly;
_locationInfo = null;
BaseNameField = baseName;
if (usingResourceSet != null && (usingResourceSet != _minResourceSet) && !(usingResourceSet.IsSubclassOf(_minResourceSet)))
throw new ArgumentException(Environment.GetResourceString("Arg_ResMgrNotResSet"), "usingResourceSet");
_userResourceSet = usingResourceSet;
CommonSatelliteAssemblyInit();
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
_callingAssembly = Assembly.nGetExecutingAssembly(ref stackMark);
if (assembly == typeof(object).Assembly && _callingAssembly != assembly)
_callingAssembly = null;
}
public ResourceManager(Type resourceSource)
{
if (null == resourceSource)
throw new ArgumentNullException("resourceSource");
_locationInfo = resourceSource;
MainAssembly = _locationInfo.Assembly;
BaseNameField = resourceSource.Name;
CommonSatelliteAssemblyInit();
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
_callingAssembly = Assembly.nGetExecutingAssembly(ref stackMark);
// Special case for mscorlib - protect mscorlib's private resources.
if (MainAssembly == typeof(object).Assembly && _callingAssembly != MainAssembly)
_callingAssembly = null;
}
// Trying to unify code as much as possible, even though having to do a
// security check in each constructor prevents it.
private void CommonSatelliteAssemblyInit()
{
UseManifest = true;
UseSatelliteAssem = true;
ResourceSets = new Hashtable();
_fallbackLoc = UltimateResourceFallbackLocation.MainAssembly;
#if _DEBUG
if (DEBUG >= 3) {
// Detect missing neutral locale resources.
string defaultResName = GetResourceFileName(CultureInfo.InvariantCulture);
string outputResName = defaultResName;
if (_locationInfo != null && _locationInfo.Namespace != null)
outputResName = _locationInfo.Namespace + Type.Delimiter + defaultResName;
if (!MainAssemblyContainsResourceBlob(defaultResName)) {
BCLDebug.Log("Your main assembly really should contain the neutral culture's resources. Expected to find a resource blob in your assembly manifest called \"" + outputResName + "\". Check capitalization in your assembly manifest. If you're extremely careful though, this is only optional, not a requirement.");
}
else {
BCLDebug.Log("ResourceManager found default culture's " + ResFileExtension + " file, " + defaultResName);
}
}
#endif
}
// Gets the base name for the ResourceManager.
public virtual string BaseName {
get { return BaseNameField; }
}
// Whether we should ignore the capitalization of resources when calling
// GetString or GetObject.
public virtual bool IgnoreCase {
get { return _ignoreCase; }
set { _ignoreCase = value; }
}
// Returns the Type of the ResourceSet the ResourceManager uses
// to construct ResourceSets.
public virtual Type ResourceSetType {
get { return (_userResourceSet == null) ? typeof(RuntimeResourceSet) : _userResourceSet; }
}
protected UltimateResourceFallbackLocation FallbackLocation {
get { return _fallbackLoc; }
set { _fallbackLoc = value; }
}
// Tells the ResourceManager to call Close on all ResourceSets and
// release all resources. This will shrink your working set by
// potentially a substantial amount in a running application. Any
// future resource lookups on this ResourceManager will be as
// expensive as the very first lookup, since it will need to search
// for files and load resources again.
//
// This may be useful in some complex threading scenarios, where
// creating a new ResourceManager isn't quite the correct behavior.
public virtual void ReleaseAllResources()
{
#if _DEBUG
if (DEBUG >= 1)
BCLDebug.Log("Calling ResourceManager::ReleaseAllResources");
#endif
IDictionaryEnumerator setEnum = ResourceSets.GetEnumerator();
// If any calls to Close throw, at least leave ourselves in a
// consistent state.
ResourceSets = new Hashtable();
while (setEnum.MoveNext()) {
((ResourceSet)setEnum.Value).Close();
}
}
// Returns whether or not the main assembly contains a particular resource
// blob in it's assembly manifest. Used to verify that the neutral
// Culture's .resources file is present in the main assembly
#if _DEBUG
private bool MainAssemblyContainsResourceBlob(string defaultResName)
{
string resName = defaultResName;
if (_locationInfo != null && _locationInfo.Namespace != null)
resName = _locationInfo.Namespace + Type.Delimiter + defaultResName;
string[] blobs = MainAssembly.GetManifestResourceNames();
foreach (string s in blobs)
if (s.Equals(resName))
return true;
return false;
}
#endif
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static ResourceManager CreateFileBasedResourceManager(string baseName, string resourceDir, Type usingResourceSet)
{
return new ResourceManager(baseName, resourceDir, usingResourceSet);
}
// Given a CultureInfo, it generates the path &; file name for
// the .resources file for that CultureInfo. This method will grovel
// the disk looking for the correct file name & path. Uses CultureInfo's
// Name property. If the module directory was set in the ResourceManager
// constructor, we'll look there first. If it couldn't be found in the module
// diretory or the module dir wasn't provided, look in the current
// directory.
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
private string FindResourceFile(CultureInfo culture)
{
// __FileBasedResourceManager: When we create a __FileBasedResourceManager, move this method
// to that class. This is part of the assembly-ignorant implementation
// that really doesn't belong on ResourceManager.
string fileName = GetResourceFileName(culture);
// If we have a moduleDir, check there first. Get module fully
// qualified name, append path to that.
if (moduleDir != null) {
#if _DEBUG
if (DEBUG >= 3)
BCLDebug.Log("FindResourceFile: checking module dir: \"" + moduleDir + '"');
#endif
string path = Path.Combine(moduleDir, fileName);
if (File.Exists(path)) {
#if _DEBUG
if (DEBUG >= 3)
BCLDebug.Log("Found resource file in module dir! " + path);
#endif
return path;
}
}
#if _DEBUG
if (DEBUG >= 3)
BCLDebug.Log("Couldn't find resource file in module dir, checking .\\" + fileName);
#endif
// look in .
if (File.Exists(fileName))
return fileName;
return null;
// give up.
}
// Given a CultureInfo, GetResourceFileName generates the name for
// the binary file for the given CultureInfo. This method uses
// CultureInfo's Name property as part of the file name for all cultures
// other than the invariant culture. This method does not touch the disk,
// and is used only to construct what a resource file name (suitable for
// passing to the ResourceReader constructor) or a manifest resource blob
// name should look like.
//
// This method can be overriden to look for a different extension,
// such as ".ResX", or a completely different format for naming files.
protected virtual string GetResourceFileName(CultureInfo culture)
{
StringBuilder sb = new StringBuilder(255);
sb.Append(BaseNameField);
// If this is the neutral culture, don't append culture name.
if (!culture.Equals(CultureInfo.InvariantCulture)) {
CultureInfo.VerifyCultureName(culture, true);
sb.Append('.');
sb.Append(culture.Name);
}
sb.Append(ResFileExtension);
return sb.ToString();
}
// Looks up a set of resources for a particular CultureInfo. This is
// not useful for most users of the ResourceManager - call
// GetString() or GetObject() instead.
//
// The parameters let you control whether the ResourceSet is created
// if it hasn't yet been loaded and if parent CultureInfos should be
// loaded as well for resource inheritance.
//
public virtual ResourceSet GetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents)
{
if (null == culture)
throw new ArgumentNullException("culture");
Hashtable localResourceSets = ResourceSets;
ResourceSet rs;
if (localResourceSets != null) {
rs = (ResourceSet)localResourceSets[culture];
if (null != rs)
return rs;
}
if (UseManifest && culture.Equals(CultureInfo.InvariantCulture)) {
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
string fileName = GetResourceFileName(culture);
Stream stream = MainAssembly.GetManifestResourceStream(_locationInfo, fileName, _callingAssembly == MainAssembly, ref stackMark);
if (createIfNotExists && stream != null) {
rs = CreateResourceSet(stream, MainAssembly);
lock (localResourceSets) {
localResourceSets.Add(culture, rs);
}
return rs;
}
}
return InternalGetResourceSet(culture, createIfNotExists, tryParents);
}
// InternalGetResourceSet is a non-threadsafe method where all the logic
// for getting a resource set lives. Access to it is controlled by
// threadsafe methods such as GetResourceSet, GetString, & GetObject.
// This will take a minimal number of locks.
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
protected virtual ResourceSet InternalGetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents)
{
BCLDebug.Assert(culture != null, "culture != null");
#if _DEBUG
if (DEBUG >= 3)
BCLDebug.Log("GetResourceSet(" + culture.Name + " [" + culture.LCID + "], " + createIfNotExists + ", " + tryParents + ")");
#endif
Hashtable localResourceSets = ResourceSets;
ResourceSet rs = (ResourceSet)localResourceSets[culture];
if (null != rs)
return rs;
// InternalGetResourceSet will never be threadsafe. However, it must
// be protected against reentrancy from the SAME THREAD. (ie, calling
// GetSatelliteAssembly may send some window messages or trigger the
// Assembly load event, which could fail then call back into the
// ResourceManager). It's happened.
Stream stream = null;
string fileName = null;
Assembly satellite = null;
// Which assembly we loaded from
if (UseManifest) {
fileName = GetResourceFileName(culture);
// Ask assembly for resource stream named fileName.
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
if (UseSatelliteAssem) {
CultureInfo lookForCulture = culture;
if (_neutralResourcesCulture == null)
_neutralResourcesCulture = GetNeutralResourcesLanguage(MainAssembly, ref _fallbackLoc);
// If our neutral resources were written in this culture
// AND we know the main assembly does NOT contain neutral
// resources, don't probe for this satellite.
if (culture.Equals(_neutralResourcesCulture) && FallbackLocation == UltimateResourceFallbackLocation.MainAssembly) {
#if _DEBUG
if (DEBUG >= 4)
BCLDebug.Log("ResMgr::InternalGetResourceSet - Your neutral resources are sufficient for this culture. Skipping satellites & using neutral resources for: " + culture.Name);
#endif
// Update internal state.
lookForCulture = CultureInfo.InvariantCulture;
fileName = GetResourceFileName(lookForCulture);
}
// For neutral locale, look in the main assembly
// if and only if our fallback location is MainAssembly.
if (lookForCulture.Equals(CultureInfo.InvariantCulture)) {
if (FallbackLocation == UltimateResourceFallbackLocation.Satellite) {
satellite = GetSatelliteAssembly(_neutralResourcesCulture);
// If your ultimate fallback satellite couldn't be
// loaded, it's a fatal error. We'll give
// you a nice error message.
if (satellite == null) {
string satAssemName = MainAssembly.nGetSimpleName() + ".resources.dll";
if (_satelliteContractVersion != null)
satAssemName += ", Version=" + _satelliteContractVersion.ToString();
AssemblyName an = new AssemblyName();
an.SetPublicKey(MainAssembly.nGetPublicKey());
byte[] token = an.GetPublicKeyToken();
int iLen = token.Length;
StringBuilder publicKeyTok = new StringBuilder(iLen * 2);
for (int i = 0; i < iLen; i++)
publicKeyTok.Append(token[i].ToString("x", CultureInfo.InvariantCulture));
satAssemName += ", PublicKeyToken=" + publicKeyTok;
string cultureName = _neutralResourcesCulture.Name;
if (cultureName.Length == 0)
cultureName = "<invariant>";
throw new MissingSatelliteAssemblyException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("MissingSatelliteAssembly_Culture_Name"), _neutralResourcesCulture, satAssemName), cultureName);
}
// Correct fileName for this satellite.
fileName = GetResourceFileName(_neutralResourcesCulture);
}
else
satellite = MainAssembly;
}
else if (!TryLookingForSatellite(lookForCulture))
satellite = null;
else
// If our config file says the satellite isn't here,
// don't ask for it.
satellite = GetSatelliteAssembly(lookForCulture);
// Look for a possibly-NameSpace-qualified resource file, ie,
// Microsoft.Name.myApp.en-US.resources.
// (A null _locationInfo is legal)
if (satellite != null) {
// Handle case in here where someone added a callback
// for assembly load events. While no other threads
// have called into GetResourceSet, our own thread can!
// At that point, we could already have an RS in our
// hash table, and we don't want to add it twice.
rs = (ResourceSet)localResourceSets[lookForCulture];
if (null != rs) {
#if _DEBUG
if (DEBUG >= 1)
BCLDebug.Log("ResMgr::GetResourceSet - After loading a satellite assembly, we already have the resource set for culture \"" + lookForCulture.Name + "\" [" + lookForCulture.LCID + "]. You must have had an assembly load callback that called into this instance of the ResourceManager! Eeew.");
#endif
return rs;
}
// If we're looking in the main assembly AND if the main
// assembly was the person who created the ResourceManager,
// skip a security check for private manifest resources.
bool canSkipSecurityCheck = MainAssembly == satellite && _callingAssembly == MainAssembly;
stream = satellite.GetManifestResourceStream(_locationInfo, fileName, canSkipSecurityCheck, ref stackMark);
if (stream == null)
stream = CaseInsensitiveManifestResourceStreamLookup(satellite, fileName);
}
#if _DEBUG
if (DEBUG >= 3)
BCLDebug.Log("ResMgr manifest resource lookup in satellite assembly for culture " + (lookForCulture.Equals(CultureInfo.InvariantCulture) ? "[neutral]" : lookForCulture.Name) + (stream == null ? " failed." : " succeeded.") + " assembly name: " + (satellite == null ? "<null>" : satellite.nGetSimpleName() + " assembly culture: " + satellite.GetLocale().Name + " [" + satellite.GetLocale().LCID + "]"));
#endif
}
else {
// if !UseSatelliteAssembly
satellite = MainAssembly;
stream = MainAssembly.GetManifestResourceStream(_locationInfo, fileName, _callingAssembly == MainAssembly, ref stackMark);
}
if (stream == null && tryParents) {
// If we've hit top of the Culture tree, return.
if (culture.Equals(CultureInfo.InvariantCulture)) {
// Keep people from bothering me about resources problems
if (MainAssembly == typeof(object).Assembly && BaseName.Equals("mscorlib")) {
// This would break CultureInfo & all our exceptions.
BCLDebug.Assert(false, "Couldn't get mscorlib" + ResFileExtension + " from mscorlib's assembly" + Environment.NewLine + Environment.NewLine + "Are you building the runtime on your machine? Chances are the BCL directory didn't build correctly. Type 'build -c' in the BCL directory. If you get build errors, look at buildd.log. If you then can't figure out what's wrong (and you aren't changing the assembly-related metadata code), ask a BCL dev.\n\nIf you did NOT build the runtime, you shouldn't be seeing this and you've found a bug.");
throw new ExecutionEngineException("mscorlib" + ResFileExtension + " couldn't be found! Large parts of the BCL won't work!");
}
// We really don't think this should happen - we always
// expect the neutral locale's resources to be present.
string resName = String.Empty;
if (_locationInfo != null && _locationInfo.Namespace != null)
resName = _locationInfo.Namespace + Type.Delimiter;
resName += fileName;
throw new MissingManifestResourceException(Environment.GetResourceString("MissingManifestResource_NoNeutralAsm", resName, MainAssembly.nGetSimpleName()));
}
CultureInfo parent = culture.Parent;
// Recurse now.
rs = InternalGetResourceSet(parent, createIfNotExists, tryParents);
if (rs != null) {
AddResourceSet(localResourceSets, culture, ref rs);
}
return rs;
}
}
//UseManifest
else {
// Don't use Assembly manifest, but grovel on disk for a file.
new System.Security.Permissions.FileIOPermission(System.Security.Permissions.PermissionState.Unrestricted).Assert();
// Create new ResourceSet, if a file exists on disk for it.
fileName = FindResourceFile(culture);
if (fileName == null) {
if (tryParents) {
// If we've hit top of the Culture tree, return.
if (culture.Equals(CultureInfo.InvariantCulture)) {
// We really don't think this should happen - we always
// expect the neutral locale's resources to be present.
throw new MissingManifestResourceException(Environment.GetResourceString("MissingManifestResource_NoNeutralDisk") + Environment.NewLine + "baseName: " + BaseNameField + " locationInfo: " + (_locationInfo == null ? "<null>" : _locationInfo.FullName) + " fileName: " + GetResourceFileName(culture));
}
CultureInfo parent = culture.Parent;
// Recurse now.
rs = InternalGetResourceSet(parent, createIfNotExists, tryParents);
if (rs != null) {
AddResourceSet(localResourceSets, culture, ref rs);
}
return rs;
}
}
else {
rs = CreateResourceSet(fileName);
// To speed up ResourceSet lookups in the future, store this
// culture with its parent culture's ResourceSet.
if (rs != null) {
AddResourceSet(localResourceSets, culture, ref rs);
}
return rs;
}
}
if (createIfNotExists && stream != null && rs == null) {
#if _DEBUG
if (DEBUG >= 1)
BCLDebug.Log("Creating new ResourceSet for culture " + ((culture == CultureInfo.InvariantCulture) ? "[neutral]" : culture.ToString()) + " from file " + fileName);
#endif
rs = CreateResourceSet(stream, satellite);
AddResourceSet(localResourceSets, culture, ref rs);
}
#if _DEBUG
else {
// Just for debugging - include debug spew saying we won't do anything.
if (!createIfNotExists && stream != null && rs == null) {
if (DEBUG >= 1)
BCLDebug.Log("NOT creating new ResourceSet because createIfNotExists was false! For culture " + ((culture == CultureInfo.InvariantCulture) ? "[neutral]" : culture.ToString()) + " from file " + fileName);
}
}
#endif
return rs;
}
// Simple helper to ease maintenance and improve readability.
private static void AddResourceSet(Hashtable localResourceSets, CultureInfo culture, ref ResourceSet rs)
{
// InternalGetResourceSet is both recursive and reentrant -
// assembly load callbacks in particular are a way we can call
// back into the ResourceManager in unexpectedly on the same thread.
lock (localResourceSets) {
// If another thread added this culture, return that.
ResourceSet lostRace = (ResourceSet)localResourceSets[culture];
if (lostRace != null) {
if (!Object.Equals(lostRace, rs)) {
rs.Dispose();
rs = lostRace;
}
}
else {
localResourceSets.Add(culture, rs);
}
}
}
// Looks up a .resources file in the assembly manifest using
// case-insensitive lookup rules. Yes, this is slow. The metadata
// dev lead refuses to make all manifest blob lookups case-insensitive,
// even optionally case-insensitive.
private Stream CaseInsensitiveManifestResourceStreamLookup(Assembly satellite, string name)
{
StringBuilder sb = new StringBuilder();
if (_locationInfo != null) {
string nameSpace = _locationInfo.Namespace;
if (nameSpace != null) {
sb.Append(nameSpace);
if (name != null)
sb.Append(Type.Delimiter);
}
}
sb.Append(name);
string givenName = sb.ToString();
CompareInfo comparer = CultureInfo.InvariantCulture.CompareInfo;
string canonicalName = null;
foreach (string existingName in satellite.GetManifestResourceNames()) {
if (comparer.Compare(existingName, givenName, CompareOptions.IgnoreCase) == 0) {
if (canonicalName == null)
canonicalName = existingName;
else
throw new MissingManifestResourceException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("MissingManifestResource_MultipleBlobs"), givenName, satellite.ToString()));
}
}
#if _DEBUG
if (DEBUG >= 4) {
if