public void Release() { #if GF_DEBUG if (m_Root._After != null) { MDebug.Assert(m_Root._After == null , "ArrayPool" , "m_Root._After == null"); StringBuilder stringBuilder = StringUtility.AllocStringBuilder(); stringBuilder.Append("ArrayPool<").Append(typeof(T).FullName).Append(">has memory leak!\n"); Node iterNode = m_Root; while (iterNode != null) { stringBuilder.Append("Offset:").Append(iterNode.GetOffset()) .Append("\tSize:").Append(iterNode.GetSize()) .Append("\tIsUsed:").Append(iterNode.IsUsed()) .Append('\n'); iterNode = iterNode._After; } MDebug.LogError("ArrayPool" , StringUtility.ReleaseStringBuilder(stringBuilder)); } #endif m_Buffer = null; ms_NodePool.Release(m_Root); m_Root = null; }
public override void ProcessAll(Object[] assets) { StringBuilder stringBuilder = StringUtility.AllocStringBuilder() .AppendLine("处理以下资源:"); for (int iAsset = 0; iAsset < assets.Length; iAsset++) { string iterAssetPath = AssetDatabase.GetAssetPath(assets[iAsset]); if (string.IsNullOrEmpty(iterAssetPath)) { continue; } stringBuilder.AppendLine(iterAssetPath); } MDebug.Log("Asset", StringUtility.ReleaseStringBuilder(stringBuilder)); }
public override string ToString() { System.Text.StringBuilder stringBuilder = StringUtility.AllocStringBuilder(); stringBuilder.Append($"ObjectPool<{typeof(T).FullName}> alloc {m_AllCount} objects. ") .Append($"{m_UsingCount} obejcts being used"); #if GF_DEBUG long currentTime = MDebug.GetMillisecondsSinceStartup(); for (int iObject = 0; iObject < m_Using.Count; iObject++) { UsingObject usingObject = m_Using[iObject]; float beUsedTime = (currentTime - usingObject.WhenBeUse) * 0.001f; stringBuilder.Append($"\nObject be used {beUsedTime:F2} seconds. ({usingObject.ToString()})"); } #endif return(StringUtility.ReleaseStringBuilder(stringBuilder)); }
public EventCenter(List <Type> eventTypes , string name , int priority , string groupName) : base(name, priority, groupName) { List <Array> eventEnumValues = new List <Array>(); int maxEventID = int.MinValue; for (int iEventType = 0; iEventType < eventTypes.Count; iEventType++) { Array enumValues = eventTypes[iEventType].GetEnumValues(); maxEventID = Math.Max(maxEventID, (int)enumValues.GetValue(enumValues.Length - 1)); eventEnumValues.Add(enumValues); } m_Listeners = new EventFunction[maxEventID + 1]; m_EventIdToName = new string[maxEventID + 1]; for (int iEventType = 0; iEventType < eventEnumValues.Count; iEventType++) { Array enumValues = eventEnumValues[iEventType]; for (int iEnum = 0; iEnum < enumValues.Length; iEnum++) { object iterEnum = enumValues.GetValue(iEnum); m_EventIdToName[(int)iterEnum] = iterEnum.ToString(); } } System.Text.StringBuilder stringBuilder = StringUtility.AllocStringBuilder() .Append("Events id to name:\n"); for (int iEvent = 0; iEvent < m_EventIdToName.Length; iEvent++) { stringBuilder.Append(iEvent).Append(", ").Append(m_EventIdToName[iEvent]).Append('\n'); } MDebug.Log("EventCenter", StringUtility.ReleaseStringBuilder(stringBuilder)); m_EventItemPool = new ObjectPool <EventItem>(32); m_MajorEventCache = new BetterQueue <EventItem>(); m_MajorEvents = new BetterQueue <EventItem> [(int)UpdateMethod.Count]; for (int iMajor = 0; iMajor < m_MajorEvents.Length; iMajor++) { m_MajorEvents[iMajor] = new BetterQueue <EventItem>(); } }
/// <summary> /// 解析字符串中的宏定义 /// </summary> public string Parse(string script) { string[] lines = script.Split(SEPARATOR, StringSplitOptions.None); System.Text.StringBuilder stringBuilder = StringUtility.AllocStringBuilder(); bool enableCode = true; m_EnableCodeStackCache.Push(true); for (int iLine = 0; iLine < lines.Length; iLine++) { string iterLine = lines[iLine]; string iterLineTrim = iterLine.Trim(); if (iterLineTrim.StartsWith(DEINFE_BEGIN)) { m_DefineLine = iterLineTrim.Substring(DEINFE_BEGIN.Length); enableCode &= ParseDefineLine(); m_EnableCodeStackCache.Push(enableCode); } else if (iterLineTrim.StartsWith(DEINFE_END)) { MDebug.Assert(m_EnableCodeStackCache.Count > 1, "XLua", "m_EnableCodeStack.Count > 0"); m_EnableCodeStackCache.Pop(); enableCode = m_EnableCodeStackCache.Peek(); } else if (enableCode) { stringBuilder.Append(iterLine); } stringBuilder.Append('\n'); } m_EnableCodeStackCache.Pop(); MDebug.Assert(m_EnableCodeStackCache.Count == 0, "XLua", "m_EnableCodeStack.Count == 0"); #if GF_DEBUG MDebug.Log("XLua", stringBuilder.ToString()); #endif return(StringUtility.ReleaseStringBuilder(stringBuilder)); }
public static Dictionary <string, MethodInfo> GetOrCollectAllStaticMethods() { if (ms_AllStaticMethods == null) { ms_AllStaticMethods = new Dictionary <string, MethodInfo>(); List <ReflectionUtility.MethodAndAttributeData> staticMethodDatas = new List <ReflectionUtility.MethodAndAttributeData>(); Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); for (int iAssembly = 0; iAssembly < assemblies.Length; iAssembly++) { ReflectionUtility.CollectionMethodWithAttribute(staticMethodDatas , assemblies[iAssembly] , BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public , typeof(StaticMethodAttribute) , false); } StringBuilder methodSignBuilder = StringUtility.AllocStringBuilder(); for (int iMethod = 0; iMethod < staticMethodDatas.Count; iMethod++) { ReflectionUtility.MethodAndAttributeData iterStaticMethodData = staticMethodDatas[iMethod]; StaticMethodAttribute iterAttribute = iterStaticMethodData.Attribute as StaticMethodAttribute; methodSignBuilder.Append(string.IsNullOrEmpty(iterAttribute.Alias) ? iterStaticMethodData.Method.Name : iterAttribute.Alias); ParameterInfo[] parameterInfos = iterStaticMethodData.Method.GetParameters(); for (int iParameter = 0; iParameter < parameterInfos.Length; iParameter++) { ParameterInfo iterParameter = parameterInfos[iParameter]; Type iterParameterType = iterParameter.ParameterType; if (iterParameterType.IsValueType) { if (iterParameterType == typeof(byte)) { AppendValueType(methodSignBuilder, ValueType.Byte); } else if (iterParameterType == typeof(int)) { AppendValueType(methodSignBuilder, ValueType.Int); } else if (iterParameterType == typeof(short)) { AppendValueType(methodSignBuilder, ValueType.Short); } else if (iterParameterType == typeof(long)) { AppendValueType(methodSignBuilder, ValueType.Long); } else if (iterParameterType == typeof(float)) { AppendValueType(methodSignBuilder, ValueType.Float); } else if (iterParameterType == typeof(double)) { AppendValueType(methodSignBuilder, ValueType.Double); } // struct else if (!iterParameterType.IsPrimitive) { MDebug.Assert(false , "Rpc" , $"Not support ParameterType {iterParameterType}"); } else { MDebug.LogWarning("Rpc" , $"Not support ParameterType: {iterParameterType} (IsValueType). But maybe we can support it."); } } else if (iterParameterType.IsArray) { AppendValueType(methodSignBuilder, ValueType.FixedValueTypeArray); } else { MDebug.Assert(false , "Rpc" , $"Not support ParameterType {iterParameterType}"); } } string methodSign = methodSignBuilder.ToString(); methodSignBuilder.Clear(); #if GF_DEBUG MDebug.Assert(!ms_AllStaticMethods.ContainsKey(methodSign) , "Rpc" , "!ms_AllStaticMethods.ContainsKey(methodSign)"); #endif ms_AllStaticMethods[methodSign] = iterStaticMethodData.Method; } methodSignBuilder.Clear(); foreach (KeyValuePair <string, MethodInfo> kv in ms_AllStaticMethods) { methodSignBuilder.AppendLine(kv.Key); } MDebug.Log("Rpc" , "All static methods:\n" + methodSignBuilder); } return(ms_AllStaticMethods); }