C# uses bind handles to reduce process memory consumption

In many applications, a set of types (Type) or type members (derived from MemberInfo) are bound and these objects are stored in some form of collection. Later, this collection is searched for a specific object and then called. This is a nice mechanism, but there is a small problem: objects derived from Type and MemberInfo require a lot of memory. If an application contains too many such classes but uses them only occasionally, the application's memory will grow rapidly, affecting the application's performance.

Internally, the CLR represents this information in a more streamlined form. The CLR creates these objects for applications simply to make the developer's life easier. The CLR does not need these large objects at runtime. If a large number of Type and MemberInfo derived objects need to be cached, developers can use runtime handles instead of objects to reduce the working set (memory occupied). FCL defines three runtime handle types (all in the System namespace), RuntimeTypeHandle, RuntimeFieldHandle, and RumtimeMethodHandle. All three types are value types, and they only contain one field, which is an IntPtr; thus, instances of these types are quite memory-saving. The ItPtr field is a handle that references a type, field, or method in the AppDomain's Loader heap. Conversion method:

• Type→RuntimeTypeHandle, by querying the read-only field attribute TypeHandle of Type.

• RuntimeTypeHandle→Type, by calling the static method GetTypeFromHanlde of Type.

• FieldInfo→RuntimeFieldHandle, by querying the read-only field FieldHandle of the FieldInfo instance.

• RuntimeFieldHandle→FieldInfo, by calling the static method GetFieldFromHandle of FieldInfo.

• MethodInfo→RuntimeMethodHandle, by querying the instance read-only field MethodHandle of MethodInof.

• RuntimeMethodHandle→MethodInfo, by calling the static method GetMethodFromHandle of MethodInfo.

The following example obtains many MethodInfo objects, converts them into RuntimeMethodHandle instances, and demonstrates the memory difference before and after conversion.

 private void UseRuntimeHandleToReduceMemory()
        {
            Show("Before doing anything");//从MSCorlib.dll中地所有方法构建methodInfos 对象缓存
            List<MethodBase> methodInfos = new List<MethodBase>();            
            foreach (Type t in typeof(object).Assembly.GetExportedTypes())
            {                if (t.IsGenericType) continue;
                MethodBase[] mbs = t.GetMethods(c_bf);
                methodInfos.AddRange(mbs);
            }            //显示当绑定所有方法之后，方法的个数和堆的大小
            Console.WriteLine("# of Methods={0:###,###}", methodInfos.Count);
            Show("After building cache of MethodInfo objects");//为所有MethodInfo对象构建RuntimeMethodHandle缓存
            List<RuntimeMethodHandle> methodHandles = new List<RuntimeMethodHandle>();
            methodHandles = methodInfos.ConvertAll<RuntimeMethodHandle>(m => m.MethodHandle);
            Show("Holding MethodInfo and RuntimeMethodHandle");
            GC.KeepAlive(methodHandles);//阻止缓存被过早垃圾回收

            methodInfos = null;//现在允许缓存垃圾回收
            Show("After freeing MethodInfo objects");

            methodInfos = methodHandles.ConvertAll<MethodBase>(r => MethodBase.GetMethodFromHandle(r));
            Show("Size of heap after re-creating methodinfo objects");
            GC.KeepAlive(methodHandles);//阻止缓存被过早垃圾回收
            GC.KeepAlive(methodInfos);//阻止缓存被过早垃圾回收

            methodInfos = null;//现在允许缓存垃圾回收
            methodHandles = null;//现在允许缓存垃圾回收
            Show("after freeing MethodInfo and MethodHandle objects");
        }

The results are as follows:

Heap Size =     114,788 - Before doing anything
# of Methods=10,003Heap Size =   2,205,652 - After building cache of MethodInfo objects
Heap Size =   2,245,744 - Holding MethodInfo and RuntimeMethodHandle
Heap Size =   2,171,976 - After freeing MethodInfo objects
Heap Size =   2,327,516 - Size of heap after re-creating methodinfo objects
Heap Size =     247,028 - after freeing MethodInfo and MethodHandle objects

This article is compiled from "NET CLR via C#"

Author: jiankunking Source: http://www.php.cn/

