LocalizationProvider

Version 9.0 targets .NET 10 and introduces several productivity and performance enhancements:

Translations & Admin UI

• Automatic translations: Pluggable model supporting Azure AI / Cognitive Services. Supports single-resource translation and batch translations.
• Batch translations: Select multiple resources, choose source/target languages, and preview proposed translations before saving.
• Per-resource notes: Attach translator-facing hints using the [Notes] attribute in code or via the Admin UI. These round-trip through CSV import/export.
• Bulk delete: Remove multiple resources at once.
• Polished UI: Styled in-app confirmation dialogs.

Performance

• Optimized Sync: SQL Server synchronization uses a temp-table + bulk-copy path for large datasets.
• Refactored Caching: Uses CachedTranslations with targeted invalidation and reduced allocations.
• Memoization: Expression-based resource keys and cached handler chains.

When using [LocalizedModel], the library automatically discovers resources for standard ASP.NET DataAnnotation attributes. This allows you to translate validation error messages.

If a property has [Required] and [StringLength(5)], the library discovers keys for the property itself and the specific validation constraints (e.g., Property-Required).

Supported attributes include:

• [Display(Name = "...")] or [DisplayName]
• [Required]
• [StringLength]
• Any attribute where you specify a custom ErrorMessage.

namespace MySampleProject {

    [LocalizedModel]
    public class MyViewModel
    {
        [Display(Name = "This is default value")]
        [Required]
        [StringLength(5)]
        public string SampleProperty { get; set; }
    }
}

// Discovered keys:
// MySampleProject.MyViewModel.SampleProperty
// MySampleProject.MyViewModel.SampleProperty-Required
// MySampleProject.MyViewModel.SampleProperty-StringLength

You can create a resource hierarchy to avoid polluting the global namespace. To enable a natural usage path in code (e.g., MyPageResources.Header.HelloMessage), define the nested resource type as an instance property (do not use the static keyword on the nested property) within the parent [LocalizedResource] class.

Usage Pattern:

• Instance Property (Recommended): Allows usage like @Html.Translate(() => MyPageResources.Header.HelloMessage). The key becomes MyProject.MyPageResources.Header.HelloMessage.
• Static Property: Requires usage like @Html.Translate(() => MyPageResources.HeaderResources.HelloMessage). This makes the path harder to discover in code.

namespace MyProject
{
    [LocalizedResource]
    public class MyPageResources
    {
        public static string ThisIsErrorMessage => "This is default value from code";
        public static HeaderResources Header { get; }

        public class HeaderResources
        {
            // Note: No 'static' keyword here to allow nested path usage
            public string HelloMessage => "Well, hello there!";
        }
    }
}

// Usage in View:
// @Html.Translate(() => MyPageResources.Header.HelloMessage)

To prevent polluting your localization database with duplicate entries for common properties (like Yes, No, or FirstName), you can use the [UseResource] attribute to point a model property to an existing resource defined in a different class.

When a property is decorated with [UseResource], the localization engine will use the key from the referenced resource instead of generating a new key based on the current model's type and property name. This ensures that updating a single shared resource updates all properties that reference it.

// 1. Define a class for shared/common resources
[LocalizedResource]
public class CommonResources
{
    public static string CommonProp => "Common Value";
}

// 2. Reference that resource in your specific model
[LocalizedModel]
public class ModelWithOtherResourceUsage
{
    [UseResource(typeof(CommonResources), nameof(CommonResources.CommonProp))]
    public string SomeProperty { get; set; }
}

// 3. Use standard translation helpers in your views
// This will now resolve to 'CommonResources.CommonProp' instead of 'ModelWithOtherResourceUsage.SomeProperty'
@Html.TranslateFor(m => m.SomeProperty)