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) !

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics











Guide to Active Directory with C#. Here we discuss the introduction and how Active Directory works in C# along with the syntax and example.

Guide to Random Number Generator in C#. Here we discuss how Random Number Generator work, concept of pseudo-random and secure numbers.

Guide to C# Data Grid View. Here we discuss the examples of how a data grid view can be loaded and exported from the SQL database or an excel file.

Guide to Factorial in C#. Here we discuss the introduction to factorial in c# along with different examples and code implementation.

The difference between multithreading and asynchronous is that multithreading executes multiple threads at the same time, while asynchronously performs operations without blocking the current thread. Multithreading is used for compute-intensive tasks, while asynchronously is used for user interaction. The advantage of multi-threading is to improve computing performance, while the advantage of asynchronous is to not block UI threads. Choosing multithreading or asynchronous depends on the nature of the task: Computation-intensive tasks use multithreading, tasks that interact with external resources and need to keep UI responsiveness use asynchronous.

Guide to Patterns in C#. Here we discuss the introduction and top 3 types of Patterns in C# along with its examples and code implementation.

Guide to Prime Numbers in C#. Here we discuss the introduction and examples of prime numbers in c# along with code implementation.

There are several ways to modify XML formats: manually editing with a text editor such as Notepad; automatically formatting with online or desktop XML formatting tools such as XMLbeautifier; define conversion rules using XML conversion tools such as XSLT; or parse and operate using programming languages such as Python. Be careful when modifying and back up the original files.