In many applications, a set of types (Type) or type members (derived from MemberInfo) are bound and these objects are stored in some form of collection. Later, this collection is searched for a specific object and then called on that object. This is a nice mechanism, but there is a small problem: Type and MemberInfo-derived objects require a lot of memory. If an application contains too many such classes but uses them only occasionally, the application's memory will grow rapidly, affecting the application's performance.

Internally, the CLR represents this information in a more streamlined form. The CLR creates these objects for applications simply to make the developer's life easier. The CLR does not need these large objects at runtime. If a large number of Type and MemberInfo derived objects need to be cached, developers can use runtime handles instead of objects to reduce the working set (memory occupied). FCL defines three runtime handle types (all in the System namespace), RuntimeTypeHandle, RuntimeFieldHandle, and RumtimeMethodHandle. All three types are value types, and they only contain one field, which is an IntPtr; thus, instances of these types are quite memory-saving. The ItPtr field is a handle that references a type, field, or method in the AppDomain's Loader heap. Conversion method:

• Type→RuntimeTypeHandle, by querying the read-only field attribute TypeHandle of Type.

• RuntimeTypeHandle→Type, by calling the static method GetTypeFromHanlde of Type.

• FieldInfo→RuntimeFieldHandle, by querying the read-only field FieldHandle of the FieldInfo instance.

• RuntimeFieldHandle→FieldInfo, by calling the static method GetFieldFromHandle of FieldInfo.

• MethodInfo→RuntimeMethodHandle, by querying the instance read-only field MethodHandle of MethodInof.

• RuntimeMethodHandle→MethodInfo, by calling the static method GetMethodFromHandle of MethodInfo.

The following example obtains many MethodInfo objects, converts them into RuntimeMethodHandle instances, and demonstrates the memory difference before and after conversion.

 private void UseRuntimeHandleToReduceMemory()
        {
            Show("Before doing anything");//从MSCorlib.dll中地所有方法构建methodInfos 对象缓存
            List<MethodBase> methodInfos = new List<MethodBase>();            
            foreach (Type t in typeof(object).Assembly.GetExportedTypes())
            {                if (t.IsGenericType) continue;
                MethodBase[] mbs = t.GetMethods(c_bf);
                methodInfos.AddRange(mbs);
            }            //显示当绑定所有方法之后，方法的个数和堆的大小
            Console.WriteLine("# of Methods={0:###,###}", methodInfos.Count);
            Show("After building cache of MethodInfo objects");//为所有MethodInfo对象构建RuntimeMethodHandle缓存
            List<RuntimeMethodHandle> methodHandles = new List<RuntimeMethodHandle>();
            methodHandles = methodInfos.ConvertAll<RuntimeMethodHandle>(m => m.MethodHandle);
            Show("Holding MethodInfo and RuntimeMethodHandle");
            GC.KeepAlive(methodHandles);//阻止缓存被过早垃圾回收

            methodInfos = null;//现在允许缓存垃圾回收
            Show("After freeing MethodInfo objects");

            methodInfos = methodHandles.ConvertAll<MethodBase>(r => MethodBase.GetMethodFromHandle(r));
            Show("Size of heap after re-creating methodinfo objects");
            GC.KeepAlive(methodHandles);//阻止缓存被过早垃圾回收
            GC.KeepAlive(methodInfos);//阻止缓存被过早垃圾回收

            methodInfos = null;//现在允许缓存垃圾回收
            methodHandles = null;//现在允许缓存垃圾回收
            Show("after freeing MethodInfo and MethodHandle objects");
        }

The results are as follows:

Heap Size =     114,788 - Before doing anything
# of Methods=10,003Heap Size =   2,205,652 - After building cache of MethodInfo objects
Heap Size =   2,245,744 - Holding MethodInfo and RuntimeMethodHandle
Heap Size =   2,171,976 - After freeing MethodInfo objects
Heap Size =   2,327,516 - Size of heap after re-creating methodinfo objects
Heap Size =     247,028 - after freeing MethodInfo and MethodHandle objects

The above is the content of C# using binding handles to reduce the memory consumption of the process. For more related content, please pay attention to the PHP Chinese website (www.php.cn) !