Append ApplicationName and RelativePath doesn't make sense for types from class library in ResourceManagerStringLocalizerFactory

[martinba1]

See:
https://github.com/aspnet/Localization/blob/dev/src/Microsoft.Extensions.Localization/ResourceManagerStringLocalizerFactory.cs#L72

It is useful to append _applicationEnvironment.ApplicationName, _resourcesRelativePath to baseName only for types from the main application assembly. It makes impossible to use this factory for resources shared in class library assemblies.

[Eilon]

If the type name being requested doesn't start with the app name then we shouldn't use any fancy prefix logic. This way the application's configuration for localization won't interfere with class libraries doing their own localization.

[joeaudette]

this is kind of a bad bug, only solution at the moment is to fork ResourceManagerStringLocalizerFactory and change the logic, wondering why this is backlog, thought it would be fixed in rc2 but backlog suggests it won't even be fixed in RTM

For example if I have a class library with a FooController like this:

    using Microsoft.AspNetCore.Mvc;
    using Microsoft.Extensions.Localization;
    namespace WebLib.Controllers
    {
        public class FooController : Controller
        {
            public FooController(
                IStringLocalizerFactory localizerFactory
                )
            {
                _localizer = localizerFactory.Create("MyResources.Controllers.FooController", "WebLib"); ;
            }

            private readonly IStringLocalizer _localizer;

            public IActionResult Index()
            {
                ViewData["Title"] = _localizer["Foo"];
                ViewData["Message"] = _localizer["Greetings ya'll"];

                return View();
            }
        }
    }

and in the project.json I embed the MyResources folder which contains Controllers.FooController.fr.resx

"buildOptions": {
    "embed": [ "Views/**", "MyResources/**" ]
},

It works if the main web app is configured like this:

services.AddLocalization();

but as soon as the web app decides to use this configuration:

services.AddLocalization(options => options.ResourcesPath = "Resources" );

It breaks the localization in FooController even though I'm using the factory and asking for exactly the correct name of my resource

[joeaudette]

and a further note, it is currently not possible in a class library to get a working IStringLocalizer like this:

    using Microsoft.AspNetCore.Mvc;
    using Microsoft.Extensions.Localization;

    namespace WebLib.Controllers
    {
        public class OtherController : Controller
        {
            public OtherController(
                IStringLocalizer<OtherController> localizer
                )
            {
                _localizer = localizer;
            }

            private readonly IStringLocalizer _localizer;

            public IActionResult Index()
            {
                ViewData["Title"] = _localizer["Otherwise"];
                ViewData["Message"] = _localizer["this is the other one"];

                return View();
            }
        }
   }

seems like with this approach there should at least be a convention where to put my resx files and how to name them so they work, but currently it just cannot work at all, so at the moment it is not possible to localize a controller that lives in a class library using IStringLocalizer, unless you fork the factory and change the logic

If it is not intended to work and we are supposed to do localization differently in a class library then it should be documented as such

[joeaudette]

so I implemented a PatchedResourceManagerStringLocalizerFactory with changes to get both broken examples working. To use:

IStringLocalizer<OtherController> 

requires a convention to add the resx file as embedded in the root of the class library named without the root namepace like Controllers.OtherController.fr.resx

