初始化仓库

This commit is contained in:
SepComet
2026-02-07 19:38:49 +08:00
commit 88641dae11
1540 changed files with 371772 additions and 0 deletions
@@ -0,0 +1,238 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFramework;
using GameFramework.Localization;
using System;
using System.IO;
using System.Text;
using UnityEngine;
namespace UnityGameFramework.Runtime
{
/// <summary>
/// 默认本地化辅助器。
/// </summary>
public class DefaultLocalizationHelper : LocalizationHelperBase
{
private static readonly string[] ColumnSplitSeparator = new string[] { "\t" };
private static readonly string BytesAssetExtension = ".bytes";
private const int ColumnCount = 4;
private ResourceComponent m_ResourceComponent = null;
/// <summary>
/// 获取系统语言。
/// </summary>
public override Language SystemLanguage
{
get
{
switch (Application.systemLanguage)
{
case UnityEngine.SystemLanguage.Afrikaans: return Language.Afrikaans;
case UnityEngine.SystemLanguage.Arabic: return Language.Arabic;
case UnityEngine.SystemLanguage.Basque: return Language.Basque;
case UnityEngine.SystemLanguage.Belarusian: return Language.Belarusian;
case UnityEngine.SystemLanguage.Bulgarian: return Language.Bulgarian;
case UnityEngine.SystemLanguage.Catalan: return Language.Catalan;
case UnityEngine.SystemLanguage.Chinese: return Language.ChineseSimplified;
case UnityEngine.SystemLanguage.ChineseSimplified: return Language.ChineseSimplified;
case UnityEngine.SystemLanguage.ChineseTraditional: return Language.ChineseTraditional;
case UnityEngine.SystemLanguage.Czech: return Language.Czech;
case UnityEngine.SystemLanguage.Danish: return Language.Danish;
case UnityEngine.SystemLanguage.Dutch: return Language.Dutch;
case UnityEngine.SystemLanguage.English: return Language.English;
case UnityEngine.SystemLanguage.Estonian: return Language.Estonian;
case UnityEngine.SystemLanguage.Faroese: return Language.Faroese;
case UnityEngine.SystemLanguage.Finnish: return Language.Finnish;
case UnityEngine.SystemLanguage.French: return Language.French;
case UnityEngine.SystemLanguage.German: return Language.German;
case UnityEngine.SystemLanguage.Greek: return Language.Greek;
case UnityEngine.SystemLanguage.Hebrew: return Language.Hebrew;
case UnityEngine.SystemLanguage.Hungarian: return Language.Hungarian;
case UnityEngine.SystemLanguage.Icelandic: return Language.Icelandic;
case UnityEngine.SystemLanguage.Indonesian: return Language.Indonesian;
case UnityEngine.SystemLanguage.Italian: return Language.Italian;
case UnityEngine.SystemLanguage.Japanese: return Language.Japanese;
case UnityEngine.SystemLanguage.Korean: return Language.Korean;
case UnityEngine.SystemLanguage.Latvian: return Language.Latvian;
case UnityEngine.SystemLanguage.Lithuanian: return Language.Lithuanian;
case UnityEngine.SystemLanguage.Norwegian: return Language.Norwegian;
case UnityEngine.SystemLanguage.Polish: return Language.Polish;
case UnityEngine.SystemLanguage.Portuguese: return Language.PortuguesePortugal;
case UnityEngine.SystemLanguage.Romanian: return Language.Romanian;
case UnityEngine.SystemLanguage.Russian: return Language.Russian;
case UnityEngine.SystemLanguage.SerboCroatian: return Language.SerboCroatian;
case UnityEngine.SystemLanguage.Slovak: return Language.Slovak;
case UnityEngine.SystemLanguage.Slovenian: return Language.Slovenian;
case UnityEngine.SystemLanguage.Spanish: return Language.Spanish;
case UnityEngine.SystemLanguage.Swedish: return Language.Swedish;
case UnityEngine.SystemLanguage.Thai: return Language.Thai;
case UnityEngine.SystemLanguage.Turkish: return Language.Turkish;
case UnityEngine.SystemLanguage.Ukrainian: return Language.Ukrainian;
case UnityEngine.SystemLanguage.Unknown: return Language.Unspecified;
case UnityEngine.SystemLanguage.Vietnamese: return Language.Vietnamese;
default: return Language.Unspecified;
}
}
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryAsset">字典资源。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public override bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, object dictionaryAsset, object userData)
{
TextAsset dictionaryTextAsset = dictionaryAsset as TextAsset;
if (dictionaryTextAsset != null)
{
if (dictionaryAssetName.EndsWith(BytesAssetExtension, StringComparison.Ordinal))
{
return localizationManager.ParseData(dictionaryTextAsset.bytes, userData);
}
else
{
return localizationManager.ParseData(dictionaryTextAsset.text, userData);
}
}
Log.Warning("Dictionary asset '{0}' is invalid.", dictionaryAssetName);
return false;
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryBytes">字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public override bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, byte[] dictionaryBytes, int startIndex, int length, object userData)
{
if (dictionaryAssetName.EndsWith(BytesAssetExtension, StringComparison.Ordinal))
{
return localizationManager.ParseData(dictionaryBytes, startIndex, length, userData);
}
else
{
return localizationManager.ParseData(Utility.Converter.GetString(dictionaryBytes, startIndex, length), userData);
}
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public override bool ParseData(ILocalizationManager localizationManager, string dictionaryString, object userData)
{
try
{
int position = 0;
string dictionaryLineString = null;
while ((dictionaryLineString = dictionaryString.ReadLine(ref position)) != null)
{
if (dictionaryLineString[0] == '#')
{
continue;
}
string[] splitedLine = dictionaryLineString.Split(ColumnSplitSeparator, StringSplitOptions.None);
if (splitedLine.Length != ColumnCount)
{
Log.Warning("Can not parse dictionary line string '{0}' which column count is invalid.", dictionaryLineString);
return false;
}
string dictionaryKey = splitedLine[1];
string dictionaryValue = splitedLine[3];
if (!localizationManager.AddRawString(dictionaryKey, dictionaryValue))
{
Log.Warning("Can not add raw string with dictionary key '{0}' which may be invalid or duplicate.", dictionaryKey);
return false;
}
}
return true;
}
catch (Exception exception)
{
Log.Warning("Can not parse dictionary string with exception '{0}'.", exception);
return false;
}
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public override bool ParseData(ILocalizationManager localizationManager, byte[] dictionaryBytes, int startIndex, int length, object userData)
{
try
{
using (MemoryStream memoryStream = new MemoryStream(dictionaryBytes, startIndex, length, false))
{
using (BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8))
{
while (binaryReader.BaseStream.Position < binaryReader.BaseStream.Length)
{
string dictionaryKey = binaryReader.ReadString();
string dictionaryValue = binaryReader.ReadString();
if (!localizationManager.AddRawString(dictionaryKey, dictionaryValue))
{
Log.Warning("Can not add raw string with dictionary key '{0}' which may be invalid or duplicate.", dictionaryKey);
return false;
}
}
}
}
return true;
}
catch (Exception exception)
{
Log.Warning("Can not parse dictionary bytes with exception '{0}'.", exception);
return false;
}
}
/// <summary>
/// 释放字典资源。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAsset">要释放的字典资源。</param>
public override void ReleaseDataAsset(ILocalizationManager localizationManager, object dictionaryAsset)
{
m_ResourceComponent.UnloadAsset(dictionaryAsset);
}
private void Start()
{
m_ResourceComponent = GameEntry.GetComponent<ResourceComponent>();
if (m_ResourceComponent == null)
{
Log.Fatal("Resource component is invalid.");
return;
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 57465d541030d834b9d764c79af94e2e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,119 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFramework;
using GameFramework.Event;
namespace UnityGameFramework.Runtime
{
/// <summary>
/// 加载字典时加载依赖资源事件。
/// </summary>
public sealed class LoadDictionaryDependencyAssetEventArgs : GameEventArgs
{
/// <summary>
/// 加载字典时加载依赖资源事件编号。
/// </summary>
public static readonly int EventId = typeof(LoadDictionaryDependencyAssetEventArgs).GetHashCode();
/// <summary>
/// 初始化加载字典时加载依赖资源事件的新实例。
/// </summary>
public LoadDictionaryDependencyAssetEventArgs()
{
DictionaryAssetName = null;
DependencyAssetName = null;
LoadedCount = 0;
TotalCount = 0;
UserData = null;
}
/// <summary>
/// 获取加载字典时加载依赖资源事件编号。
/// </summary>
public override int Id
{
get
{
return EventId;
}
}
/// <summary>
/// 获取字典资源名称。
/// </summary>
public string DictionaryAssetName
{
get;
private set;
}
/// <summary>
/// 获取被加载的依赖资源名称。
/// </summary>
public string DependencyAssetName
{
get;
private set;
}
/// <summary>
/// 获取当前已加载依赖资源数量。
/// </summary>
public int LoadedCount
{
get;
private set;
}
/// <summary>
/// 获取总共加载依赖资源数量。
/// </summary>
public int TotalCount
{
get;
private set;
}
/// <summary>
/// 获取用户自定义数据。
/// </summary>
public object UserData
{
get;
private set;
}
/// <summary>
/// 创建加载字典时加载依赖资源事件。
/// </summary>
/// <param name="e">内部事件。</param>
/// <returns>创建的加载字典时加载依赖资源事件。</returns>
public static LoadDictionaryDependencyAssetEventArgs Create(ReadDataDependencyAssetEventArgs e)
{
LoadDictionaryDependencyAssetEventArgs loadDictionaryDependencyAssetEventArgs = ReferencePool.Acquire<LoadDictionaryDependencyAssetEventArgs>();
loadDictionaryDependencyAssetEventArgs.DictionaryAssetName = e.DataAssetName;
loadDictionaryDependencyAssetEventArgs.DependencyAssetName = e.DependencyAssetName;
loadDictionaryDependencyAssetEventArgs.LoadedCount = e.LoadedCount;
loadDictionaryDependencyAssetEventArgs.TotalCount = e.TotalCount;
loadDictionaryDependencyAssetEventArgs.UserData = e.UserData;
return loadDictionaryDependencyAssetEventArgs;
}
/// <summary>
/// 清理加载字典时加载依赖资源事件。
/// </summary>
public override void Clear()
{
DictionaryAssetName = null;
DependencyAssetName = null;
LoadedCount = 0;
TotalCount = 0;
UserData = null;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 1b3481fe69ce20a49ad4735ec0d2b9dc
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,95 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFramework;
using GameFramework.Event;
namespace UnityGameFramework.Runtime
{
/// <summary>
/// 加载字典失败事件。
/// </summary>
public sealed class LoadDictionaryFailureEventArgs : GameEventArgs
{
/// <summary>
/// 加载字典失败事件编号。
/// </summary>
public static readonly int EventId = typeof(LoadDictionaryFailureEventArgs).GetHashCode();
/// <summary>
/// 初始化加载字典失败事件的新实例。
/// </summary>
public LoadDictionaryFailureEventArgs()
{
DictionaryAssetName = null;
ErrorMessage = null;
UserData = null;
}
/// <summary>
/// 获取加载字典失败事件编号。
/// </summary>
public override int Id
{
get
{
return EventId;
}
}
/// <summary>
/// 获取字典资源名称。
/// </summary>
public string DictionaryAssetName
{
get;
private set;
}
/// <summary>
/// 获取错误信息。
/// </summary>
public string ErrorMessage
{
get;
private set;
}
/// <summary>
/// 获取用户自定义数据。
/// </summary>
public object UserData
{
get;
private set;
}
/// <summary>
/// 创建加载字典失败事件。
/// </summary>
/// <param name="e">内部事件。</param>
/// <returns>创建的加载字典失败事件。</returns>
public static LoadDictionaryFailureEventArgs Create(ReadDataFailureEventArgs e)
{
LoadDictionaryFailureEventArgs loadDictionaryFailureEventArgs = ReferencePool.Acquire<LoadDictionaryFailureEventArgs>();
loadDictionaryFailureEventArgs.DictionaryAssetName = e.DataAssetName;
loadDictionaryFailureEventArgs.ErrorMessage = e.ErrorMessage;
loadDictionaryFailureEventArgs.UserData = e.UserData;
return loadDictionaryFailureEventArgs;
}
/// <summary>
/// 清理加载字典失败事件。
/// </summary>
public override void Clear()
{
DictionaryAssetName = null;
ErrorMessage = null;
UserData = null;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 82e68c5abc85cb346b4dd03c73bb8c10
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,95 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFramework;
using GameFramework.Event;
namespace UnityGameFramework.Runtime
{
/// <summary>
/// 加载字典成功事件。
/// </summary>
public sealed class LoadDictionarySuccessEventArgs : GameEventArgs
{
/// <summary>
/// 加载字典成功事件编号。
/// </summary>
public static readonly int EventId = typeof(LoadDictionarySuccessEventArgs).GetHashCode();
/// <summary>
/// 初始化加载字典成功事件的新实例。
/// </summary>
public LoadDictionarySuccessEventArgs()
{
DictionaryAssetName = null;
Duration = 0f;
UserData = null;
}
/// <summary>
/// 获取加载字典成功事件编号。
/// </summary>
public override int Id
{
get
{
return EventId;
}
}
/// <summary>
/// 获取字典资源名称。
/// </summary>
public string DictionaryAssetName
{
get;
private set;
}
/// <summary>
/// 获取加载持续时间。
/// </summary>
public float Duration
{
get;
private set;
}
/// <summary>
/// 获取用户自定义数据。
/// </summary>
public object UserData
{
get;
private set;
}
/// <summary>
/// 创建加载字典成功事件。
/// </summary>
/// <param name="e">内部事件。</param>
/// <returns>创建的加载字典成功事件。</returns>
public static LoadDictionarySuccessEventArgs Create(ReadDataSuccessEventArgs e)
{
LoadDictionarySuccessEventArgs loadDictionarySuccessEventArgs = ReferencePool.Acquire<LoadDictionarySuccessEventArgs>();
loadDictionarySuccessEventArgs.DictionaryAssetName = e.DataAssetName;
loadDictionarySuccessEventArgs.Duration = e.Duration;
loadDictionarySuccessEventArgs.UserData = e.UserData;
return loadDictionarySuccessEventArgs;
}
/// <summary>
/// 清理加载字典成功事件。
/// </summary>
public override void Clear()
{
DictionaryAssetName = null;
Duration = 0f;
UserData = null;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 21fad28624e6eca4e86242e3fe512359
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,95 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFramework;
using GameFramework.Event;
namespace UnityGameFramework.Runtime
{
/// <summary>
/// 加载字典更新事件。
/// </summary>
public sealed class LoadDictionaryUpdateEventArgs : GameEventArgs
{
/// <summary>
/// 加载字典更新事件编号。
/// </summary>
public static readonly int EventId = typeof(LoadDictionaryUpdateEventArgs).GetHashCode();
/// <summary>
/// 初始化加载字典更新事件的新实例。
/// </summary>
public LoadDictionaryUpdateEventArgs()
{
DictionaryAssetName = null;
Progress = 0f;
UserData = null;
}
/// <summary>
/// 获取加载字典更新事件编号。
/// </summary>
public override int Id
{
get
{
return EventId;
}
}
/// <summary>
/// 获取字典资源名称。
/// </summary>
public string DictionaryAssetName
{
get;
private set;
}
/// <summary>
/// 获取加载字典进度。
/// </summary>
public float Progress
{
get;
private set;
}
/// <summary>
/// 获取用户自定义数据。
/// </summary>
public object UserData
{
get;
private set;
}
/// <summary>
/// 创建加载字典更新事件。
/// </summary>
/// <param name="e">内部事件。</param>
/// <returns>创建的加载字典更新事件。</returns>
public static LoadDictionaryUpdateEventArgs Create(ReadDataUpdateEventArgs e)
{
LoadDictionaryUpdateEventArgs loadDictionaryUpdateEventArgs = ReferencePool.Acquire<LoadDictionaryUpdateEventArgs>();
loadDictionaryUpdateEventArgs.DictionaryAssetName = e.DataAssetName;
loadDictionaryUpdateEventArgs.Progress = e.Progress;
loadDictionaryUpdateEventArgs.UserData = e.UserData;
return loadDictionaryUpdateEventArgs;
}
/// <summary>
/// 清理加载字典更新事件。
/// </summary>
public override void Clear()
{
DictionaryAssetName = null;
Progress = 0f;
UserData = null;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 067358629da8fc440b396eea65bb6434
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,789 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFramework;
using GameFramework.Localization;
using GameFramework.Resource;
using UnityEngine;
namespace UnityGameFramework.Runtime
{
/// <summary>
/// 本地化组件。
/// </summary>
[DisallowMultipleComponent]
[AddComponentMenu("Game Framework/Localization")]
public sealed class LocalizationComponent : GameFrameworkComponent
{
private const int DefaultPriority = 0;
private ILocalizationManager m_LocalizationManager = null;
private EventComponent m_EventComponent = null;
[SerializeField]
private bool m_EnableLoadDictionaryUpdateEvent = false;
[SerializeField]
private bool m_EnableLoadDictionaryDependencyAssetEvent = false;
[SerializeField]
private string m_LocalizationHelperTypeName = "UnityGameFramework.Runtime.DefaultLocalizationHelper";
[SerializeField]
private LocalizationHelperBase m_CustomLocalizationHelper = null;
[SerializeField]
private int m_CachedBytesSize = 0;
/// <summary>
/// 获取或设置本地化语言。
/// </summary>
public Language Language
{
get
{
return m_LocalizationManager.Language;
}
set
{
m_LocalizationManager.Language = value;
}
}
/// <summary>
/// 获取系统语言。
/// </summary>
public Language SystemLanguage
{
get
{
return m_LocalizationManager.SystemLanguage;
}
}
/// <summary>
/// 获取字典数量。
/// </summary>
public int DictionaryCount
{
get
{
return m_LocalizationManager.DictionaryCount;
}
}
/// <summary>
/// 获取缓冲二进制流的大小。
/// </summary>
public int CachedBytesSize
{
get
{
return m_LocalizationManager.CachedBytesSize;
}
}
/// <summary>
/// 游戏框架组件初始化。
/// </summary>
protected override void Awake()
{
base.Awake();
m_LocalizationManager = GameFrameworkEntry.GetModule<ILocalizationManager>();
if (m_LocalizationManager == null)
{
Log.Fatal("Localization manager is invalid.");
return;
}
m_LocalizationManager.ReadDataSuccess += OnReadDataSuccess;
m_LocalizationManager.ReadDataFailure += OnReadDataFailure;
if (m_EnableLoadDictionaryUpdateEvent)
{
m_LocalizationManager.ReadDataUpdate += OnReadDataUpdate;
}
if (m_EnableLoadDictionaryDependencyAssetEvent)
{
m_LocalizationManager.ReadDataDependencyAsset += OnReadDataDependencyAsset;
}
}
private void Start()
{
BaseComponent baseComponent = GameEntry.GetComponent<BaseComponent>();
if (baseComponent == null)
{
Log.Fatal("Base component is invalid.");
return;
}
m_EventComponent = GameEntry.GetComponent<EventComponent>();
if (m_EventComponent == null)
{
Log.Fatal("Event component is invalid.");
return;
}
if (baseComponent.EditorResourceMode)
{
m_LocalizationManager.SetResourceManager(baseComponent.EditorResourceHelper);
}
else
{
m_LocalizationManager.SetResourceManager(GameFrameworkEntry.GetModule<IResourceManager>());
}
LocalizationHelperBase localizationHelper = Helper.CreateHelper(m_LocalizationHelperTypeName, m_CustomLocalizationHelper);
if (localizationHelper == null)
{
Log.Error("Can not create localization helper.");
return;
}
localizationHelper.name = "Localization Helper";
Transform transform = localizationHelper.transform;
transform.SetParent(this.transform);
transform.localScale = Vector3.one;
m_LocalizationManager.SetDataProviderHelper(localizationHelper);
m_LocalizationManager.SetLocalizationHelper(localizationHelper);
m_LocalizationManager.Language = baseComponent.EditorResourceMode && baseComponent.EditorLanguage != Language.Unspecified ? baseComponent.EditorLanguage : m_LocalizationManager.SystemLanguage;
if (m_CachedBytesSize > 0)
{
EnsureCachedBytesSize(m_CachedBytesSize);
}
}
/// <summary>
/// 确保二进制流缓存分配足够大小的内存并缓存。
/// </summary>
/// <param name="ensureSize">要确保二进制流缓存分配内存的大小。</param>
public void EnsureCachedBytesSize(int ensureSize)
{
m_LocalizationManager.EnsureCachedBytesSize(ensureSize);
}
/// <summary>
/// 释放缓存的二进制流。
/// </summary>
public void FreeCachedBytes()
{
m_LocalizationManager.FreeCachedBytes();
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
public void ReadData(string dictionaryAssetName)
{
m_LocalizationManager.ReadData(dictionaryAssetName);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="priority">加载字典资源的优先级。</param>
public void ReadData(string dictionaryAssetName, int priority)
{
m_LocalizationManager.ReadData(dictionaryAssetName, priority);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="userData">用户自定义数据。</param>
public void ReadData(string dictionaryAssetName, object userData)
{
m_LocalizationManager.ReadData(dictionaryAssetName, userData);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="priority">加载字典资源的优先级。</param>
/// <param name="userData">用户自定义数据。</param>
public void ReadData(string dictionaryAssetName, int priority, object userData)
{
m_LocalizationManager.ReadData(dictionaryAssetName, priority, userData);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(string dictionaryString)
{
return m_LocalizationManager.ParseData(dictionaryString);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(string dictionaryString, object userData)
{
return m_LocalizationManager.ParseData(dictionaryString, userData);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes)
{
return m_LocalizationManager.ParseData(dictionaryBytes);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, object userData)
{
return m_LocalizationManager.ParseData(dictionaryBytes, userData);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, int startIndex, int length)
{
return m_LocalizationManager.ParseData(dictionaryBytes, startIndex, length);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, int startIndex, int length, object userData)
{
return m_LocalizationManager.ParseData(dictionaryBytes, startIndex, length, userData);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString(string key)
{
return m_LocalizationManager.GetString(key);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T">字典参数的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg">字典参数。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T>(string key, T arg)
{
return m_LocalizationManager.GetString(key, arg);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2>(string key, T1 arg1, T2 arg2)
{
return m_LocalizationManager.GetString(key, arg1, arg2);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3>(string key, T1 arg1, T2 arg2, T3 arg3)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <typeparam name="T9">字典参数 9 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <param name="arg9">字典参数 9。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <typeparam name="T9">字典参数 9 的类型。</typeparam>
/// <typeparam name="T10">字典参数 10 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <param name="arg9">字典参数 9。</param>
/// <param name="arg10">字典参数 10。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <typeparam name="T9">字典参数 9 的类型。</typeparam>
/// <typeparam name="T10">字典参数 10 的类型。</typeparam>
/// <typeparam name="T11">字典参数 11 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <param name="arg9">字典参数 9。</param>
/// <param name="arg10">字典参数 10。</param>
/// <param name="arg11">字典参数 11。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <typeparam name="T9">字典参数 9 的类型。</typeparam>
/// <typeparam name="T10">字典参数 10 的类型。</typeparam>
/// <typeparam name="T11">字典参数 11 的类型。</typeparam>
/// <typeparam name="T12">字典参数 12 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <param name="arg9">字典参数 9。</param>
/// <param name="arg10">字典参数 10。</param>
/// <param name="arg11">字典参数 11。</param>
/// <param name="arg12">字典参数 12。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <typeparam name="T9">字典参数 9 的类型。</typeparam>
/// <typeparam name="T10">字典参数 10 的类型。</typeparam>
/// <typeparam name="T11">字典参数 11 的类型。</typeparam>
/// <typeparam name="T12">字典参数 12 的类型。</typeparam>
/// <typeparam name="T13">字典参数 13 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <param name="arg9">字典参数 9。</param>
/// <param name="arg10">字典参数 10。</param>
/// <param name="arg11">字典参数 11。</param>
/// <param name="arg12">字典参数 12。</param>
/// <param name="arg13">字典参数 13。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <typeparam name="T9">字典参数 9 的类型。</typeparam>
/// <typeparam name="T10">字典参数 10 的类型。</typeparam>
/// <typeparam name="T11">字典参数 11 的类型。</typeparam>
/// <typeparam name="T12">字典参数 12 的类型。</typeparam>
/// <typeparam name="T13">字典参数 13 的类型。</typeparam>
/// <typeparam name="T14">字典参数 14 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <param name="arg9">字典参数 9。</param>
/// <param name="arg10">字典参数 10。</param>
/// <param name="arg11">字典参数 11。</param>
/// <param name="arg12">字典参数 12。</param>
/// <param name="arg13">字典参数 13。</param>
/// <param name="arg14">字典参数 14。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <typeparam name="T9">字典参数 9 的类型。</typeparam>
/// <typeparam name="T10">字典参数 10 的类型。</typeparam>
/// <typeparam name="T11">字典参数 11 的类型。</typeparam>
/// <typeparam name="T12">字典参数 12 的类型。</typeparam>
/// <typeparam name="T13">字典参数 13 的类型。</typeparam>
/// <typeparam name="T14">字典参数 14 的类型。</typeparam>
/// <typeparam name="T15">字典参数 15 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <param name="arg9">字典参数 9。</param>
/// <param name="arg10">字典参数 10。</param>
/// <param name="arg11">字典参数 11。</param>
/// <param name="arg12">字典参数 12。</param>
/// <param name="arg13">字典参数 13。</param>
/// <param name="arg14">字典参数 14。</param>
/// <param name="arg15">字典参数 15。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <typeparam name="T5">字典参数 5 的类型。</typeparam>
/// <typeparam name="T6">字典参数 6 的类型。</typeparam>
/// <typeparam name="T7">字典参数 7 的类型。</typeparam>
/// <typeparam name="T8">字典参数 8 的类型。</typeparam>
/// <typeparam name="T9">字典参数 9 的类型。</typeparam>
/// <typeparam name="T10">字典参数 10 的类型。</typeparam>
/// <typeparam name="T11">字典参数 11 的类型。</typeparam>
/// <typeparam name="T12">字典参数 12 的类型。</typeparam>
/// <typeparam name="T13">字典参数 13 的类型。</typeparam>
/// <typeparam name="T14">字典参数 14 的类型。</typeparam>
/// <typeparam name="T15">字典参数 15 的类型。</typeparam>
/// <typeparam name="T16">字典参数 16 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <param name="arg5">字典参数 5。</param>
/// <param name="arg6">字典参数 6。</param>
/// <param name="arg7">字典参数 7。</param>
/// <param name="arg8">字典参数 8。</param>
/// <param name="arg9">字典参数 9。</param>
/// <param name="arg10">字典参数 10。</param>
/// <param name="arg11">字典参数 11。</param>
/// <param name="arg12">字典参数 12。</param>
/// <param name="arg13">字典参数 13。</param>
/// <param name="arg14">字典参数 14。</param>
/// <param name="arg15">字典参数 15。</param>
/// <param name="arg16">字典参数 16。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
}
/// <summary>
/// 是否存在字典。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>是否存在字典。</returns>
public bool HasRawString(string key)
{
return m_LocalizationManager.HasRawString(key);
}
/// <summary>
/// 根据字典主键获取字典值。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>字典值。</returns>
public string GetRawString(string key)
{
return m_LocalizationManager.GetRawString(key);
}
/// <summary>
/// 移除字典。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>是否移除字典成功。</returns>
public bool RemoveRawString(string key)
{
return m_LocalizationManager.RemoveRawString(key);
}
/// <summary>
/// 清空所有字典。
/// </summary>
public void RemoveAllRawStrings()
{
m_LocalizationManager.RemoveAllRawStrings();
}
private void OnReadDataSuccess(object sender, ReadDataSuccessEventArgs e)
{
m_EventComponent.Fire(this, LoadDictionarySuccessEventArgs.Create(e));
}
private void OnReadDataFailure(object sender, ReadDataFailureEventArgs e)
{
Log.Warning("Load dictionary failure, asset name '{0}', error message '{1}'.", e.DataAssetName, e.ErrorMessage);
m_EventComponent.Fire(this, LoadDictionaryFailureEventArgs.Create(e));
}
private void OnReadDataUpdate(object sender, ReadDataUpdateEventArgs e)
{
m_EventComponent.Fire(this, LoadDictionaryUpdateEventArgs.Create(e));
}
private void OnReadDataDependencyAsset(object sender, ReadDataDependencyAssetEventArgs e)
{
m_EventComponent.Fire(this, LoadDictionaryDependencyAssetEventArgs.Create(e));
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 706e6317a59f61044b2805be79f6b284
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,76 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFramework;
using GameFramework.Localization;
using UnityEngine;
namespace UnityGameFramework.Runtime
{
/// <summary>
/// 本地化辅助器基类。
/// </summary>
public abstract class LocalizationHelperBase : MonoBehaviour, IDataProviderHelper<ILocalizationManager>, ILocalizationHelper
{
/// <summary>
/// 获取系统语言。
/// </summary>
public abstract Language SystemLanguage
{
get;
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryAsset">字典资源。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public abstract bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, object dictionaryAsset, object userData);
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryBytes">字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public abstract bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, byte[] dictionaryBytes, int startIndex, int length, object userData);
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public abstract bool ParseData(ILocalizationManager localizationManager, string dictionaryString, object userData);
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public abstract bool ParseData(ILocalizationManager localizationManager, byte[] dictionaryBytes, int startIndex, int length, object userData);
/// <summary>
/// 释放字典资源。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAsset">要释放的字典资源。</param>
public abstract void ReleaseDataAsset(ILocalizationManager localizationManager, object dictionaryAsset);
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 91f20cfd35b8d804ab29f8c3bc25fed8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: