Простой плагин для локализации приложений на Unity3D

    /// <summary>
    ///    Represents string localized to some language.
    /// </summary>
    [Serializable]
    public class LocalizationString
    {
        /// <summary>
        ///    Constructs empty LocalizationString.
        /// </summary>
        public LocalizationString() { }

        /// <summary>
        ///    Constructs LocalizationString with given description and localized value.
        /// </summary>
        public LocalizationString(String description, String value)
        {
            Description = description;
            Value = value;
        }

        public override String ToString()
        {
            return Value;
        }

        /// <summary>
        ///    Description of the string.
        /// </summary>
        public String Description { get; internal set; }

        /// <summary>
        ///    Translation of the string to desired language.
        /// </summary>
        public String Value { get; internal set; }
}

{
    "__type": "HabitableZone.Localization.Common.LocalizationString",
    "Description": "Settings button.",
    "Value": "Settings"
}

{
    "MainMenu.LoadWorldButton": 
        {
            "Description": "Load saved world button.",
            "Value": "Load world"
        },
    "MainMenu.NewWorldButton": 
        {
            "Description": "New world button.",
            "Value": "New world"
        },
    "MainMenu.QuitButton": 
        {
            "Description": "Quit button.",
            "Value": "Quit"
        },
    "MainMenu.SettingsButton": 
        {
            "Description": "Settings button.",
            "Value": "Settings"
        },
    "Shared.CommonLabels.Acceleration": 
        {
            "Description": "Title of UI elements used for displaying acceleration of something.",
            "Value": "Acceleration"
        },
    "Shared.CommonLabels.Mass": 
        {
            "Description": "Title of UI elements used for displaying mass of something.",
            "Value": "Mass"
        },
    "Shared.CommonLabels.Temperature": 
        {
            "Description": "Title of UI elements used for displaying temperature of something.",
            "Value": "Temperature"
        },
    "Shared.CommonLabels.Velocity": 
        {
            "Description": "Title of UI elements used for displaying velocity of something.",
            "Value": "Velocity"
        },
    "Shared.Units.AU": 
        {
            "Description": "AU",
            "Value": "AU"
        },
    "Shared.Units.Days": 
        {
            "Description": "Days",
            "Value": "d."
        },
    "Shared.Units.Kelvins": 
        {
            "Description": "Kelvins",
            "Value": "K"
        },
    "Shared.Units.Megawatts": 
        {
            "Description": "Megawatts",
            "Value": "MW"
        },
    "Shared.Units.Tons": 
        {
            "Description": "Tons",
            "Value": "t"
        },
    "Shared.Units.Years": 
        {
            "Description": "Years",
            "Value": "y."
        },
    "Shared.Units.kmps": 
        {
            "Description": "Kilometres per second",
            "Value": "km/s"
        },
    "Shared.Units.mps^2": 
        {
            "Description": "m/s^2",
            "Value": "m/s^2"
        },
    "Shared.VersionText": 
        {
            "Description": "Version text usually displayed near the corner of screen.",
            "Value": "Some Game Prototype v0.42"
        }
}

    /// <summary>
    ///    Provides acess to localized strings.
    /// </summary>
    public sealed class LocalizationManager
    {
        /// <summary>
        ///    Initializes LocalizationLanguage as unknown and tries to load provided localization.
        /// </summary>
        public LocalizationManager(SystemLanguage initialLanguage)
        {
            LocalizationLanguage = SystemLanguage.Unknown;
            try
            {
                Load(initialLanguage);
            }
            catch (LocalizationLoadException)
            {
                Debug.Log($"Can't load {initialLanguage}, loading English.");
                Load(SystemLanguage.English);
            }
        }

        /// <summary>
        ///    Occurs when LocalizationLanguage is changed.
        /// </summary>
        public event SEventHandler<SystemLanguage> LocalizationLanguageChanged;

        /// <summary>
        ///    Currently loaded localization's language. SystemLanguage.Unknown if nothing is loaded.
        /// </summary>
        public SystemLanguage LocalizationLanguage { get; private set; }

        /// <summary>
        ///    Loads localization for given language from resource files.
        /// </summary>
        /// <remarks>
        ///    Simply loads json as a dictionaries hierarchy.
        /// </remarks>
        public void Load(SystemLanguage language)
        {
            try
            {
                var textAsset = Resources.Load<TextAsset>(@"Localizations\" + language + @"Localization");
                using (var stream = new MemoryStream(textAsset.bytes))
                {
                    _localization = Serialization.DeserializeDataFromJson<GameLocalization>(stream);
                }

                LocalizationLanguage = language;

                LocalizationLanguageChanged?.Invoke(language);
            }
            catch (Exception exception)
            {
                throw new LocalizationLoadException(
                    $"Can't load localization of language \"{language}\".",
                    exception);
            }
        }

        /// <summary>
        ///    Returns localized string associated with the specified key.
        /// </summary>
        /// <remarks>
        ///    Example: UI.VersionText
        /// </remarks>
        public LocalizationString GetLocalizationString(String keyString)
        {
            try
            {
                return _localization[keyString];
            }
            catch (Exception exception)
            {
                throw new KeyNotFoundException($"Localization doesn't contains string of key {keyString}.",
                    exception);
            }
        }

        private GameLocalization _localization; //Практически пустой наследник Dictionary, я в нем только символ-разделитель определил
    }

    public class LocalizationLoadException : Exception
    {
        public LocalizationLoadException(String message, Exception innerException) : base(message, innerException) { }
    }

    /// <summary>
    ///    Sets localized string in the UnityEngine.UI.Text.text.
    /// </summary>
    public sealed class TextLocalizer : MonoBehaviour
    {
        [Inject]
        public void InjectDependencies(LocalizationManager localizationManager)
        {
            _localizationManager = localizationManager;
        }

        private void OnEnable()
        {
            _localizationManager.LocalizationLanguageChanged += SetText;
            SetText(_localizationManager.LocalizationLanguage);
        }

        private void OnDisable()
        {
            _localizationManager.LocalizationLanguageChanged -= SetText;
        }

        private void SetText(SystemLanguage language)
        {
            if (language != SystemLanguage.Unknown)
                GetComponent<Text>().text = _localizationManager.GetLocalizationString(_localizationKey).Value;
        }

        private LocalizationManager _localizationManager;

        [SerializeField] private String _localizationKey;
}