public static VirtualFile OpenAsFormat(Stream baseStream, string filename, int offset = 0, int length = -1, FileFormat format = FileFormat.None, CacheMethod m = CacheMethod.Default) {
if (length == -1) length = (int)baseStream.Length;
if (format == FileFormat.None) {
format = GuessFormat(filename);
logger.Debug("Guessed format: {0}", format);
}
switch (format) {
case FileFormat.Csf:
return new CsfFile(baseStream, filename, offset, length, m != CacheMethod.NoCache); // defaults to cache
case FileFormat.Hva:
return new HvaFile(baseStream, filename, offset, length, m != CacheMethod.NoCache); // defaults to not cache
case FileFormat.Ini:
return new IniFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Missions:
return new MissionsFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Mix:
return new MixFile(baseStream, filename, offset, length, m == CacheMethod.Cache);
case FileFormat.Pal:
return new PalFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Pkt:
return new PktFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Shp:
return new ShpFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Tmp:
return new TmpFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Vpl:
return new VplFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Vxl:
return new VxlFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
case FileFormat.Ukn:
default:
return new VirtualFile(baseStream, filename, offset, length, m != CacheMethod.NoCache);
}
}
public virtual CLS_Content.Value MemberValueGet(CLS_Content content, object object_this, string valuename, bool isBaseCall = false)
{
#if UNITY_EDITOR
if (object_this == null)
{
throw new NotImplementedException("MemberValueGet实例 = null:" + type.ToString() + "." + valuename);
}
#endif
CacheMethod cache;
if (!s_cacheGet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.field = type.GetField(valuename);
if (cache.field == null)
{
cache.method = type.GetMethod("get_" + valuename);
if (cache.method == null)
{
Type baseType = type.BaseType;
while (baseType != null)
{
cache.field = baseType.GetField(valuename);
if (cache.field == null)
{
cache.method = baseType.GetMethod("get_" + valuename);
if (cache.method != null)
{
break;
}
}
else
{
break;
}
baseType = baseType.BaseType;
}
if (cache.field == null && cache.method == null)
{
throw new NotImplementedException("实例属性不存在:" + type.ToString() + "." + valuename);
}
}
}
s_cacheGet[content.CallExpression] = cache;
}
CLS_Content.Value retVal = new CLS_Content.Value();
if (cache.field != null)
{
retVal.value = cache.field.GetValue(object_this);
retVal.type = cache.field.FieldType;
}
else
{
retVal.value = cache.method.Invoke(object_this, null);
retVal.type = cache.method.ReturnType;
}
return(retVal);
}
public bool AddItem(string path, CacheMethod m = CacheMethod.Default)
{
// directory
if (Directory.Exists(path))
{
AllArchives.Add(new DirArchive(path));
Logger.Trace("Added <DirArchive> {0} to VFS", path);
return(true);
}
// regular file
else if (File.Exists(path))
{
var fi = new FileInfo(path);
// mix file
if (FormatHelper.MixArchiveExtensions.Contains(fi.Extension, StringComparer.InvariantCultureIgnoreCase))
{
var mf = new MixFile(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read));
mf.FileName = path;
AllArchives.Add(mf);
Logger.Trace("Added <MixFile> {0} to VFS", path);
return(true);
}
}
// virtual mix file
else if (FileExists(path))
{
var mx = Open(path, FileFormat.Mix) as MixFile;
AllArchives.Add(mx);
Logger.Trace("Added <VirtualMixFile> {0} to VFS", path);
return(true);
}
return(false);
}
private void SetDefaultArguments(CacheMethod defaultMethod, double defaultMinimumAgeInMilliseconds)
{
DefaultMethod = defaultMethod;
DefaultMinimumAgeInMilliseconds = defaultMinimumAgeInMilliseconds;
Arguments = new Object[] { defaultMethod, defaultMinimumAgeInMilliseconds };
}
public static void AddCacheMethod(CacheMethod method)
{
#if UNITY_ANDROID && !UNITY_EDITOR
switch (method)
{
case CacheMethod.getActivityMetaValue:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getActivityMetaValue, string2StringSign);
break;
case CacheMethod.getApplicationMetaValue:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getApplicationMetaValue, string2StringSign);
break;
case CacheMethod.getLayoutId:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getLayoutId, string2IntSign);
break;
case CacheMethod.getStringId:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getStringId, string2IntSign);
break;
case CacheMethod.getDrawableId:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getDrawableId, string2IntSign);
break;
case CacheMethod.getStyleId:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getStyleId, string2IntSign);
break;
case CacheMethod.getId:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getId, string2IntSign);
break;
case CacheMethod.getColorId:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getColorId, string2IntSign);
break;
case CacheMethod.getStringValue:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getStringValue, string2StringSign);
break;
case CacheMethod.getAppMemory:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getAppMemory, void2IntSign);
break;
case CacheMethod.getAvailMemory:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getAvailMemory, void2IntSign);
break;
case CacheMethod.getCpuRate:
_androidCall.RegisterStaticMethod(ANDROID_INFO_JAVA_CLASS, getCpuRate, void2IntSign);
break;
}
#else
Debug.LogError("AndroidInfo.AddCacheMethod : Please use AndroidInfo in Android platform!");
#endif
}
public static CacheMember GetCacheObject(MemberInfo member, object declaringInstance)
{
CacheMember ret;
if (member is MethodInfo mi && CanProcessArgs(mi.GetParameters()))
{
ret = new CacheMethod();
ret.InitMember(mi, declaringInstance);
}
public virtual CLS_Content.Value StaticValueGet(CLS_Content content, string valuename)
{
CacheMethod cache;
if (!s_cacheGet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.field = type.GetField(valuename);
if (cache.field == null)
{
cache.method = type.GetMethod("get_" + valuename);
if (cache.method == null)
{
Type baseType = type.BaseType;
while (baseType != null)
{
cache.field = baseType.GetField(valuename);
if (cache.field == null)
{
cache.method = baseType.GetMethod("get_" + valuename);
if (cache.method != null)
{
break;
}
}
else
{
break;
}
baseType = baseType.BaseType;
}
if (cache.field == null && cache.method == null)
{
throw new NotImplementedException("静态属性不存在:" + type.ToString() + "." + valuename);
}
}
}
s_cacheGet[content.CallExpression] = cache;
}
CLS_Content.Value retVal = new CLS_Content.Value();
if (cache.field != null)
{
retVal.value = cache.field.GetValue(null);
retVal.type = cache.field.FieldType;
}
else
{
retVal.value = cache.method.Invoke(null, null);
retVal.type = cache.method.ReturnType;
}
return(retVal);
}
public VirtualFile OpenFile(string filename, FileFormat f = FileFormat.None, CacheMethod m = CacheMethod.Default)
{
MixEntry e;
if (!Index.TryGetValue(MixEntry.HashFilename(filename), out e))
{
return(null);
}
else
{
return(FormatHelper.OpenAsFormat(BaseStream, filename, (int)(BaseOffset + dataStart + e.Offset), (int)e.Length, f, m));
}
}
public virtual CLS_Content.Value New(CLS_Content content, BetterList <CLS_Content.Value> _params)
{
Type[] pts = CLS_Content.ParamTypesArray[_params.size];
object[] ps = CLS_Content.ParamObjsArray[_params.size];
CLS_Content.Value tempValue;
for (int i = 0; i < _params.size; i++)
{
tempValue = _params[i];
if (tempValue.type == null)
{
pts[i] = typeof(object);
}
else if ((SType)tempValue.type != null)
{
pts[i] = typeof(SInstance);
}
else if ((Type)tempValue.type != null)
{
pts[i] = tempValue.type;
}
else
{
pts[i] = typeof(object);
}
ps[i] = tempValue.value;
}
CacheMethod cache;
if (!s_cacheMethod.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.constructor = this.type.GetConstructor(pts);
s_cacheMethod[content.CallExpression] = cache;
}
CLS_Content.Value retVal = new CLS_Content.Value();
if (cache.constructor != null)
{
retVal.value = cache.constructor.Invoke(ps);
retVal.type = this.type;
}
else
{
retVal.value = Activator.CreateInstance(this.type);
retVal.type = this.type;
}
return(retVal);
}
String GetKeyParam(CacheMethod cacheMethod, IParameterCollection inputs)
{
StringBuilder sb = new StringBuilder();
sb.ToString();
sb.Append(cacheMethod.ToString());
if (inputs != null && inputs.Count > 0)
{
foreach (var item in inputs)
{
sb.Append("-");
sb.Append(item.ToString());
}
}
return(sb.ToString());
}
public virtual CLS_Content.Value IndexGet(CLS_Content content, object object_this, object key)
{
CacheMethod cache;
if (!s_cacheGet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.method = type.GetMethod("get_Item");
if (cache.method == null)
{
cache.method = type.GetMethod("GetValue", new Type[] { typeof(int) });
if (cache.method == null)
{
throw new NotImplementedException("IndexGet不存在:" + type.ToString() + "." + key);
}
}
cache.defaultParamStart = (sbyte)(cache.method.Name == "get_Item" ? 0 : -1);
s_cacheGet[content.CallExpression] = cache;
}
CLS_Content.Value retVal = new CLS_Content.Value();
if (cache.defaultParamStart == 0)
{
object[] ps = CLS_Content.ParamObjsArray[1];
ps[0] = key;
retVal.value = cache.method.Invoke(object_this, ps);
retVal.type = cache.method.ReturnType;
}
else
{
object[] ps = CLS_Content.ParamObjsArray[1];
ps[0] = key;
retVal.value = cache.method.Invoke(object_this, ps);
retVal.type = type.GetElementType();
}
return(retVal);
}
public virtual void IndexSet(CLS_Content content, object object_this, object key, object value)
{
CacheMethod cache;
if (!s_cacheSet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.method = type.GetMethod("set_Item");
if (cache.method == null)
{
cache.method = type.GetMethod("SetValue", new Type[] { typeof(object), typeof(int) });
if (cache.method == null)
{
throw new NotImplementedException("IndexSet不存在:" + type.ToString() + "." + key);
}
}
cache.defaultParamStart = (sbyte)(cache.method.Name == "set_Item" ? 0 : -1);
s_cacheSet[content.CallExpression] = cache;
}
if (cache.defaultParamStart == 0)
{
object[] ps = CLS_Content.ParamObjsArray[2];
ps[0] = key;
ps[1] = value;
cache.method.Invoke(object_this, ps);
}
else
{
object[] ps = CLS_Content.ParamObjsArray[2];
ps[0] = value;
ps[1] = key;
cache.method.Invoke(object_this, ps);
}
}
public T OpenFile <T>(string filename, CacheMethod m = CacheMethod.Default) where T : VirtualFile
{
return(Open(filename, GetFormatFromTypeclass(typeof(T)), m) as T);
}
public bool Add(string filename, CacheMethod cache = CacheMethod.Default)
{
return(AddItem(filename, cache));
}
public static IDisposable SetScope(CacheMethod method, DateTimeOffset minimumValueTimestamp)
{
return(ScopedContext <CacheDirectives> .CreateNewScope(new CacheDirectives(method, minimumValueTimestamp)));
}
/// <summary>
///
/// </summary>
/// <param name="cacheMethod"></param>
/// <param name="key">尽量采用实体类型名称</param>
public CacheAttribute(CacheMethod cacheMethod, String key)
{
this.CacheMethod = cacheMethod;
this.Key = key;
}
/// <summary>
///
/// </summary>
/// <param name="method"></param>
public CacheMethodAttribute(CacheMethod method)
{
this.Method = method;
}
public VirtualFile OpenFile(uint mixEntry, string filename = "", FileFormat f = FileFormat.None, CacheMethod m = CacheMethod.Default) {
var e = Index[mixEntry];
return FormatHelper.OpenAsFormat(BaseStream, filename, (int)(BaseOffset + dataStart + e.Offset), (int)e.Length, f, m);
}
public VirtualFile OpenFile(string filename, FileFormat format = FileFormat.None, CacheMethod m = CacheMethod.Default) {
var fs = new FileStream(Path.Combine(Directory, filename), FileMode.Open, FileAccess.Read, FileShare.Read);
return FormatHelper.OpenAsFormat(fs, filename, 0, (int)fs.Length, format);
}
public CachingAttribute(CacheMethod method)
{
Method = method;
}
public async Task <RestClientResponse <TResult> > ExecuteAsync <TResult>(Encoding encoding, CacheMethod cacheMethod = CacheMethod.OnlyOnline)
where TResult : IMutableModel, new()
{
if (encoding == null)
{
throw new NullReferenceException();
}
var restClientResponse = await ExecuteAsync(null, cacheMethod);
return(new RestClientResponse <TResult>(restClientResponse, encoding));
}
/// <summary>
/// 初始化一个新的<c>CachingAttribute</c>类型。
/// </summary>
/// <param name="method">缓存方式。</param>
public CacheAttribute(CacheMethod method)
{
Method = method;
}
public CacheableActionFilterAttribute(CacheMethod defaultMethod, double defaultMinimumAgeInMilliseconds) : base(typeof(CacheableActionFilterImpl))
{
SetDefaultArguments(defaultMethod, defaultMinimumAgeInMilliseconds);
}
public VirtualFile OpenFile(uint mixEntry, string filename = "", FileFormat f = FileFormat.None, CacheMethod m = CacheMethod.Default)
{
var e = Index[mixEntry];
return(FormatHelper.OpenAsFormat(BaseStream, filename, (int)(BaseOffset + dataStart + e.Offset), (int)e.Length, f, m));
}
public VirtualFile OpenFile(string filename, FileFormat format = FileFormat.None, CacheMethod m = CacheMethod.Default)
{
if (!_openedFiles.TryGetValue(filename, out FileStream file))
{
file = _openedFiles[filename] = new FileStream(Path.Combine(Directory, filename), FileMode.Open, FileAccess.Read, FileShare.Read);
}
return(FormatHelper.OpenAsFormat(file, filename, 0, (int)file.Length, format));
}
public static VirtualFile OpenAsFormat(Stream baseStream, string filename, int offset = 0, int length = -1, FileFormat format = FileFormat.None, CacheMethod m = CacheMethod.Default)
{
if (length == -1)
{
length = (int)baseStream.Length;
}
if (format == FileFormat.None)
{
format = GuessFormat(filename);
logger.Debug("Guessed format: {0}", format);
}
switch (format)
{
case FileFormat.Csf:
return(new CsfFile(baseStream, filename, offset, length, m != CacheMethod.NoCache)); // defaults to cache
case FileFormat.Hva:
return(new HvaFile(baseStream, filename, offset, length, m != CacheMethod.NoCache)); // defaults to not cache
case FileFormat.Ini:
return(new IniFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
case FileFormat.Missions:
return(new MissionsFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
case FileFormat.Mix:
return(new MixFile(baseStream, filename, offset, length, m == CacheMethod.Cache));
case FileFormat.Pal:
return(new PalFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
case FileFormat.Pkt:
return(new PktFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
case FileFormat.Shp:
return(new ShpFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
case FileFormat.Tmp:
return(new TmpFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
case FileFormat.Vpl:
return(new VplFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
case FileFormat.Vxl:
return(new VxlFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
case FileFormat.Ukn:
default:
return(new VirtualFile(baseStream, filename, offset, length, m != CacheMethod.NoCache));
}
}
public VirtualFile Open(string filename, FileFormat format = FileFormat.None, CacheMethod m = CacheMethod.Default)
{
if (AllArchives == null || AllArchives.Count == 0)
{
return(null);
}
var archive = AllArchives.FirstOrDefault(v => v != null && v.ContainsFile(filename));
if (archive == null)
{
return(null);
}
try {
return(archive.OpenFile(filename, format, m));
}
catch {
return(null);
}
}
public CachingAttribute(CacheMethod method, TimeSpan expiration)
: this(method)
{
Expiration = expiration;
}
public static bool Add(string filename, CacheMethod cache = CacheMethod.Default)
{
return(Instance.AddFile(filename, cache));
}
/// <summary>
/// 初始化一个新的<c>CachingAttribute</c>类型。
/// </summary>
/// <param name="method">缓存方式。</param>
/// <param name="correspondingMethodNames">与当前缓存方式相关的方法名称。注：此参数仅在缓存方式为Remove时起作用。</param>
public CacheAttribute(CacheMethod method, params string[] correspondingMethodNames)
: this(method)
{
CorrespondingMethodNames = correspondingMethodNames;
}
public virtual void IndexSet(CLS_Content content, object object_this, object key, object value)
{
CacheMethod cache;
if (!s_cacheSet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.method = type.GetMethod("set_Item");
if (cache.method == null)
{
cache.method = type.GetMethod("SetValue", new Type[] { typeof(object), typeof(int) });
if (cache.method == null)
throw new NotImplementedException("IndexSet不存在:" + type.ToString() + "." + key);
}
cache.defaultParamStart = (sbyte)(cache.method.Name == "set_Item" ? 0 : -1);
s_cacheSet[content.CallExpression] = cache;
}
if (cache.defaultParamStart == 0)
{
object[] ps = CLS_Content.ParamObjsArray[2];
ps[0] = key;
ps[1] = value;
cache.method.Invoke(object_this, ps);
}
else
{
object[] ps = CLS_Content.ParamObjsArray[2];
ps[0] = value;
ps[1] = key;
cache.method.Invoke(object_this, ps);
}
}
public async Task <RestClientResponse> ExecuteAsync(byte[] requestBody = null, CacheMethod cacheMethod = CacheMethod.OnlyOnline)
{
if (RequestMessage.Method != HttpMethod.Get && cacheMethod != CacheMethod.Default)
{
throw new Exception(string.Format("Http method {0} does not support CacheMethod {1}.", RequestMessage.Method.ToString(), cacheMethod.ToString()));
}
Log.Info("HTTP {0} {1} (CacheMethod={2})", RequestMessage.Method.ToString(), RequestMessage.RequestUri.ToString(), cacheMethod.ToString());
if (requestBody == null)
{
Log.Verbose("HTTP Body: null");
}
else
{
Log.Verbose("HTTP Body: {0}", Encoding.UTF8.GetString(requestBody, 0, requestBody.Length));
}
byte[] responseBody = null;
HttpResponseMessage httpResponseMessage = null;
CacheControlHeaderValue cacheControl = new CacheControlHeaderValue();
RequestMessage.Headers.CacheControl = cacheControl;
switch (cacheMethod)
{
case CacheMethod.OnlyCached:
{
cacheControl.OnlyIfCached = (cacheMethod == CacheMethod.OnlyCached);
break;
}
case CacheMethod.PreferCached:
{
cacheControl.Extensions.Add(new NameValueHeaderValue("Straaw", "PreferCached"));
break;
}
case CacheMethod.Default:
{
break;
}
case CacheMethod.PreferOnline:
{
cacheControl.Extensions.Add(new NameValueHeaderValue("Straaw", "PreferOnline"));
break;
}
case CacheMethod.OnlyOnline:
{
cacheControl.NoCache = (cacheMethod == CacheMethod.OnlyOnline);
break;
}
}
if (requestBody != null)
{
RequestMessage.Content = new ByteArrayContent(requestBody);
RequestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
}
using (Log.Scope(LogLevel.Verbose, "HTTP Request Timing"))
{
try
{
httpResponseMessage = await _httpClient.SendAsync(RequestMessage, HttpCompletionOption.ResponseHeadersRead);
}
catch (Exception e)
{
Log.Warning(e.Message);
throw;
}
}
using (Log.Scope(LogLevel.Verbose, "HTTP Response Timing"))
{
if (httpResponseMessage.Content != null)
{
responseBody = await httpResponseMessage.Content.ReadAsByteArrayAsync();
}
}
if (responseBody != null && responseBody.Length > 0)
{
Log.Verbose("HTTP Response body {0} bytes: {1}", responseBody.Length, Encoding.UTF8.GetString(responseBody, 0, responseBody.Length));
}
else
{
Log.Verbose("HTTP Response body 0 bytes");
}
return(new RestClientResponse(httpResponseMessage, responseBody));
}
public virtual CLS_Content.Value New(CLS_Content content, BetterList<CLS_Content.Value> _params)
{
Type[] pts = CLS_Content.ParamTypesArray[_params.size];
object[] ps = CLS_Content.ParamObjsArray[_params.size];
CLS_Content.Value tempValue;
for (int i = 0; i < _params.size; i++)
{
tempValue = _params[i];
if (tempValue.type == null)
{
pts[i] = typeof(object);
}
else if ((SType)tempValue.type != null)
{
pts[i] = typeof(SInstance);
}
else if ((Type)tempValue.type != null)
{
pts[i] = tempValue.type;
}
else
{
pts[i] = typeof(object);
}
ps[i] = tempValue.value;
}
CacheMethod cache;
if (!s_cacheMethod.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.constructor = this.type.GetConstructor(pts);
s_cacheMethod[content.CallExpression] = cache;
}
CLS_Content.Value retVal = new CLS_Content.Value();
if (cache.constructor != null)
{
retVal.value = cache.constructor.Invoke(ps);
retVal.type = this.type;
}
else
{
retVal.value = Activator.CreateInstance(this.type);
retVal.type = this.type;
}
return retVal;
}
/// <summary>
/// 初始化一个新的<c>CachingAttribute</c>类型。
/// </summary>
/// <param name="method">缓存方式。</param>
/// <param name="correspondingMethodNames">与当前缓存方式相关的方法名称。注：此参数仅在缓存方式为Remove时起作用。</param>
public CachingAttribute(CacheMethod method, params string[] correspondingMethodNames)
: this(method)
{
this.CorrespondingMethodNames = correspondingMethodNames;
}
public virtual void StaticValueSet(CLS_Content content, string valuename, object value)
{
CacheMethod cache;
if (!s_cacheSet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.field = type.GetField(valuename);
if (cache.field == null)
{
cache.method = type.GetMethod("set_" + valuename);
if (cache.method == null)
{
Type baseType = type.BaseType;
while (baseType != null)
{
cache.field = baseType.GetField(valuename);
if (cache.field == null)
{
cache.method = baseType.GetMethod("set_" + valuename);
if (cache.method != null)
break;
}
else
break;
baseType = baseType.BaseType;
}
if (cache.field == null && cache.method == null)
throw new NotImplementedException("静态属性不存在:" + type.ToString() + "." + valuename);
}
}
s_cacheSet[content.CallExpression] = cache;
}
if (cache.field != null)
{
if (value != null)
{
Type vType = value.GetType();
if (vType != cache.field.FieldType)
value = content.environment.GetType(vType).ConvertTo(content, value, cache.field.FieldType);
}
cache.field.SetValue(null, value); ;
}
else
{
if (value != null)
{
Type vType = value.GetType();
Type pType = cache.method.GetParameters()[0].ParameterType;
if (vType != pType)
value = content.environment.GetType(vType).ConvertTo(content, value, pType);
}
object[] ps = CLS_Content.ParamObjsArray[1];
ps[0] = value;
cache.method.Invoke(null, ps);
}
}
public virtual CLS_Content.Value IndexGet(CLS_Content content, object object_this, object key)
{
CacheMethod cache;
if (!s_cacheGet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.method = type.GetMethod("get_Item");
if (cache.method == null)
{
cache.method = type.GetMethod("GetValue", new Type[] { typeof(int) });
if (cache.method == null)
throw new NotImplementedException("IndexGet不存在:" + type.ToString() + "." + key);
}
cache.defaultParamStart = (sbyte)(cache.method.Name == "get_Item" ? 0 : -1);
s_cacheGet[content.CallExpression] = cache;
}
CLS_Content.Value retVal = new CLS_Content.Value();
if (cache.defaultParamStart == 0)
{
object[] ps = CLS_Content.ParamObjsArray[1];
ps[0] = key;
retVal.value = cache.method.Invoke(object_this, ps);
retVal.type = cache.method.ReturnType;
}
else
{
object[] ps = CLS_Content.ParamObjsArray[1];
ps[0] = key;
retVal.value = cache.method.Invoke(object_this, ps);
retVal.type = type.GetElementType();
}
return retVal;
}
public CacheableActionFilterImpl(CacheMethod defaultMethod, double defaultMinimumAgeInMilliseconds)
{
_defaultMethod = defaultMethod;
_defaultMinimumAgeInMilliseconds = defaultMinimumAgeInMilliseconds;
}
public virtual CLS_Content.Value MemberValueGet(CLS_Content content, object object_this, string valuename, bool isBaseCall = false)
{
#if UNITY_EDITOR
if (object_this == null)
throw new NotImplementedException("MemberValueGet实例 = null:" + type.ToString() + "." + valuename);
#endif
CacheMethod cache;
if (!s_cacheGet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.field = type.GetField(valuename);
if (cache.field == null)
{
cache.method = type.GetMethod("get_" + valuename);
if (cache.method == null)
{
Type baseType = type.BaseType;
while (baseType != null)
{
cache.field = baseType.GetField(valuename);
if (cache.field == null)
{
cache.method = baseType.GetMethod("get_" + valuename);
if (cache.method != null)
break;
}
else
break;
baseType = baseType.BaseType;
}
if (cache.field == null && cache.method == null)
throw new NotImplementedException("实例属性不存在:" + type.ToString() + "." + valuename);
}
}
s_cacheGet[content.CallExpression] = cache;
}
CLS_Content.Value retVal = new CLS_Content.Value();
if (cache.field != null)
{
retVal.value = cache.field.GetValue(object_this);
retVal.type = cache.field.FieldType;
}
else
{
retVal.value = cache.method.Invoke(object_this, null);
retVal.type = cache.method.ReturnType;
}
return retVal;
}
public static T Open <T>(string filename, FileFormat f, CacheMethod m) where T : VirtualFile
{
return(Open(filename, f, m) as T);
}
public virtual CLS_Content.Value StaticValueGet(CLS_Content content, string valuename)
{
CacheMethod cache;
if (!s_cacheGet.TryGetValue(content.CallExpression, out cache))
{
cache = new CacheMethod();
cache.field = type.GetField(valuename);
if (cache.field == null)
{
cache.method = type.GetMethod("get_" + valuename);
if (cache.method == null)
{
Type baseType = type.BaseType;
while (baseType != null)
{
cache.field = baseType.GetField(valuename);
if (cache.field == null)
{
cache.method = baseType.GetMethod("get_" + valuename);
if (cache.method != null)
break;
}
else
break;
baseType = baseType.BaseType;
}
if (cache.field == null && cache.method == null)
throw new NotImplementedException("静态属性不存在:" + type.ToString() + "." + valuename);
}
}
s_cacheGet[content.CallExpression] = cache;
}
CLS_Content.Value retVal = new CLS_Content.Value();
if (cache.field != null)
{
retVal.value = cache.field.GetValue(null);
retVal.type = cache.field.FieldType;
}
else
{
retVal.value = cache.method.Invoke(null, null);
retVal.type = cache.method.ReturnType;
}
return retVal;
}
public static VirtualFile Open(string filename, FileFormat f, CacheMethod m)
{
return(Instance.OpenFile(filename, f, m));
}
// 方法查找
protected static CacheMethod FindMethod(CLS_Content content, Type type, string function, Type[] pts, object[] ps)
{
MethodInfo md;
try
{
md = type.GetMethod(function, pts);
}
catch (System.Exception)
{
md = null;
}
if (md != null)
{
CacheMethod cache = new CacheMethod();
cache.method = md;
return cache;
}
int defaultParamStart = -1;
int paramArrayStart = -1;
if (function[function.Length - 1] == '>')
{
string[] sf = function.Split(new char[] { '<', ',', '>' }, StringSplitOptions.RemoveEmptyEntries);
string tfunc = sf[0];
Type[] gtypes = new Type[sf.Length - 1];
for (int i = 1; i < sf.Length; i++)
{
gtypes[i - 1] = content.environment.GetTypeByKeyword(sf[i]).type;
}
md = FindGenericMethod(type, tfunc, pts, ps, gtypes, out defaultParamStart, out paramArrayStart);
if (md != null)
{
CacheMethod cache = new CacheMethod();
cache.method = md;
cache.defaultParamStart = (sbyte)defaultParamStart;
cache.paramArrayStart = (sbyte)paramArrayStart;
return cache;
}
return null;
}
List<MethodInfo> listMethods = getMethodsSorted(type, function, false);
for (int i = 0, count = listMethods.Count; i < count; i++)
{
MethodInfo tmpMethod = listMethods[i];
if (isMatchParams(tmpMethod, pts, ps, out defaultParamStart, out paramArrayStart))
{
CacheMethod cache = new CacheMethod();
cache.method = tmpMethod;
cache.defaultParamStart = (sbyte)defaultParamStart;
cache.paramArrayStart = (sbyte)paramArrayStart;
return cache;
}
}
Type baseType = type.BaseType;
while (baseType != null)
{
CacheMethod cache = FindMethod(content, baseType, function, pts, ps);
if (cache != null)
return cache;
baseType = baseType.BaseType;
}
return null;
}
public VirtualFile OpenFile(string filename, FileFormat f = FileFormat.None, CacheMethod m = CacheMethod.Default) {
MixEntry e;
if (!Index.TryGetValue(MixEntry.HashFilename(filename), out e))
return null;
else
return FormatHelper.OpenAsFormat(BaseStream, filename, (int)(BaseOffset + dataStart + e.Offset), (int)e.Length, f, m);
}
