Shulou(Shulou.com)06/02 Report--

This article introduces you how to parse the DotNet assembly, the content is very detailed, interested friends can refer to, hope to be helpful to you.

In the .NET Framework Framework, assemblies are the smallest unit of reuse, security, and versioning. An assembly is defined as a collection of one or more type definition files and resource files. The assembly mainly contains: PE/COFF,CLR header, metadata, manifest, CIL code, metadata.

PE/COFF files are generated by tools and represent logical groupings of files. PE files contain "manifest" data blocks, which are another collection of metadata tables that describe the files that make up the assembly, the types of public exports implemented by files in the assembly, and the resources or data files associated with the assembly.

Including metadata and IL (an intermediate language of Microsoft) in managed assemblies, IL can access and manipulate object types and provides instructions to create and initialize objects, call virtual methods on objects, and directly manipulate array elements.

The CLR header is a small block of information, which mainly contains the major (primary) and major (secondary) version numbers of the CLR for which the module is generated; a flag, a MethodDef token (which specifies the entry method of the module); and an optional strong name digital signature.

Metadata represents a binary data block consisting of several tables: definition table, reference table, and inventory table.

The above is a simple explanation of the composition of the assembly, and then take a look at some of the features of the assembly: the assembly defines a reusable type; the assembly marks a version number; and the assembly can have associated security information.

While the program is running, the JIT compiler uses the TypeRef and AssemblyRef metadata tables of the assembly to determine which assembly defines the referenced type. At run time, the JIT compiler needs to obtain information about the assembly, including name, version, language and culture, public key token, and so on, and concatenate these into a string. The JIT compiler will find the identified assembly and, if found, load the assembly into AppDomain.

Let's take a look at how to load assemblies in CLR:

In the static method Load of the System.Refection.Assembly class to load the assembly, the LoadFrom () method is used in the operation of loading the specified assembly. LoadFrom () has multiple overloaded versions. Take a look at the underlying implementation code of the LoadFrom method:

