File size: 9,663 Bytes
8c763fb | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 | // Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
using System.Collections.Generic;
using System.Reflection;
using System.Resources;
namespace System.Management.Automation
{
/// <summary>
/// </summary>
internal static class ResourceManagerCache
{
/// <summary>
/// Maintains a cache of ResourceManager objects. This is a dictionary that is keyed based on the path
/// to the default resource assembly. The value is another dictionary that is keyed based on the base
/// name for the resource that is being retrieved. The value for this dictionary is the ResourceManager.
/// </summary>
private static readonly Dictionary<string, Dictionary<string, ResourceManager>> s_resourceManagerCache =
new Dictionary<string, Dictionary<string, ResourceManager>>(StringComparer.OrdinalIgnoreCase);
/// <summary>
/// Used to synchronize access to the ResourceManagerCache.
/// </summary>
private static readonly object s_syncRoot = new object();
/// <summary>
/// Gets the ResourceManager from the cache or gets an instance of the ResourceManager
/// and returns it if it isn't already present in the cache.
/// </summary>
/// <param name="assembly">
/// The assembly to be used as the base for resource lookup.
/// </param>
/// <param name="baseName">
/// The base name of the resources to get the ResourceManager for.
/// </param>
/// <returns>
/// A ResourceManager instance for the assembly and base name that were specified.
/// </returns>
internal static ResourceManager GetResourceManager(
Assembly assembly,
string baseName)
{
if (assembly == null)
{
throw PSTraceSource.NewArgumentNullException(nameof(assembly));
}
if (string.IsNullOrEmpty(baseName))
{
throw PSTraceSource.NewArgumentException(nameof(baseName));
}
// Check to see if the manager is already in the cache
ResourceManager manager = null;
Dictionary<string, ResourceManager> baseNameCache;
string assemblyManifestFileLocation = assembly.Location;
lock (s_syncRoot)
{
// First do the lookup based on the assembly location
if (s_resourceManagerCache.TryGetValue(assemblyManifestFileLocation, out baseNameCache) && baseNameCache != null)
{
// Now do the lookup based on the resource base name
baseNameCache.TryGetValue(baseName, out manager);
}
}
// If it's not in the cache, create it an add it.
if (manager == null)
{
manager = InitRMWithAssembly(baseName, assembly);
// Add the new resource manager to the hash
if (baseNameCache != null)
{
lock (s_syncRoot)
{
// Since the assembly is already cached, we just have
// to cache the base name entry
baseNameCache[baseName] = manager;
}
}
else
{
// Since the assembly wasn't cached, we have to create base name
// cache entry and then add it into the cache keyed by the assembly
// location
var baseNameCacheEntry = new Dictionary<string, ResourceManager>();
baseNameCacheEntry[baseName] = manager;
lock (s_syncRoot)
{
s_resourceManagerCache[assemblyManifestFileLocation] = baseNameCacheEntry;
}
}
}
Diagnostics.Assert(
manager != null,
"If the manager was not already created, it should have been dynamically created or an exception should have been thrown");
return manager;
}
/// <summary>
/// Design For Testability -- assert on failed resource lookup.
/// </summary>
private static bool s_DFT_monitorFailingResourceLookup = true;
internal static bool DFT_DoMonitorFailingResourceLookup
{
get { return ResourceManagerCache.s_DFT_monitorFailingResourceLookup; }
set { ResourceManagerCache.s_DFT_monitorFailingResourceLookup = value; }
}
/// <summary>
/// Gets the string from the resource manager based on the assembly,
/// base name, resource ID, and culture specified.
/// </summary>
/// <param name="assembly">
/// The base assembly from which to get the resources from.
/// </param>
/// <param name="baseName">
/// The base name of the resource to retrieve the string from.
/// </param>
/// <param name="resourceId">
/// Resource ID for which the localized string needs to be retrieved
/// </param>
/// <returns>
/// Localized String, or null if the string does not exist
/// </returns>
/// <remarks>
/// The current thread's UI culture is used.
/// </remarks>
/// <throws>
/// ArgumentException if <paramref name="baseName"/> or <paramref name="resourceId"/>
/// are null or empty..
/// InvalidOperationException if the value of the specified resource is not a string
/// MissingManifestResourceException if no usable set of resources have been found, and
/// there are no neutral culture resources.
/// </throws>
internal static string GetResourceString(
Assembly assembly,
string baseName,
string resourceId)
{
if (assembly == null)
{
throw PSTraceSource.NewArgumentNullException(nameof(assembly));
}
if (string.IsNullOrEmpty(baseName))
{
throw PSTraceSource.NewArgumentException(nameof(baseName));
}
if (string.IsNullOrEmpty(resourceId))
{
throw PSTraceSource.NewArgumentException(nameof(resourceId));
}
ResourceManager resourceManager = null;
string text = string.Empty;
// For a non-existing resource defined by {assembly,baseName,resourceId}
// MissingManifestResourceException is thrown only at the time when resource retrieval method
// such as ResourceManager.GetString or ResourceManager.GetObject is called,
// not when you instantiate a ResourceManager object.
try
{
// try with original baseName first
// if it fails then try with alternative resource path format
resourceManager = GetResourceManager(assembly, baseName);
text = resourceManager.GetString(resourceId);
}
catch (MissingManifestResourceException)
{
const string resourcesSubstring = ".resources.";
int resourcesSubstringIndex = baseName.IndexOf(resourcesSubstring);
string newBaseName = string.Empty;
if (resourcesSubstringIndex != -1)
{
newBaseName = baseName.Substring(resourcesSubstringIndex + resourcesSubstring.Length); // e.g. "FileSystemProviderStrings"
}
else
{
newBaseName = string.Concat(assembly.GetName().Name, resourcesSubstring, baseName); // e.g. "System.Management.Automation.resources.FileSystemProviderStrings"
}
resourceManager = GetResourceManager(assembly, newBaseName);
text = resourceManager.GetString(resourceId);
}
if (string.IsNullOrEmpty(text) && s_DFT_monitorFailingResourceLookup)
{
Diagnostics.Assert(false,
"Lookup failure: baseName " + baseName + " resourceId " + resourceId);
}
return text;
}
/// <summary>
/// Creates a Resource manager instance based on the assembly specified.
/// </summary>
/// <param name="baseName">
/// The root name of the resources.
/// For example, the root name for the resource file
/// named "MyResource.en-US.resources" is "MyResource".
/// </param>
/// <param name="assemblyToUse">
/// The main Assembly for the resources
/// </param>
/// <returns>Resource Manager instance.</returns>
/// <exception cref="ArgumentException">
/// Thrown if the resource manager instance could not be created
/// </exception>
private static ResourceManager InitRMWithAssembly(string baseName, Assembly assemblyToUse)
{
ResourceManager rm = null;
if (baseName != null && assemblyToUse != null)
{
rm = new ResourceManager(baseName, assemblyToUse);
}
else
{
// 2004/10/11-JonN Do we need a better error message? I don't think so,
// since this is private.
throw PSTraceSource.NewArgumentException(nameof(assemblyToUse));
}
return rm;
}
}
}
|