I'm not sure if this is the same way the team would fix this but here is my full implementation:

        using System;
    using System.Collections.Concurrent;
    using System.IO;
    using System.Reflection;
    using System.Resources;
    using Microsoft.AspNetCore.Hosting;
    using Microsoft.Extensions.Options;

    namespace Microsoft.Extensions.Localization
    {
        /// <summary>
        /// An <see cref="IStringLocalizerFactory"/> that creates instances of <see cref="ResourceManagerStringLocalizer"/>.
        /// </summary>
        public class PatchedResourceManagerStringLocalizerFactory : IStringLocalizerFactory
        {
            private readonly IResourceNamesCache _resourceNamesCache = new ResourceNamesCache();
            private readonly ConcurrentDictionary<string, ResourceManagerStringLocalizer> _localizerCache =
                new ConcurrentDictionary<string, ResourceManagerStringLocalizer>();
            private readonly IHostingEnvironment _hostingEnvironment;
            private readonly string _resourcesRelativePath;

            /// <summary>
            /// Creates a new <see cref="ResourceManagerStringLocalizer"/>.
            /// </summary>
            /// <param name="hostingEnvironment">The <see cref="IHostingEnvironment"/>.</param>
            /// <param name="localizationOptions">The <see cref="IOptions{LocalizationOptions}"/>.</param>
            public PatchedResourceManagerStringLocalizerFactory(
                IHostingEnvironment hostingEnvironment,
                IOptions<LocalizationOptions> localizationOptions)
            {
                if (hostingEnvironment == null)
                {
                    throw new ArgumentNullException(nameof(hostingEnvironment));
                }

                if (localizationOptions == null)
                {
                    throw new ArgumentNullException(nameof(localizationOptions));
                }

                _hostingEnvironment = hostingEnvironment;
                _resourcesRelativePath = localizationOptions.Value.ResourcesPath ?? string.Empty;
                if (!string.IsNullOrEmpty(_resourcesRelativePath))
                {
                    _resourcesRelativePath = _resourcesRelativePath.Replace(Path.AltDirectorySeparatorChar, '.')
                        .Replace(Path.DirectorySeparatorChar, '.') + ".";
                }
            }

            /// <summary>
            /// Creates a <see cref="ResourceManagerStringLocalizer"/> using the <see cref="Assembly"/> and
            /// <see cref="Type.FullName"/> of the specified <see cref="Type"/>.
            /// </summary>
            /// <param name="resourceSource">The <see cref="Type"/>.</param>
            /// <returns>The <see cref="ResourceManagerStringLocalizer"/>.</returns>
            public IStringLocalizer Create(Type resourceSource)
            {
                if (resourceSource == null)
                {
                    throw new ArgumentNullException(nameof(resourceSource));
                }

                var typeInfo = resourceSource.GetTypeInfo();
                var assembly = typeInfo.Assembly;

                // Re-root the base name if a resources path is set
                string baseName;
                if (assembly.FullName.StartsWith(_hostingEnvironment.ApplicationName))
                {
                    baseName = string.IsNullOrEmpty(_resourcesRelativePath)
                    ? typeInfo.FullName
                    : _hostingEnvironment.ApplicationName + "." + _resourcesRelativePath
                        + TrimPrefix(typeInfo.FullName, _hostingEnvironment.ApplicationName + ".");
                }
                else
                {
                    var appName = TrimOnFirstComma(assembly.FullName); 
                    baseName = appName + "." +  TrimPrefix(typeInfo.FullName, appName + ".");
                }

                return _localizerCache.GetOrAdd(baseName, _ =>
                        new ResourceManagerStringLocalizer(
                            new ResourceManager(baseName, assembly),
                            assembly,
                            baseName,
                            _resourceNamesCache)
                            );
            }

            /// <summary>
            /// Creates a <see cref="ResourceManagerStringLocalizer"/>.
            /// </summary>
            /// <param name="baseName">The base name of the resource to load strings from.</param>
            /// <param name="location">The location to load resources from.</param>
            /// <returns>The <see cref="ResourceManagerStringLocalizer"/>.</returns>
            public IStringLocalizer Create(string baseName, string location)
            {
                if (baseName == null)
                {
                    throw new ArgumentNullException(nameof(baseName));
                }

                location = location ?? _hostingEnvironment.ApplicationName;

                if(location.StartsWith(_hostingEnvironment.ApplicationName))
                {
                    baseName = location + "." + _resourcesRelativePath + TrimPrefix(baseName, location + ".");
                }
                else 
                {
                    baseName = location + "." + TrimPrefix(baseName, location + ".");
                }

                return _localizerCache.GetOrAdd($"B={baseName},L={location}", _ =>
                {
                    var assembly = Assembly.Load(new AssemblyName(location));
                    return new ResourceManagerStringLocalizer(
                        new ResourceManager(baseName, assembly),
                        assembly,
                        baseName,
                        _resourceNamesCache);
                });
            }

            private static string TrimPrefix(string name, string prefix)
            {
                if (name.StartsWith(prefix, StringComparison.Ordinal))
                {
                    return name.Substring(prefix.Length);
                }
                return name;
            }

            private static string TrimOnFirstComma(string name)
            {     
                return name.Substring(0,name.IndexOf(","));    
            }
        }
    }