[ResourceExposure (ResourceScope.Machine)] [ResourceConsumption (ResourceScope.Machine)] [MethodImplAttribute (MethodImplOptions.NoInlining)] public static Assembly LoadFrom (String assemblyFile) {Contract.Ensures (Contract.Result ()! = null); Contract.Ensures (! Contract.Result () .ReflectionOnly); StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller Return RuntimeAssembly.InternalLoadFrom (assemblyFile, null, / / securityEvidence null, / / hashValue AssemblyHashAlgorithm.None, false,// forIntrospection false,// suppressSecurityChecks ref stackMark) } [System.Security.SecurityCritical] / / auto-generated [ResourceExposure (ResourceScope.Machine)] [ResourceConsumption (ResourceScope.Machine)] [MethodImplAttribute (MethodImplOptions.NoInlining)] / / Methods containing StackCrawlMark local var has to be marked non-inlineable internal static RuntimeAssembly InternalLoadFrom (String assemblyFile, Evidence securityEvidence) Byte [] hashValue, AssemblyHashAlgorithm hashAlgorithm, bool forIntrospection, bool suppressSecurityChecks Ref StackCrawlMark stackMark) {if (assemblyFile = = null) throw new ArgumentNullException ("assemblyFile") Contract.EndContractBlock (); # if FEATURE_CAS_POLICY if (securityEvidence! = null & &! AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled) {throw new NotSupportedException (Environment.GetResourceString ("NotSupported_RequiresCasPolicyImplicit"));} # endif / / FEATURE_CAS_POLICY AssemblyName an = new AssemblyName (); an.CodeBase = assemblyFile; an.SetHashControl (hashValue, hashAlgorithm) / / The stack mark is used for MDA filtering return InternalLoadAssemblyName (an, securityEvidence, null, ref stackMark, true / * thrownOnFileNotFound*/, forIntrospection, suppressSecurityChecks);}

In the operation of loading the assembly, LoadFrom first calls the static method GetAssemblyName of the Syatem.Reflection.AssemblyName class (this method opens the specified file, looks for record entries in the assemblyRef metadata table, extracts assembly identification information, and then returns this information as a Syatem.Reflection.AssemblyName object). The LoadFrom method internally calls the Load method of Assembly, passing the AssemblyName object to it, and CLR binds the redirection policy for the application version And look for matching assemblies in various locations. If Load finds a matching assembly, it loads it and returns an Assembly object that represents the loaded assembly, and the LoadFrom method returns this value.

Another way to load a program is LoadFile, which loads an assembly from any path and loads an assembly with the same identity into an AppDoamin multiple times. Next, take a look at the underlying implementation code of LoadFile:

[System.Security.SecuritySafeCritical] / / auto-generated [ResourceExposure (ResourceScope.Machine)] [ResourceConsumption (ResourceScope.Machine)] public static Assembly LoadFile (String path) {Contract.Ensures (Contract.Result ()! = null); Contract.Ensures (! Contract.Result () .ReflectionOnly); AppDomain.CheckLoadFileSupported (); new FileIOPermission (FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read, path). Demand () Return RuntimeAssembly.nLoadFile (path, null);}

The above gives a simple description of the structure of the assembly and the loading method of the assembly, and it is important to note that the assembly does not provide the function of unloading.

Here are some of the more common ways to manipulate assemblies

1. Common properties and methods:

Public static int Minutes = 60; public static int Hour = 60 * 60; public static int Day = 60 * 60 * 24; private readonly int _ time; private bool IsCache {get {return _ time > 0 }} / caching time, 0: no cache (default: 0 seconds, unit: seconds) / public ReflectionSugar (int time = 0) {_ time = time } / get key / private string GetKey (params string [] keyElementArray) {return string.Join ("", keyElementArray) based on the assembly path and name } / whether key exists / key / true does not exist false. Private bool ContainsKey (string key) {return HttpRuntime.Cache [key]! = null;} / get Cache according to key / private V Get (string key) {return (V) HttpRuntime.Cache [key] } / / insert cache. / key / value / expiration time unit second / / cache item attribute private void Add (string key, TV value, int cacheDurationInSeconds, CacheItemPriority priority = CacheItemPriority.Default) {string keyString = key HttpRuntime.Cache.Insert (keyString, value, null, DateTime.Now.AddSeconds (cacheDurationInSeconds), Cache.NoSlidingExpiration, priority, null);}

two。 Load the assembly:

/ load assembly / assembly path / public Assembly LoadFile (string path) {if (string.IsNullOrEmpty (path)) {throw new ArgumentNullException (path) } try {var key = GetKey ("LoadFile", path); if (IsCache) {if (ContainsKey (key)) {return Get (key) }} var asm = Assembly.LoadFile (path); if (IsCache) {Add (key, asm, _ time);} return asm } catch (Exception ex) {throw new Exception (ex.Message);}}

3. Get the type based on the assembly

/ / get the type / Assembly object / namespace / class name / assembly type public Type GetTypeByAssembly (Assembly asm, string nameSpace, string className) {try {var key = GetKey ("GetTypeByAssembly", nameSpace, className) based on the assembly If (IsCache) {if (ContainsKey (key)) {return Get (key);}} Type type = asm.GetType (nameSpace + "." + className) If (IsCache) {Add (key, type, _ time);} return type;} catch (Exception ex) {throw new Exception (ex.Message);}}

4. Create an object instance:

/ / create an object instance / / namespace. Type name / / assembly (dll name) / public T CreateInstance (string fullName, string assemblyName) {var key = GetKey ("CreateInstance1", fullName, assemblyName); if (IsCache) if (ContainsKey (key)) {return Get (key) } / / namespace. Type name, var path = fullName + "," + assemblyName; / / load type var o = Type.GetType (path); / / create an instance based on the type var obj = Activator.CreateInstance (o, true); var reval = (T) obj; if (IsCache) Add (key, reval, _ time) / / Type conversion and return return reval;}

In the above method, after the object is created based on the loaded assembly, the obtained return value structure is added to the cache.

On how to parse the DotNet assembly to share here, I hope that the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.