新增友好的类型名称打印

Convention/[Runtime]/Config.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
+using System.Text;
 using System.Threading;
 using System.Xml;
 
@@ -463,5 +464,362 @@ namespace Convention
         {
             return new EnumerableClass(ir);
         }
+
+        /// <summary>
+        /// Marshal 相关的实用函数。
+        /// </summary>
+        public static class Marshal
+        {
+
+            [Serializable]
+            public class MarshalException : Exception
+            {
+                public MarshalException() { }
+                public MarshalException(string message) : base(message) { }
+                public MarshalException(string message, Exception inner) : base(message, inner) { }
+            }
+
+            private const int BlockSize = 1024 * 4;
+            private static IntPtr s_CachedHGlobalPtr = IntPtr.Zero;
+            private static int s_CachedHGlobalSize = 0;
+
+            /// <summary>
+            /// 获取缓存的从进程的非托管内存中分配的内存的大小。
+            /// </summary>
+            public static int CachedHGlobalSize
+            {
+                get
+                {
+                    return s_CachedHGlobalSize;
+                }
+            }
+
+            /// <summary>
+            /// 确保从进程的非托管内存中分配足够大小的内存并缓存。
+            /// </summary>
+            /// <param name="ensureSize">要确保从进程的非托管内存中分配内存的大小。</param>
+            public static void EnsureCachedHGlobalSize(int ensureSize)
+            {
+                if (ensureSize < 0)
+                {
+                    throw new MarshalException("Ensure size is invalid.");
+                }
+
+                if (s_CachedHGlobalPtr == IntPtr.Zero || s_CachedHGlobalSize < ensureSize)
+                {
+                    FreeCachedHGlobal();
+                    int size = (ensureSize - 1 + BlockSize) / BlockSize * BlockSize;
+                    s_CachedHGlobalPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(size);
+                    s_CachedHGlobalSize = size;
+                }
+            }
+
+            /// <summary>
+            /// 释放缓存的从进程的非托管内存中分配的内存。
+            /// </summary>
+            public static void FreeCachedHGlobal()
+            {
+                if (s_CachedHGlobalPtr != IntPtr.Zero)
+                {
+                    System.Runtime.InteropServices.Marshal.FreeHGlobal(s_CachedHGlobalPtr);
+                    s_CachedHGlobalPtr = IntPtr.Zero;
+                    s_CachedHGlobalSize = 0;
+                }
+            }
+
+            /// <summary>
+            /// 将数据从对象转换为二进制流。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="structure">要转换的对象。</param>
+            /// <returns>存储转换结果的二进制流。</returns>
+            public static byte[] StructureToBytes<T>(T structure)
+            {
+                return StructureToBytes(structure, System.Runtime.InteropServices.Marshal.SizeOf(typeof(T)));
+            }
+
+            /// <summary>
+            /// 将数据从对象转换为二进制流。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="structure">要转换的对象。</param>
+            /// <param name="structureSize">要转换的对象的大小。</param>
+            /// <returns>存储转换结果的二进制流。</returns>
+            internal static byte[] StructureToBytes<T>(T structure, int structureSize)
+            {
+                if (structureSize < 0)
+                {
+                    throw new MarshalException("Structure size is invalid.");
+                }
+
+                EnsureCachedHGlobalSize(structureSize);
+                System.Runtime.InteropServices.Marshal.StructureToPtr(structure, s_CachedHGlobalPtr, true);
+                byte[] result = new byte[structureSize];
+                System.Runtime.InteropServices.Marshal.Copy(s_CachedHGlobalPtr, result, 0, structureSize);
+                return result;
+            }
+
+            /// <summary>
+            /// 将数据从对象转换为二进制流。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="structure">要转换的对象。</param>
+            /// <param name="result">存储转换结果的二进制流。</param>
+            public static void StructureToBytes<T>(T structure, byte[] result)
+            {
+                StructureToBytes(structure, System.Runtime.InteropServices.Marshal.SizeOf(typeof(T)), result, 0);
+            }
+
+            /// <summary>
+            /// 将数据从对象转换为二进制流。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="structure">要转换的对象。</param>
+            /// <param name="structureSize">要转换的对象的大小。</param>
+            /// <param name="result">存储转换结果的二进制流。</param>
+            internal static void StructureToBytes<T>(T structure, int structureSize, byte[] result)
+            {
+                StructureToBytes(structure, structureSize, result, 0);
+            }
+
+            /// <summary>
+            /// 将数据从对象转换为二进制流。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="structure">要转换的对象。</param>
+            /// <param name="result">存储转换结果的二进制流。</param>
+            /// <param name="startIndex">写入存储转换结果的二进制流的起始位置。</param>
+            public static void StructureToBytes<T>(T structure, byte[] result, int startIndex)
+            {
+                StructureToBytes(structure, System.Runtime.InteropServices.Marshal.SizeOf(typeof(T)), result, startIndex);
+            }
+
+            /// <summary>
+            /// 将数据从对象转换为二进制流。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="structure">要转换的对象。</param>
+            /// <param name="structureSize">要转换的对象的大小。</param>
+            /// <param name="result">存储转换结果的二进制流。</param>
+            /// <param name="startIndex">写入存储转换结果的二进制流的起始位置。</param>
+            internal static void StructureToBytes<T>(T structure, int structureSize, byte[] result, int startIndex)
+            {
+                if (structureSize < 0)
+                {
+                    throw new MarshalException("Structure size is invalid.");
+                }
+
+                if (result == null)
+                {
+                    throw new MarshalException("Result is invalid.");
+                }
+
+                if (startIndex < 0)
+                {
+                    throw new MarshalException("Start index is invalid.");
+                }
+
+                if (startIndex + structureSize > result.Length)
+                {
+                    throw new MarshalException("Result length is not enough.");
+                }
+
+                EnsureCachedHGlobalSize(structureSize);
+                System.Runtime.InteropServices.Marshal.StructureToPtr(structure, s_CachedHGlobalPtr, true);
+                System.Runtime.InteropServices.Marshal.Copy(s_CachedHGlobalPtr, result, startIndex, structureSize);
+            }
+
+            /// <summary>
+            /// 将数据从二进制流转换为对象。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="buffer">要转换的二进制流。</param>
+            /// <returns>存储转换结果的对象。</returns>
+            public static T BytesToStructure<T>(byte[] buffer)
+            {
+                return BytesToStructure<T>(System.Runtime.InteropServices.Marshal.SizeOf(typeof(T)), buffer, 0);
+            }
+
+            /// <summary>
+            /// 将数据从二进制流转换为对象。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="buffer">要转换的二进制流。</param>
+            /// <param name="startIndex">读取要转换的二进制流的起始位置。</param>
+            /// <returns>存储转换结果的对象。</returns>
+            public static T BytesToStructure<T>(byte[] buffer, int startIndex)
+            {
+                return BytesToStructure<T>(System.Runtime.InteropServices.Marshal.SizeOf(typeof(T)), buffer, startIndex);
+            }
+
+            /// <summary>
+            /// 将数据从二进制流转换为对象。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="structureSize">要转换的对象的大小。</param>
+            /// <param name="buffer">要转换的二进制流。</param>
+            /// <returns>存储转换结果的对象。</returns>
+            internal static T BytesToStructure<T>(int structureSize, byte[] buffer)
+            {
+                return BytesToStructure<T>(structureSize, buffer, 0);
+            }
+
+            /// <summary>
+            /// 将数据从二进制流转换为对象。
+            /// </summary>
+            /// <typeparam name="T">要转换的对象的类型。</typeparam>
+            /// <param name="structureSize">要转换的对象的大小。</param>
+            /// <param name="buffer">要转换的二进制流。</param>
+            /// <param name="startIndex">读取要转换的二进制流的起始位置。</param>
+            /// <returns>存储转换结果的对象。</returns>
+            internal static T BytesToStructure<T>(int structureSize, byte[] buffer, int startIndex)
+            {
+                if (structureSize < 0)
+                {
+                    throw new MarshalException("Structure size is invalid.");
+                }
+
+                if (buffer == null)
+                {
+                    throw new MarshalException("Buffer is invalid.");
+                }
+
+                if (startIndex < 0)
+                {
+                    throw new MarshalException("Start index is invalid.");
+                }
+
+                if (startIndex + structureSize > buffer.Length)
+                {
+                    throw new MarshalException("Buffer length is not enough.");
+                }
+
+                EnsureCachedHGlobalSize(structureSize);
+                System.Runtime.InteropServices.Marshal.Copy(buffer, startIndex, s_CachedHGlobalPtr, structureSize);
+                return (T)System.Runtime.InteropServices.Marshal.PtrToStructure(s_CachedHGlobalPtr, typeof(T));
+            }
+        }
+
+        /// <summary>
+        /// 获取类型的友好显示名称，支持泛型、数组等复杂类型
+        /// </summary>
+        public static string GetFriendlyName(this Type type)
+        {
+            if (type == null) return null;
+
+            // 处理泛型类型
+            if (type.IsGenericType)
+            {
+                // 特殊处理可空类型（Nullable<T>）
+                if (type.IsNullable())
+                {
+                    return $"{GetFriendlyName(type.GetGenericArguments()[0])}?";
+                }
+
+                var sb = new StringBuilder();
+                // 获取类型基础名称（移除 `1, `2 等后缀）
+                string baseName = type.Name.Contains('`') ? type.Name[..type.Name.IndexOf('`')] : type.Name;
+                sb.Append(baseName);
+                sb.Append('<');
+
+                // 递归处理泛型参数
+                Type[] args = type.GetGenericArguments();
+                for (int i = 0; i < args.Length; i++)
+                {
+                    if (i > 0) sb.Append(", ");
+                    sb.Append(GetFriendlyName(args[i]));
+                }
+
+                sb.Append('>');
+                return sb.ToString();
+            }
+
+            // 处理数组类型
+            if (type.IsArray)
+            {
+                string elementName = GetFriendlyName(type.GetElementType());
+                int rank = type.GetArrayRank();
+                return rank == 1 ? $"{elementName}[]" : $"{elementName}[{new string(',', rank - 1)}]";
+            }
+
+            // 处理指针类型
+            if (type.IsPointer)
+            {
+                return $"{GetFriendlyName(type.GetElementType())}*";
+            }
+
+            // 处理引用类型（ref/out 参数）
+            if (type.IsByRef)
+            {
+                return $"{GetFriendlyName(type.GetElementType())}&";
+            }
+
+            // 普通类型直接返回名称
+            return type.Name;
+        }
+
+        /// <summary>
+        /// 判断是否为可空类型
+        /// </summary>
+        public static bool IsNullable(this Type type)
+        {
+            return type.IsGenericType &&
+                   type.GetGenericTypeDefinition() == typeof(Nullable<>);
+        }
+    }
+}
+
+namespace Convention
+{
+    public static partial class Utility
+    {
+        /// <summary>
+        /// 生成期望类型的栈实例
+        /// </summary>
+        /// <param name="type">期望类型</param>
+        /// <returns></returns>
+        public static object CreateStack([In] Type type)
+        {
+            var stackType = typeof(Stack<>).MakeGenericType(type);
+            var stackInstance = Activator.CreateInstance(stackType);
+            return stackInstance;
+        }
+
+        /// <summary>
+        /// 生成期望类型的队列实例
+        /// </summary>
+        /// <param name="type">期望类型</param>
+        /// <returns></returns>
+        public static object CreateQueue([In] Type type)
+        {
+            var queueType = typeof(Queue<>).MakeGenericType(type);
+            var queueInstance = Activator.CreateInstance(queueType);
+            return queueInstance;
+        }
+
+        /// <summary>
+        /// 生成期望类型的列表实例
+        /// </summary>
+        /// <param name="type">期望类型</param>
+        /// <returns></returns>
+        public static object CreateList([In] Type type)
+        {
+            var listType = typeof(List<>).MakeGenericType(type);
+            var listInstance = Activator.CreateInstance(listType);
+            return listInstance;
+        }
+
+        /// <summary>
+        /// 生成期望键值对类型的字典实例
+        /// </summary>
+        /// <param name="keyType">期望键类型</param>
+        /// <param name="valueType">期望值类型</param>
+        /// <returns></returns>
+        public static object CreateDictionary([In] Type keyType, [In] Type valueType)
+        {
+            var dictType = typeof(Dictionary<,>).MakeGenericType(keyType, valueType);
+            var dictInstance = Activator.CreateInstance(dictType);
+            return dictInstance;
+        }
     }
 }

[Test]/Program.cs

@@ -6,34 +6,30 @@ using Convention.RScript.Variable.Attr;
 using Convention.RScript.Variable.CStyle;
 using System;
 using System.IO;
+using System.Collections;
+using System.Linq;
+using System.Threading;
 
 public class Program
 {
-    [Description(@"
+    static int i = 0;
-测试注释1
+
-测试注释二
+    static IEnumerator Test1()
-")]
-    [Default(@"
-this.Log(1);
-")]
-    public class Test
     {
-        [Method]
+        Console.WriteLine(i);
-        public void Log(object o)
+        for(; ; )
-        {
+        yield return null;
-            Console.WriteLine(o);
+    }
-        }
+
+    static IEnumerator Test()
+    {
+        yield return Test1();
     }
 
     static void Main(string[] args)
     {
-        var engine = new RScriptEngine();
+        var ir = Test();
-        var testClass = new CScriptRScriptVariableGenerater(typeof(Test), () => new Test(), null, nameof(Test));
+        while (ir.MoveNext()) 
-        testClass.Register();
+            Thread.Sleep(1000);
-        engine.Run(@"
-var t = New(Test);
-t.Log(114514);
-");
-        Console.WriteLine(testClass.scriptIndicator);
     }
 }