[joeaudette]

one more thing I noticed that I thought I should mention, maybe it is normal/intended but seemed a little weird to me. When I plug in my PatchedResourceManagerStringLocalizerFactory and I sett a breakpoint in the else of this method:

        public IStringLocalizer Create(Type resourceSource)
        {
            if (resourceSource == null)
            {
                throw new ArgumentNullException(nameof(resourceSource));
            }

            var typeInfo = resourceSource.GetTypeInfo();
            var assembly = typeInfo.Assembly;

            // Re-root the base name if a resources path is set
            string baseName;
            if (assembly.FullName.StartsWith(_hostingEnvironment.ApplicationName))
            {
                baseName = string.IsNullOrEmpty(_resourcesRelativePath)
                ? typeInfo.FullName
                : _hostingEnvironment.ApplicationName + "." + _resourcesRelativePath
                    + TrimPrefix(typeInfo.FullName, _hostingEnvironment.ApplicationName + ".");
            }
            else
            {
                //breakpoint here
                var appName = TrimOnFirstComma(assembly.FullName); 
                baseName = appName + "." +  TrimPrefix(typeInfo.FullName, appName + ".");
            }

            return _localizerCache.GetOrAdd(baseName, _ =>
                    new ResourceManagerStringLocalizer(
                        new ResourceManager(baseName, assembly),
                        assembly,
                        baseName,
                        _resourceNamesCache)
                        );


        }

if I set that breakpoint before starting the app in the debugger, I notice 2 times that method and else clause are invoked and the type being passed in is CultureInfo. I'm not sure where the calling code that does that is, I don't think it is part of my application code. After startup I don't see that happening anymore, just the 2 times at initial startup

maybe there is a good reason for that, but it seemed unexpected to me so thought I should mention it

[joeaudette]

figured out that the 2 times when CultureInfo is passed in as the type is happening because I'm using the language selector partial view from the Localization.StarterWeb sample

when I remove that from my _Layout I no longer see those invocations. But looking at the partial view I don't see where

IStringLocalizer<CultureInfo> 

is being requested, maybe it is being requested implicitly somehow

@using Microsoft.AspNetCore.Builder
@using Microsoft.AspNetCore.Http.Features
@using Microsoft.AspNetCore.Localization
@using Microsoft.AspNetCore.Mvc.Localization
@using Microsoft.Extensions.Options
@inject IViewLocalizer Localizer
@inject IOptions<RequestLocalizationOptions> LocOptions

@{
    var requestCulture = Context.Features.Get<IRequestCultureFeature>();
    var cultureItems = LocOptions.Value.SupportedUICultures
        .Select(c => new SelectListItem { Value = c.Name, Text = c.DisplayName })
        .ToList();
}

<div title="@Localizer["Request culture provider:"] @requestCulture?.Provider?.GetType().Name">
    <form id="selectLanguage" asp-controller="Home" asp-action="SetLanguage" asp-route-returnUrl="@Context.Request.Path" method="post" class="form-horizontal" role="form">
    @Localizer["Language:"] <select name="culture" asp-for="@requestCulture.RequestCulture.UICulture.Name" asp-items="cultureItems"></select>
    </form>
</div>

[joeaudette]

If the fixes in my PatchedResourcManagerStringLocalizerFactory look correct, I would be glad to submit a PR on ResourceManagerStringLocalizerFactory