PowerShell/src/System.Management.Automation/utils/ResourceManagerCache.cs

/********************************************************************++
Copyright (c) Microsoft Corporation.  All rights reserved.
--********************************************************************/

using System;
using System.Reflection;
using System.Collections.Generic;
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>
        static private Dictionary<string, Dictionary<string, ResourceManager>> resourceManagerCache =
            new Dictionary<string, Dictionary<string, ResourceManager>>(StringComparer.OrdinalIgnoreCase);

        /// <summary>
        /// Used to synchronize access to the ResourceManagerCache
        /// </summary>
        static object 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>
        /// 
        static internal ResourceManager GetResourceManager (
            Assembly assembly,
            string baseName)
        {
            if (assembly == null)
            {
                throw PSTraceSource.NewArgumentNullException("assembly");
            }

            if (String.IsNullOrEmpty(baseName))
            {
                throw PSTraceSource.NewArgumentException("baseName");
            }

            // Check to see if the manager is already in the cache

            ResourceManager manager = null;
            Dictionary<string, ResourceManager> baseNameCache;

            string assemblyManifestFileLocation = ClrFacade.GetAssemblyLocation(assembly);
            lock (syncRoot)
            {
                // First do the lookup based on the assembly location

                if (resourceManagerCache.TryGetValue(assemblyManifestFileLocation, out baseNameCache) && baseNameCache != null)
                {
                    // Now do the lookup based on the resource base name
                    baseNameCache.TryGetValue(baseName, out manager);
                }
            }

            // If its 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 (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 (syncRoot)
                    {
                        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;
        } // GetResourceManager

        /// <summary>
        /// Design For Testability -- assert on failed resource lookup
        /// </summary>
        private static bool DFT_monitorFailingResourceLookup = true;
        static internal bool DFT_DoMonitorFailingResourceLookup
        {
            get { return ResourceManagerCache.DFT_monitorFailingResourceLookup; }
            set { ResourceManagerCache.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>
        static internal string GetResourceString (
            Assembly assembly,
            string baseName,
            string resourceId)
        {
            if (assembly == null)
            {
                throw PSTraceSource.NewArgumentNullException ("assembly");
            }

            if (String.IsNullOrEmpty (baseName))
            {
                throw PSTraceSource.NewArgumentException ("baseName");
            }

            if (String.IsNullOrEmpty (resourceId))
            {
                throw PSTraceSource.NewArgumentException ("resourceId");
            }

            ResourceManager resourceManager = GetResourceManager (assembly, baseName);
            string text = resourceManager.GetString (resourceId);
            if (String.IsNullOrEmpty(text) && 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>
        static private 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("assemblyToUse");
            }

            return rm;
        }

    } // class ResourceManagerCache
} // namespace System.Management.Automation