The Labs \ Source Viewer \ SSCLI \ System.Reflection.Emit \ ModuleBuilder

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. namespace System.Reflection.Emit
  16. {
  17.     using System.Runtime.InteropServices;
  18.     using System;
  19.     using IList = System.Collections.IList;
  20.     using ArrayList = System.Collections.ArrayList;
  21.     using CultureInfo = System.Globalization.CultureInfo;
  22.     using ResourceWriter = System.Resources.ResourceWriter;
  23.     using IResourceWriter = System.Resources.IResourceWriter;
  24.     using System.Diagnostics.SymbolStore;
  25.     using System.Reflection;
  26.     using System.Diagnostics;
  27.     using System.IO;
  28.     using System.Security;
  29.     using System.Security.Permissions;
  30.     using System.Runtime.Serialization;
  31.     using System.Text;
  32.     using System.Threading;
  33.     using System.Runtime.Versioning;
  34.    
  35.     // deliberately not [serializable]
  36.     [HostProtection(MayLeakOnAbort = true)]
  37.     [ClassInterface(ClassInterfaceType.None)]
  38.     [ComDefaultInterface(typeof(_ModuleBuilder))]
  39.     [System.Runtime.InteropServices.ComVisible(true)]
  40.     public class ModuleBuilder : Module, _ModuleBuilder
  41.     {
  42.         #region Internal Static Members
  43.         static internal string UnmangleTypeName(string typeName)
  44.         {
  45.             // Gets the original type name, without '+' name mangling.
  46.            
  47.             int i = typeName.Length - 1;
  48.             while (true) {
  49.                 i = typeName.LastIndexOf('+', i);
  50.                 if (i == -1)
  51.                     break;
  52.                
  53.                 bool evenSlashes = true;
  54.                 int iSlash = i;
  55.                 while (typeName[--iSlash] == '\\')
  56.                     evenSlashes = !evenSlashes;
  57.                
  58.                 // Even number of slashes means this '+' is a name separator
  59.                 if (evenSlashes)
  60.                     break;
  61.                
  62.                 i = iSlash;
  63.             }
  64.            
  65.             return typeName.Substring(i + 1);
  66.         }
  67.        
  68.         #endregion
  69.        
  70.         #region Private Data Members
  71.         // WARNING!! WARNING!!
  72.         // ModuleBuilder should not contain any data members as its reflectbase is the same as Module.
  73.         #endregion
  74.        
  75.         #region Constructor
  76.         private ModuleBuilder()
  77.         {
  78.         }
  79.        
  80.         #endregion
  81.        
  82.         #region Private Members
  83.         private Type GetType(string strFormat, Type baseType)
  84.         {
  85.             // This function takes a string to describe the compound type, such as "[,][]", and a baseType.
  86.            
  87.             if (strFormat == null || strFormat.Equals(String.Empty)) {
  88.                 return baseType;
  89.             }
  90.            
  91.             // convert the format string to byte array and then call FormCompoundType
  92.             char[] bFormat = strFormat.ToCharArray();
  93.             return SymbolType.FormCompoundType(bFormat, baseType, 0);
  94.            
  95.         }
  96.        
  97.        
  98.         internal void CheckContext(params Type[][] typess)
  99.         {
  100.             ((AssemblyBuilder)Assembly).CheckContext(typess);
  101.         }
  102.         internal void CheckContext(params Type[] types)
  103.         {
  104.             ((AssemblyBuilder)Assembly).CheckContext(types);
  105.         }
  106.         #endregion
  107.        
  108.         #region Internal Members
  109.         internal virtual Type FindTypeBuilderWithName(string strTypeName, bool ignoreCase)
  110.         {
  111.             int size = m_TypeBuilderList.Count;
  112.             int i;
  113.             Type typeTemp = null;
  114.            
  115.             for (i = 0; i < size; i++) {
  116.                 typeTemp = (Type)m_TypeBuilderList[i];
  117.                 if (ignoreCase == true) {
  118.                     if (String.Compare(typeTemp.FullName, strTypeName, ((ignoreCase) ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) == 0)
  119.                         break;
  120.                 }
  121.                 else {
  122.                     if (typeTemp.FullName.Equals(strTypeName))
  123.                         break;
  124.                 }
  125.             }
  126.             if (i == size)
  127.                 typeTemp = null;
  128.            
  129.             return typeTemp;
  130.         }
  131.        
  132.         internal Type GetRootElementType(Type type)
  133.         {
  134.             // This function will walk compound type to the inner most BaseType. Such as returning int for "ptr[] int".
  135.             if (type.IsByRef == false && type.IsPointer == false && type.IsArray == false)
  136.                 return type;
  137.            
  138.             return GetRootElementType(type.GetElementType());
  139.         }
  140.        
  141.         internal void SetEntryPoint(MethodInfo entryPoint)
  142.         {
  143.             // Sets the entry point of the module to be a given method. If no entry point
  144.             // is specified, calling EmitPEFile will generate a dll.
  145.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  146.             m_EntryPoint = GetMethodToken(entryPoint);
  147.         }
  148.        
  149.        
  150.         internal void PreSave(string fileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  151.         {
  152.             if (Assembly.m_assemblyData.m_isSynchronized) {
  153.                 lock (Assembly.m_assemblyData) {
  154.                     PreSaveNoLock(fileName, portableExecutableKind, imageFileMachine);
  155.                 }
  156.             }
  157.             else {
  158.                 PreSaveNoLock(fileName, portableExecutableKind, imageFileMachine);
  159.             }
  160.         }
  161.        
  162.         private void PreSaveNoLock(string fileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  163.         {
  164.             // This is a helper called by AssemblyBuilder save to presave information for the persistable modules.
  165.             object item;
  166.             TypeBuilder typeBuilder;
  167.             if (m_moduleData.m_isSaved == true) {
  168.                 // can only save once
  169.                 throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("InvalidOperation_ModuleHasBeenSaved"), m_moduleData.m_strModuleName));
  170.             }
  171.            
  172.             if (m_moduleData.m_fGlobalBeenCreated == false && m_moduleData.m_fHasGlobal == true)
  173.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_GlobalFunctionNotBaked"));
  174.            
  175.             int size = m_TypeBuilderList.Count;
  176.             for (int i = 0; i < size; i++) {
  177.                 item = m_TypeBuilderList[i];
  178.                 if (item is TypeBuilder) {
  179.                     typeBuilder = (TypeBuilder)item;
  180.                 }
  181.                 else {
  182.                     EnumBuilder enumBuilder = (EnumBuilder)item;
  183.                     typeBuilder = enumBuilder.m_typeBuilder;
  184.                 }
  185.                 if (typeBuilder.m_hasBeenCreated == false && typeBuilder.m_isHiddenType == false) {
  186.                     // cannot save to PE file without creating all of the types first
  187.                     throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("NotSupported_NotAllTypesAreBaked"), typeBuilder.FullName));
  188.                 }
  189.             }
  190.            
  191.             InternalPreSavePEFile((int)portableExecutableKind, (int)imageFileMachine);
  192.         }
  193.        
  194.         internal void Save(string fileName, bool isAssemblyFile, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  195.         {
  196.             if (Assembly.m_assemblyData.m_isSynchronized) {
  197.                 lock (Assembly.m_assemblyData) {
  198.                     SaveNoLock(fileName, isAssemblyFile, portableExecutableKind, imageFileMachine);
  199.                 }
  200.             }
  201.             else {
  202.                 SaveNoLock(fileName, isAssemblyFile, portableExecutableKind, imageFileMachine);
  203.             }
  204.         }
  205.        
  206.         private void SaveNoLock(string fileName, bool isAssemblyFile, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  207.         {
  208.             // This is a helper called by AssemblyBuilder save to save information for the persistable modules.
  209.             if (m_moduleData.m_embeddedRes != null) {
  210.                 // There are embedded resources for this module
  211.                 ResWriterData resWriter;
  212.                 int iCount;
  213.                
  214.                 // Set the number of resources embedded in this PE
  215.                 for (resWriter = m_moduleData.m_embeddedRes,iCount = 0; resWriter != null; resWriter = resWriter.m_nextResWriter,iCount++)
  216.                     ;
  217.                 InternalSetResourceCounts(iCount);
  218.                
  219.                 // Add each resource content into the to be saved PE file
  220.                 for (resWriter = m_moduleData.m_embeddedRes; resWriter != null; resWriter = resWriter.m_nextResWriter) {
  221.                     if (resWriter.m_resWriter != null)
  222.                         resWriter.m_resWriter.Generate();
  223.                    
  224.                     byte[] resBytes = new byte[resWriter.m_memoryStream.Length];
  225.                     resWriter.m_memoryStream.Flush();
  226.                     resWriter.m_memoryStream.Position = 0;
  227.                     resWriter.m_memoryStream.Read(resBytes, 0, resBytes.Length);
  228.                     InternalAddResource(resWriter.m_strName, resBytes, resBytes.Length, m_moduleData.m_tkFile, (int)resWriter.m_attribute, (int)portableExecutableKind, (int)imageFileMachine);
  229.                 }
  230.             }
  231.            
  232.            
  233.             if (isAssemblyFile)
  234.                 InternalSavePEFile(fileName, m_EntryPoint, (int)Assembly.m_assemblyData.m_peFileKind, true);
  235.             else
  236.                 InternalSavePEFile(fileName, m_EntryPoint, (int)PEFileKinds.Dll, false);
  237.             m_moduleData.m_isSaved = true;
  238.         }
  239.        
  240.         internal int GetTypeRefNested(Type type, Module refedModule, string strRefedModuleFileName)
  241.         {
  242.             // This function will generate correct TypeRef token for top level type and nested type.
  243.            
  244.             Type enclosingType = type.DeclaringType;
  245.             int tkResolution = 0;
  246.             string typeName = type.FullName;
  247.            
  248.             if (enclosingType != null) {
  249.                 tkResolution = GetTypeRefNested(enclosingType, refedModule, strRefedModuleFileName);
  250.                 typeName = UnmangleTypeName(typeName);
  251.             }
  252.            
  253.             return InternalGetTypeToken(typeName, refedModule, strRefedModuleFileName, tkResolution);
  254.         }
  255.        
  256.         internal MethodToken InternalGetConstructorToken(ConstructorInfo con, bool usingRef)
  257.         {
  258.             // Helper to get constructor token. If usingRef is true, we will never use the def token
  259.            
  260.            
  261.             int tr;
  262.             int mr = 0;
  263.            
  264.             if (con == null)
  265.                 throw new ArgumentNullException("con");
  266.            
  267.             if (con is ConstructorBuilder) {
  268.                 ConstructorBuilder conBuilder = con as ConstructorBuilder;
  269.                 if (usingRef == false && conBuilder.ReflectedType.Module.Equals(this))
  270.                     return conBuilder.GetToken();
  271.                
  272.                 // constructor is defined in a different module
  273.                 tr = GetTypeToken(con.ReflectedType).Token;
  274.                 mr = InternalGetMemberRef(con.ReflectedType.Module, tr, conBuilder.GetToken().Token);
  275.             }
  276.             else if (con is ConstructorOnTypeBuilderInstantiation) {
  277.                 ConstructorOnTypeBuilderInstantiation conBuilder = con as ConstructorOnTypeBuilderInstantiation;
  278.                 if (usingRef == true)
  279.                     throw new InvalidOperationException();
  280.                
  281.                 tr = GetTypeToken(con.DeclaringType).Token;
  282.                 mr = InternalGetMemberRef(con.DeclaringType.Module, tr, conBuilder.m_ctor.MetadataTokenInternal);
  283.             }
  284.             else if (con is RuntimeConstructorInfo && con.ReflectedType.IsArray == false) {
  285.                 // constructor is not a dynamic field
  286.                 // We need to get the TypeRef tokens
  287.                
  288.                 tr = GetTypeToken(con.ReflectedType).Token;
  289.                 mr = InternalGetMemberRefOfMethodInfo(tr, con.GetMethodHandle());
  290.             }
  291.             else {
  292.                 // some user derived ConstructorInfo
  293.                 // go through the slower code path, i.e. retrieve parameters and form signature helper.
  294.                 ParameterInfo[] parameters = con.GetParameters();
  295.                 Type[] parameterTypes = new Type[parameters.Length];
  296.                 Type[][] requiredCustomModifiers = new Type[parameterTypes.Length][];
  297.                 Type[][] optionalCustomModifiers = new Type[parameterTypes.Length][];
  298.                
  299.                 for (int i = 0; i < parameters.Length; i++) {
  300.                     parameterTypes[i] = parameters[i].ParameterType;
  301.                     requiredCustomModifiers[i] = parameters[i].GetRequiredCustomModifiers();
  302.                     optionalCustomModifiers[i] = parameters[i].GetOptionalCustomModifiers();
  303.                 }
  304.                
  305.                 tr = GetTypeToken(con.ReflectedType).Token;
  306.                
  307.                 SignatureHelper sigHelp = SignatureHelper.GetMethodSigHelper(this, con.CallingConvention, null, null, null, parameterTypes, requiredCustomModifiers, optionalCustomModifiers);
  308.                 int length;
  309.                 byte[] sigBytes = sigHelp.InternalGetSignature(out length);
  310.                
  311.                 mr = InternalGetMemberRefFromSignature(tr, con.Name, sigBytes, length);
  312.             }
  313.            
  314.             return new MethodToken(mr);
  315.         }
  316.        
  317.         internal void Init(string strModuleName, string strFileName, ISymbolWriter writer)
  318.         {
  319.             m_moduleData = new ModuleBuilderData(this, strModuleName, strFileName);
  320.             m_TypeBuilderList = new ArrayList();
  321.             m_iSymWriter = writer;
  322.            
  323.             if (writer != null) {
  324.                 // Set the underlying writer for the managed writer
  325.                 // that we're using. Note that this function requires
  326.                 // unmanaged code access.
  327.                 new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
  328.                 writer.SetUnderlyingWriter(m_pInternalSymWriter);
  329.             }
  330.         }
  331.        
  332.         [ResourceExposure(ResourceScope.Machine)]
  333.         [ResourceConsumption(ResourceScope.Machine)]
  334.         internal void DefineUnmanagedResourceFileInternal(string resourceFileName)
  335.         {
  336.             // Shouldn't have resource bytes, but a previous file is OK, because assemblyBuilder.Save
  337.             // creates then deletes a temp file.
  338.             if (m_moduleData.m_resourceBytes != null)
  339.                 throw new ArgumentException(Environment.GetResourceString("Argument_NativeResourceAlreadyDefined"));
  340.            
  341.             if (resourceFileName == null)
  342.                 throw new ArgumentNullException("resourceFileName");
  343.            
  344.             if (m_moduleData.m_fHasExplicitUnmanagedResource)
  345.                 throw new ArgumentException(Environment.GetResourceString("Argument_NativeResourceAlreadyDefined"));
  346.            
  347.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  348.            
  349.             // Check caller has the right to read the file.
  350.             string strFullFileName;
  351.             strFullFileName = Path.GetFullPath(resourceFileName);
  352.             new FileIOPermission(FileIOPermissionAccess.Read, strFullFileName).Demand();
  353.            
  354.             new EnvironmentPermission(PermissionState.Unrestricted).Assert();
  355.             try {
  356.                 if (File.Exists(resourceFileName) == false)
  357.                     throw new FileNotFoundException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("IO.FileNotFound_FileName"), resourceFileName), resourceFileName);
  358.             }
  359.             finally {
  360.                 CodeAccessPermission.RevertAssert();
  361.             }
  362.            
  363.             m_moduleData.m_strResourceFileName = strFullFileName;
  364.         }
  365.        
  366.         #endregion
  367.        
  368.         #region Module Overrides
  369.         public override Type[] GetTypes()
  370.         {
  371.             int size = m_TypeBuilderList.Count;
  372.             Type[] moduleTypes = new Type[size];
  373.             TypeBuilder tmpTypeBldr;
  374.             int filtered = 0;
  375.            
  376.             for (int i = 0; i < size; i++) {
  377.                 EnumBuilder enumBldr = m_TypeBuilderList[i] as EnumBuilder;
  378.                 tmpTypeBldr = m_TypeBuilderList[i] as TypeBuilder;
  379.                 if (enumBldr != null)
  380.                     tmpTypeBldr = enumBldr.m_typeBuilder;
  381.                
  382.                 if (tmpTypeBldr != null) {
  383.                     if (tmpTypeBldr.m_hasBeenCreated)
  384.                         moduleTypes[i] = tmpTypeBldr.UnderlyingSystemType;
  385.                     else
  386.                         moduleTypes[i] = tmpTypeBldr;
  387.                 }
  388.                 else {
  389.                     // RuntimeType case: This will happen in TlbImp.
  390.                     moduleTypes[i] = (Type)m_TypeBuilderList[i];
  391.                 }
  392.             }
  393.            
  394.             if (filtered > 0) {
  395.                 Type[] filteredTypes = new Type[size - filtered];
  396.                 int src;
  397.                 int dst;
  398.                 for (src = 0,dst = 0; src < size; src++) {
  399.                     if (moduleTypes[src] != null) {
  400.                         filteredTypes[dst] = moduleTypes[src];
  401.                         dst++;
  402.                     }
  403.                 }
  404.                 moduleTypes = filteredTypes;
  405.             }
  406.            
  407.             return moduleTypes;
  408.         }
  409.        
  410.         [System.Runtime.InteropServices.ComVisible(true)]
  411.         public override Type GetType(string className)
  412.         {
  413.             return GetType(className, false, false);
  414.         }
  415.        
  416.         [System.Runtime.InteropServices.ComVisible(true)]
  417.         public override Type GetType(string className, bool ignoreCase)
  418.         {
  419.             return GetType(className, false, ignoreCase);
  420.         }
  421.        
  422.         [System.Runtime.InteropServices.ComVisible(true)]
  423.         public override Type GetType(string className, bool throwOnError, bool ignoreCase)
  424.         {
  425.             if (Assembly.m_assemblyData.m_isSynchronized) {
  426.                 lock (Assembly.m_assemblyData) {
  427.                     return GetTypeNoLock(className, throwOnError, ignoreCase);
  428.                 }
  429.             }
  430.             else {
  431.                 return GetTypeNoLock(className, throwOnError, ignoreCase);
  432.             }
  433.         }
  434.        
  435.         private Type GetTypeNoLock(string className, bool throwOnError, bool ignoreCase)
  436.         {
  437.             // public API to to a type. The reason that we need this function override from module
  438.             // is because clients might need to get foo[] when foo is being built. For example, if
  439.             // foo class contains a data member of type foo[].
  440.             // This API first delegate to the Module.GetType implementation. If succeeded, great!
  441.             // If not, we have to look up the current module to find the TypeBuilder to represent the base
  442.             // type and form the Type object for "foo[,]".
  443.            
  444.             // Module.GetType() will verify className.
  445.             Type baseType = base.GetType(className, throwOnError, ignoreCase);
  446.             if (baseType != null)
  447.                 return baseType;
  448.            
  449.             // Now try to see if we contain a TypeBuilder for this type or not.
  450.             // Might have a compound type name, indicated via an unescaped
  451.             // '[', '*' or '&'. Split the name at this point.
  452.             string baseName = null;
  453.             string parameters = null;
  454.             int startIndex = 0;
  455.            
  456.             while (startIndex <= className.Length) {
  457.                 // Are there any possible special characters left?
  458.                 int i = className.IndexOfAny(new char[] {'[', '*', '&'}, startIndex);
  459.                 if (i == -1) {
  460.                     // No, type name is simple.
  461.                     baseName = className;
  462.                     parameters = null;
  463.                     break;
  464.                 }
  465.                
  466.                 // Found a potential special character, but it might be escaped.
  467.                 int slashes = 0;
  468.                 for (int j = i - 1; j >= 0 && className[j] == '\\'; j--)
  469.                     slashes++;
  470.                
  471.                 // Odd number of slashes indicates escaping.
  472.                 if (slashes % 2 == 1) {
  473.                     startIndex = i + 1;
  474.                     continue;
  475.                 }
  476.                
  477.                 // Found the end of the base type name.
  478.                 baseName = className.Substring(0, i);
  479.                 parameters = className.Substring(i);
  480.                 break;
  481.             }
  482.            
  483.             // If we didn't find a basename yet, the entire class name is
  484.             // the base name and we don't have a composite type.
  485.             if (baseName == null) {
  486.                 baseName = className;
  487.                 parameters = null;
  488.             }
  489.            
  490.             baseName = baseName.Replace("\\\\", "\\").Replace("\\[", "[").Replace("\\*", "*").Replace("\\&", "&");
  491.            
  492.             if (parameters != null) {
  493.                 // try to see if reflection can find the base type. It can be such that reflection
  494.                 // does not support the complex format string yet!
  495.                
  496.                 baseType = base.GetType(baseName, false, ignoreCase);
  497.             }
  498.            
  499.             if (baseType == null) {
  500.                 // try to find it among the unbaked types.
  501.                 // starting with the current module first of all.
  502.                 baseType = FindTypeBuilderWithName(baseName, ignoreCase);
  503.                 if (baseType == null && Assembly is AssemblyBuilder) {
  504.                     // now goto Assembly level to find the type.
  505.                     int size;
  506.                     ArrayList modList;
  507.                    
  508.                     modList = Assembly.m_assemblyData.m_moduleBuilderList;
  509.                     size = modList.Count;
  510.                     for (int i = 0; i < size && baseType == null; i++) {
  511.                         ModuleBuilder mBuilder = (ModuleBuilder)modList[i];
  512.                         baseType = mBuilder.FindTypeBuilderWithName(baseName, ignoreCase);
  513.                     }
  514.                 }
  515.                 if (baseType == null)
  516.                     return null;
  517.             }
  518.            
  519.             if (parameters == null)
  520.                 return baseType;
  521.            
  522.             return GetType(parameters, baseType);
  523.         }
  524.        
  525.         public override string FullyQualifiedName {
  526.             [ResourceExposure(ResourceScope.Machine)]
  527.             [ResourceConsumption(ResourceScope.Machine)]
  528.             get {
  529.                 string fullyQualifiedName = m_moduleData.m_strFileName;
  530.                 if (fullyQualifiedName == null)
  531.                     return null;
  532.                 if (Assembly.m_assemblyData.m_strDir != null) {
  533.                     fullyQualifiedName = Path.Combine(Assembly.m_assemblyData.m_strDir, fullyQualifiedName);
  534.                     fullyQualifiedName = Path.GetFullPath(fullyQualifiedName);
  535.                 }
  536.                
  537.                 if (Assembly.m_assemblyData.m_strDir != null && fullyQualifiedName != null) {
  538.                     new FileIOPermission(FileIOPermissionAccess.PathDiscovery, fullyQualifiedName).Demand();
  539.                 }
  540.                
  541.                 return fullyQualifiedName;
  542.             }
  543.         }
  544.        
  545.         #endregion
  546.        
  547.         #region Public Members
  548.        
  549.         #region Define Type
  550.         public TypeBuilder DefineType(string name)
  551.         {
  552.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  553.             if (Assembly.m_assemblyData.m_isSynchronized) {
  554.                 lock (Assembly.m_assemblyData) {
  555.                     return DefineTypeNoLock(name);
  556.                 }
  557.             }
  558.             else {
  559.                 return DefineTypeNoLock(name);
  560.             }
  561.         }
  562.        
  563.         private TypeBuilder DefineTypeNoLock(string name)
  564.         {
  565.             TypeBuilder typeBuilder;
  566.             typeBuilder = new TypeBuilder(name, TypeAttributes.NotPublic, null, null, this, PackingSize.Unspecified, null);
  567.             m_TypeBuilderList.Add(typeBuilder);
  568.             return typeBuilder;
  569.         }
  570.        
  571.         public TypeBuilder DefineType(string name, TypeAttributes attr)
  572.         {
  573.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  574.             if (Assembly.m_assemblyData.m_isSynchronized) {
  575.                 lock (Assembly.m_assemblyData) {
  576.                     return DefineTypeNoLock(name, attr);
  577.                 }
  578.             }
  579.             else {
  580.                 return DefineTypeNoLock(name, attr);
  581.             }
  582.         }
  583.        
  584.         private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr)
  585.         {
  586.             TypeBuilder typeBuilder;
  587.             typeBuilder = new TypeBuilder(name, attr, null, null, this, PackingSize.Unspecified, null);
  588.             m_TypeBuilderList.Add(typeBuilder);
  589.             return typeBuilder;
  590.         }
  591.        
  592.         public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent)
  593.         {
  594.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  595.             if (Assembly.m_assemblyData.m_isSynchronized) {
  596.                 lock (Assembly.m_assemblyData) {
  597.                     return DefineTypeNoLock(name, attr, parent);
  598.                 }
  599.             }
  600.             else {
  601.                 return DefineTypeNoLock(name, attr, parent);
  602.             }
  603.         }
  604.        
  605.         private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr, Type parent)
  606.         {
  607.             CheckContext(parent);
  608.            
  609.             TypeBuilder typeBuilder;
  610.            
  611.             typeBuilder = new TypeBuilder(name, attr, parent, null, this, PackingSize.Unspecified, null);
  612.             m_TypeBuilderList.Add(typeBuilder);
  613.             return typeBuilder;
  614.         }
  615.        
  616.         public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent, int typesize)
  617.         {
  618.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  619.             if (Assembly.m_assemblyData.m_isSynchronized) {
  620.                 lock (Assembly.m_assemblyData) {
  621.                     return DefineTypeNoLock(name, attr, parent, typesize);
  622.                 }
  623.             }
  624.             else {
  625.                 return DefineTypeNoLock(name, attr, parent, typesize);
  626.             }
  627.         }
  628.        
  629.         private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr, Type parent, int typesize)
  630.         {
  631.             TypeBuilder typeBuilder;
  632.             typeBuilder = new TypeBuilder(name, attr, parent, this, PackingSize.Unspecified, typesize, null);
  633.             m_TypeBuilderList.Add(typeBuilder);
  634.             return typeBuilder;
  635.         }
  636.        
  637.         public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent, PackingSize packingSize, int typesize)
  638.         {
  639.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  640.             if (Assembly.m_assemblyData.m_isSynchronized) {
  641.                 lock (Assembly.m_assemblyData) {
  642.                     return DefineTypeNoLock(name, attr, parent, packingSize, typesize);
  643.                 }
  644.             }
  645.             else {
  646.                 return DefineTypeNoLock(name, attr, parent, packingSize, typesize);
  647.             }
  648.         }
  649.        
  650.         private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr, Type parent, PackingSize packingSize, int typesize)
  651.         {
  652.             TypeBuilder typeBuilder;
  653.             typeBuilder = new TypeBuilder(name, attr, parent, this, packingSize, typesize, null);
  654.             m_TypeBuilderList.Add(typeBuilder);
  655.             return typeBuilder;
  656.         }
  657.        
  658.         [System.Runtime.InteropServices.ComVisible(true)]
  659.         public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent, Type[] interfaces)
  660.         {
  661.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  662.             if (Assembly.m_assemblyData.m_isSynchronized) {
  663.                 lock (Assembly.m_assemblyData) {
  664.                     return DefineTypeNoLock(name, attr, parent, interfaces);
  665.                 }
  666.             }
  667.             else {
  668.                 return DefineTypeNoLock(name, attr, parent, interfaces);
  669.             }
  670.         }
  671.        
  672.         private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr, Type parent, Type[] interfaces)
  673.         {
  674.             TypeBuilder typeBuilder;
  675.             typeBuilder = new TypeBuilder(name, attr, parent, interfaces, this, PackingSize.Unspecified, null);
  676.             m_TypeBuilderList.Add(typeBuilder);
  677.             return typeBuilder;
  678.         }
  679.        
  680.         #endregion
  681.        
  682.         #region Define Enum
  683.         public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent, PackingSize packsize)
  684.         {
  685.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  686.             if (Assembly.m_assemblyData.m_isSynchronized) {
  687.                 lock (Assembly.m_assemblyData) {
  688.                     return DefineTypeNoLock(name, attr, parent, packsize);
  689.                 }
  690.             }
  691.             else {
  692.                 return DefineTypeNoLock(name, attr, parent, packsize);
  693.             }
  694.         }
  695.        
  696.         private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr, Type parent, PackingSize packsize)
  697.         {
  698.             TypeBuilder typeBuilder;
  699.             typeBuilder = new TypeBuilder(name, attr, parent, null, this, packsize, null);
  700.             m_TypeBuilderList.Add(typeBuilder);
  701.             return typeBuilder;
  702.         }
  703.        
  704.         public EnumBuilder DefineEnum(string name, TypeAttributes visibility, Type underlyingType)
  705.         {
  706.             CheckContext(underlyingType);
  707.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  708.             if (Assembly.m_assemblyData.m_isSynchronized) {
  709.                 lock (Assembly.m_assemblyData) {
  710.                     return DefineEnumNoLock(name, visibility, underlyingType);
  711.                 }
  712.             }
  713.             else {
  714.                 return DefineEnumNoLock(name, visibility, underlyingType);
  715.             }
  716.         }
  717.        
  718.         private EnumBuilder DefineEnumNoLock(string name, TypeAttributes visibility, Type underlyingType)
  719.         {
  720.             EnumBuilder enumBuilder;
  721.             enumBuilder = new EnumBuilder(name, underlyingType, visibility, this);
  722.             m_TypeBuilderList.Add(enumBuilder);
  723.             return enumBuilder;
  724.         }
  725.        
  726.         #endregion
  727.        
  728.         #region Define Resource
  729.         public IResourceWriter DefineResource(string name, string description)
  730.         {
  731.             // Define embedded managed resource to be stored in this module
  732.            
  733.             return DefineResource(name, description, ResourceAttributes.Public);
  734.         }
  735.        
  736.         public IResourceWriter DefineResource(string name, string description, ResourceAttributes attribute)
  737.         {
  738.             // Define embedded managed resource to be stored in this module
  739.            
  740.            
  741.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  742.             if (Assembly.m_assemblyData.m_isSynchronized) {
  743.                 lock (Assembly.m_assemblyData) {
  744.                     return DefineResourceNoLock(name, description, attribute);
  745.                 }
  746.             }
  747.             else {
  748.                 return DefineResourceNoLock(name, description, attribute);
  749.             }
  750.         }
  751.        
  752.         private IResourceWriter DefineResourceNoLock(string name, string description, ResourceAttributes attribute)
  753.         {
  754.             // Define embedded managed resource to be stored in this module
  755.            
  756.            
  757.             if (IsTransient())
  758.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadResourceContainer"));
  759.            
  760.             if (name == null)
  761.                 throw new ArgumentNullException("name");
  762.             if (name.Length == 0)
  763.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  764.            
  765.             Assembly assembly = this.Assembly;
  766.             if (assembly is AssemblyBuilder) {
  767.                 AssemblyBuilder asmBuilder = (AssemblyBuilder)assembly;
  768.                 if (asmBuilder.IsPersistable()) {
  769.                     asmBuilder.m_assemblyData.CheckResNameConflict(name);
  770.                    
  771.                     MemoryStream stream = new MemoryStream();
  772.                     ResourceWriter resWriter = new ResourceWriter(stream);
  773.                     ResWriterData resWriterData = new ResWriterData(resWriter, stream, name, String.Empty, String.Empty, attribute);
  774.                    
  775.                     // chain it to the embedded resource list
  776.                     resWriterData.m_nextResWriter = m_moduleData.m_embeddedRes;
  777.                     m_moduleData.m_embeddedRes = resWriterData;
  778.                     return resWriter;
  779.                 }
  780.                 else {
  781.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadResourceContainer"));
  782.                 }
  783.             }
  784.             else {
  785.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadResourceContainer"));
  786.             }
  787.         }
  788.        
  789.         public void DefineManifestResource(string name, Stream stream, ResourceAttributes attribute)
  790.         {
  791.             if (name == null)
  792.                 throw new ArgumentNullException("name");
  793.            
  794.             if (stream == null)
  795.                 throw new ArgumentNullException("stream");
  796.            
  797.             // Define embedded managed resource to be stored in this module
  798.            
  799.            
  800.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  801.             if (Assembly.m_assemblyData.m_isSynchronized) {
  802.                 lock (Assembly.m_assemblyData) {
  803.                     DefineManifestResourceNoLock(name, stream, attribute);
  804.                 }
  805.             }
  806.             else {
  807.                 DefineManifestResourceNoLock(name, stream, attribute);
  808.             }
  809.         }
  810.        
  811.         private void DefineManifestResourceNoLock(string name, Stream stream, ResourceAttributes attribute)
  812.         {
  813.             // Define embedded managed resource to be stored in this module
  814.            
  815.            
  816.             if (IsTransient())
  817.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadResourceContainer"));
  818.            
  819.             if (name == null)
  820.                 throw new ArgumentNullException("name");
  821.             if (name.Length == 0)
  822.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  823.            
  824.             Assembly assembly = this.Assembly;
  825.             if (assembly is AssemblyBuilder) {
  826.                 AssemblyBuilder asmBuilder = (AssemblyBuilder)assembly;
  827.                 if (asmBuilder.IsPersistable()) {
  828.                     asmBuilder.m_assemblyData.CheckResNameConflict(name);
  829.                    
  830.                     ResWriterData resWriterData = new ResWriterData(null, stream, name, String.Empty, String.Empty, attribute);
  831.                    
  832.                     // chain it to the embedded resource list
  833.                     resWriterData.m_nextResWriter = m_moduleData.m_embeddedRes;
  834.                     m_moduleData.m_embeddedRes = resWriterData;
  835.                 }
  836.                 else {
  837.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadResourceContainer"));
  838.                 }
  839.             }
  840.             else {
  841.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadResourceContainer"));
  842.             }
  843.         }
  844.        
  845.        
  846.         public void DefineUnmanagedResource(byte[] resource)
  847.         {
  848.             if (m_moduleData.m_strResourceFileName != null || m_moduleData.m_resourceBytes != null)
  849.                 throw new ArgumentException(Environment.GetResourceString("Argument_NativeResourceAlreadyDefined"));
  850.            
  851.             if (resource == null)
  852.                 throw new ArgumentNullException("resource");
  853.            
  854.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  855.            
  856.             m_moduleData.m_resourceBytes = new byte[resource.Length];
  857.             System.Array.Copy(resource, m_moduleData.m_resourceBytes, resource.Length);
  858.             m_moduleData.m_fHasExplicitUnmanagedResource = true;
  859.         }
  860.        
  861.         [ResourceExposure(ResourceScope.Machine)]
  862.         [ResourceConsumption(ResourceScope.Machine)]
  863.         public void DefineUnmanagedResource(string resourceFileName)
  864.         {
  865.             // No resource should have been set already.
  866.             if (m_moduleData.m_strResourceFileName != null || m_moduleData.m_resourceBytes != null)
  867.                 throw new ArgumentException(Environment.GetResourceString("Argument_NativeResourceAlreadyDefined"));
  868.            
  869.             // Must have a file name.
  870.             if (resourceFileName == null)
  871.                 throw new ArgumentNullException("resourceFileName");
  872.            
  873.             // Defer to internal implementation.
  874.             DefineUnmanagedResourceFileInternal(resourceFileName);
  875.             m_moduleData.m_fHasExplicitUnmanagedResource = true;
  876.         }
  877.        
  878.         #endregion
  879.        
  880.         #region Define Global Method
  881.         public MethodBuilder DefineGlobalMethod(string name, MethodAttributes attributes, Type returnType, Type[] parameterTypes)
  882.         {
  883.             return DefineGlobalMethod(name, attributes, CallingConventions.Standard, returnType, parameterTypes);
  884.         }
  885.        
  886.         public MethodBuilder DefineGlobalMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
  887.         {
  888.             return DefineGlobalMethod(name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null);
  889.         }
  890.        
  891.         public MethodBuilder DefineGlobalMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
  892.         {
  893.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  894.             if (Assembly.m_assemblyData.m_isSynchronized) {
  895.                 lock (Assembly.m_assemblyData) {
  896.                     return DefineGlobalMethodNoLock(name, attributes, callingConvention, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
  897.                 }
  898.             }
  899.             else {
  900.                 return DefineGlobalMethodNoLock(name, attributes, callingConvention, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
  901.             }
  902.         }
  903.        
  904.         private MethodBuilder DefineGlobalMethodNoLock(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
  905.         {
  906.             CheckContext(returnType);
  907.             CheckContext(requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes);
  908.             CheckContext(requiredParameterTypeCustomModifiers);
  909.             CheckContext(optionalParameterTypeCustomModifiers);
  910.            
  911.             if (m_moduleData.m_fGlobalBeenCreated == true)
  912.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_GlobalsHaveBeenCreated"));
  913.            
  914.             if (name == null)
  915.                 throw new ArgumentNullException("name");
  916.            
  917.             if (name.Length == 0)
  918.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  919.            
  920.             if ((attributes & MethodAttributes.Static) == 0)
  921.                 throw new ArgumentException(Environment.GetResourceString("Argument_GlobalFunctionHasToBeStatic"));
  922.            
  923.             m_moduleData.m_fHasGlobal = true;
  924.            
  925.             return m_moduleData.m_globalTypeBuilder.DefineMethod(name, attributes, callingConvention, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
  926.         }
  927.        
  928.         public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
  929.         {
  930.             return DefinePInvokeMethod(name, dllName, name, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet);
  931.         }
  932.        
  933.         public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
  934.         {
  935.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  936.             if (Assembly.m_assemblyData.m_isSynchronized) {
  937.                 lock (Assembly.m_assemblyData) {
  938.                     return DefinePInvokeMethodNoLock(name, dllName, entryName, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet);
  939.                 }
  940.             }
  941.             else {
  942.                 return DefinePInvokeMethodNoLock(name, dllName, entryName, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet);
  943.             }
  944.         }
  945.        
  946.         private MethodBuilder DefinePInvokeMethodNoLock(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
  947.         {
  948.             CheckContext(returnType);
  949.             CheckContext(parameterTypes);
  950.            
  951.             //Global methods must be static.
  952.             if ((attributes & MethodAttributes.Static) == 0) {
  953.                 throw new ArgumentException(Environment.GetResourceString("Argument_GlobalFunctionHasToBeStatic"));
  954.             }
  955.             m_moduleData.m_fHasGlobal = true;
  956.             return m_moduleData.m_globalTypeBuilder.DefinePInvokeMethod(name, dllName, entryName, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet);
  957.         }
  958.        
  959.         public void CreateGlobalFunctions()
  960.         {
  961.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  962.             if (Assembly.m_assemblyData.m_isSynchronized) {
  963.                 lock (Assembly.m_assemblyData) {
  964.                     CreateGlobalFunctionsNoLock();
  965.                 }
  966.             }
  967.             else {
  968.                 CreateGlobalFunctionsNoLock();
  969.             }
  970.         }
  971.        
  972.         private void CreateGlobalFunctionsNoLock()
  973.         {
  974.             if (m_moduleData.m_fGlobalBeenCreated) {
  975.                 // cannot create globals twice
  976.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule"));
  977.             }
  978.             m_moduleData.m_globalTypeBuilder.CreateType();
  979.             m_moduleData.m_fGlobalBeenCreated = true;
  980.         }
  981.        
  982.         #endregion
  983.        
  984.         #region Define Data
  985.         public FieldBuilder DefineInitializedData(string name, byte[] data, FieldAttributes attributes)
  986.         {
  987.             // This method will define an initialized Data in .sdata.
  988.             // We will create a fake TypeDef to represent the data with size. This TypeDef
  989.             // will be the signature for the Field.
  990.            
  991.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  992.            
  993.             if (Assembly.m_assemblyData.m_isSynchronized) {
  994.                 lock (Assembly.m_assemblyData) {
  995.                     return DefineInitializedDataNoLock(name, data, attributes);
  996.                 }
  997.             }
  998.             else {
  999.                 return DefineInitializedDataNoLock(name, data, attributes);
  1000.             }
  1001.         }
  1002.        
  1003.         private FieldBuilder DefineInitializedDataNoLock(string name, byte[] data, FieldAttributes attributes)
  1004.         {
  1005.             // This method will define an initialized Data in .sdata.
  1006.             // We will create a fake TypeDef to represent the data with size. This TypeDef
  1007.             // will be the signature for the Field.
  1008.             if (m_moduleData.m_fGlobalBeenCreated == true) {
  1009.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_GlobalsHaveBeenCreated"));
  1010.             }
  1011.            
  1012.             m_moduleData.m_fHasGlobal = true;
  1013.             return m_moduleData.m_globalTypeBuilder.DefineInitializedData(name, data, attributes);
  1014.         }
  1015.        
  1016.         public FieldBuilder DefineUninitializedData(string name, int size, FieldAttributes attributes)
  1017.         {
  1018.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  1019.             if (Assembly.m_assemblyData.m_isSynchronized) {
  1020.                 lock (Assembly.m_assemblyData) {
  1021.                     return DefineUninitializedDataNoLock(name, size, attributes);
  1022.                 }
  1023.             }
  1024.             else {
  1025.                 return DefineUninitializedDataNoLock(name, size, attributes);
  1026.             }
  1027.         }
  1028.        
  1029.         private FieldBuilder DefineUninitializedDataNoLock(string name, int size, FieldAttributes attributes)
  1030.         {
  1031.             // This method will define an uninitialized Data in .sdata.
  1032.             // We will create a fake TypeDef to represent the data with size. This TypeDef
  1033.             // will be the signature for the Field.
  1034.            
  1035.             if (m_moduleData.m_fGlobalBeenCreated == true) {
  1036.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_GlobalsHaveBeenCreated"));
  1037.             }
  1038.            
  1039.             m_moduleData.m_fHasGlobal = true;
  1040.             return m_moduleData.m_globalTypeBuilder.DefineUninitializedData(name, size, attributes);
  1041.         }
  1042.        
  1043.         #endregion
  1044.        
  1045.         #region GetToken
  1046.         public TypeToken GetTypeToken(Type type)
  1047.         {
  1048.             if (Assembly.m_assemblyData.m_isSynchronized) {
  1049.                 lock (Assembly.m_assemblyData) {
  1050.                     return GetTypeTokenNoLock(type);
  1051.                 }
  1052.             }
  1053.             else {
  1054.                 return GetTypeTokenNoLock(type);
  1055.             }
  1056.         }
  1057.        
  1058.         private TypeToken GetTypeTokenNoLock(Type type)
  1059.         {
  1060.             CheckContext(type);
  1061.            
  1062.             // Return a token for the class relative to the Module. Tokens
  1063.             // are used to indentify objects when the objects are used in IL
  1064.             // instructions. Tokens are always relative to the Module. For example,
  1065.             // the token value for System.String is likely to be different from
  1066.             // Module to Module. Calling GetTypeToken will cause a reference to be
  1067.             // added to the Module. This reference becomes a perminate part of the Module,
  1068.             // multiple calles to this method with the same class have no additional side affects.
  1069.             // This function is optimized to use the TypeDef token if Type is within the same module.
  1070.             // We should also be aware of multiple dynamic modules and multiple implementation of Type!!!
  1071.            
  1072.             TypeToken tkToken;
  1073.             bool isSameAssembly;
  1074.             bool isSameModule;
  1075.             Module refedModule;
  1076.             string strRefedModuleFileName = String.Empty;
  1077.            
  1078.             // assume that referenced module is non-transient. Only if the referenced module is dynamic,
  1079.             // and transient, this variable will be set to true.
  1080.             bool isRefedModuleTransient = false;
  1081.            
  1082.             if (type == null)
  1083.                 throw new ArgumentNullException("type");
  1084.            
  1085.             refedModule = type.Module;
  1086.             isSameModule = refedModule.Equals(this);
  1087.            
  1088.             if (type.IsByRef)
  1089.                 throw new ArgumentException(Environment.GetResourceString("Argument_CannotGetTypeTokenForByRef"));
  1090.            
  1091.             if ((type.IsGenericType && !type.IsGenericTypeDefinition) || type.IsGenericParameter || type.IsArray || type.IsPointer) {
  1092.                 int length;
  1093.                 byte[] sig = SignatureHelper.GetTypeSigToken(this, type).InternalGetSignature(out length);
  1094.                 return new TypeToken(InternalGetTypeSpecTokenWithBytes(sig, length));
  1095.             }
  1096.            
  1097.             // After this point, it is not an array type nor Pointer type
  1098.            
  1099.             if (isSameModule) {
  1100.                 // no need to do anything additional other than defining the TypeRef Token
  1101.                 if (type is TypeBuilder) {
  1102.                     // optimization: if the type is defined in this module,
  1103.                     // just return the token
  1104.                     //
  1105.                     TypeBuilder typeBuilder = (TypeBuilder)type;
  1106.                     return typeBuilder.TypeToken;
  1107.                 }
  1108.                 else if (type is EnumBuilder) {
  1109.                     TypeBuilder typeBuilder = ((EnumBuilder)type).m_typeBuilder;
  1110.                     return typeBuilder.TypeToken;
  1111.                 }
  1112.                 else if (type is GenericTypeParameterBuilder) {
  1113.                     return new TypeToken(type.MetadataTokenInternal);
  1114.                 }
  1115.                
  1116.                 return new TypeToken(GetTypeRefNested(type, this, String.Empty));
  1117.             }
  1118.            
  1119.             // After this point, the referenced module is not the same as the referencing
  1120.             // module.
  1121.             //
  1122.             isSameAssembly = refedModule.Assembly.Equals(Assembly);
  1123.             if (refedModule is ModuleBuilder) {
  1124.                 ModuleBuilder refedModuleBuilder = (ModuleBuilder)refedModule;
  1125.                 if (refedModuleBuilder.IsTransient()) {
  1126.                     isRefedModuleTransient = true;
  1127.                 }
  1128.                 // get the referenced module's file name
  1129.                 strRefedModuleFileName = refedModuleBuilder.m_moduleData.m_strFileName;
  1130.             }
  1131.             else
  1132.                 strRefedModuleFileName = refedModule.ScopeName;
  1133.            
  1134.             // We cannot have a non-transient module referencing to a transient module.
  1135.             if (IsTransient() == false && isRefedModuleTransient) {
  1136.                
  1137.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadTransientModuleReference"));
  1138.             }
  1139.            
  1140.             tkToken = new TypeToken(GetTypeRefNested(type, refedModule, strRefedModuleFileName));
  1141.             return tkToken;
  1142.         }
  1143.        
  1144.         public TypeToken GetTypeToken(string name)
  1145.         {
  1146.            
  1147.            
  1148.             return GetTypeToken(base.GetType(name, false, true));
  1149.         }
  1150.        
  1151.         public MethodToken GetMethodToken(MethodInfo method)
  1152.         {
  1153.             if (Assembly.m_assemblyData.m_isSynchronized) {
  1154.                 lock (Assembly.m_assemblyData) {
  1155.                     return GetMethodTokenNoLock(method);
  1156.                 }
  1157.             }
  1158.             else {
  1159.                 return GetMethodTokenNoLock(method);
  1160.             }
  1161.         }
  1162.        
  1163.         private MethodToken GetMethodTokenNoLock(MethodInfo method)
  1164.         {
  1165.             // Return a MemberRef token if MethodInfo is not defined in this module. Or
  1166.             // return the MethodDef token.
  1167.            
  1168.             int tr;
  1169.             int mr = 0;
  1170.            
  1171.             if (method == null)
  1172.                 throw new ArgumentNullException("method");
  1173.            
  1174.             if (method is MethodBuilder || method is MethodOnTypeBuilderInstantiation) {
  1175.                 if (method.Module == this)
  1176.                     return new MethodToken(method.MetadataTokenInternal);
  1177.                
  1178.                 if (method.DeclaringType == null)
  1179.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotImportGlobalFromDifferentModule"));
  1180.                
  1181.                 // method is defined in a different module
  1182.                 tr = GetTypeToken(method.DeclaringType).Token;
  1183.                 mr = InternalGetMemberRef(method.DeclaringType.Module, tr, method.MetadataTokenInternal);
  1184.             }
  1185.             else if (method is SymbolMethod) {
  1186.                 SymbolMethod symMethod = method as SymbolMethod;
  1187.                
  1188.                 if (symMethod.GetModule() == this)
  1189.                     return symMethod.GetToken();
  1190.                
  1191.                 // form the method token
  1192.                 return symMethod.GetToken(this);
  1193.             }
  1194.             else {
  1195.                 Type declaringType = method.DeclaringType;
  1196.                
  1197.                 // We need to get the TypeRef tokens
  1198.                 if (declaringType == null)
  1199.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotImportGlobalFromDifferentModule"));
  1200.                
  1201.                 if (declaringType.IsArray == true) {
  1202.                     // use reflection to build signature to work around the E_T_VAR problem in EEClass
  1203.                     ParameterInfo[] paramInfo = method.GetParameters();
  1204.                    
  1205.                     Type[] tt = new Type[paramInfo.Length];
  1206.                    
  1207.                     for (int i = 0; i < paramInfo.Length; i++)
  1208.                         tt[i] = paramInfo[i].ParameterType;
  1209.                    
  1210.                     return GetArrayMethodToken(declaringType, method.Name, method.CallingConvention, method.ReturnType, tt);
  1211.                 }
  1212.                 else if (method is RuntimeMethodInfo) {
  1213.                     tr = GetTypeToken(declaringType).Token;
  1214.                     mr = InternalGetMemberRefOfMethodInfo(tr, method.GetMethodHandle());
  1215.                 }
  1216.                 else {
  1217.                     // some user derived ConstructorInfo
  1218.                     // go through the slower code path, i.e. retrieve parameters and form signature helper.
  1219.                     ParameterInfo[] parameters = method.GetParameters();
  1220.                    
  1221.                     Type[] parameterTypes = new Type[parameters.Length];
  1222.                     Type[][] requiredCustomModifiers = new Type[parameterTypes.Length][];
  1223.                     Type[][] optionalCustomModifiers = new Type[parameterTypes.Length][];
  1224.                    
  1225.                     for (int i = 0; i < parameters.Length; i++) {
  1226.                         parameterTypes[i] = parameters[i].ParameterType;
  1227.                         requiredCustomModifiers[i] = parameters[i].GetRequiredCustomModifiers();
  1228.                         optionalCustomModifiers[i] = parameters[i].GetOptionalCustomModifiers();
  1229.                     }
  1230.                    
  1231.                     tr = GetTypeToken(method.ReflectedType).Token;
  1232.                    
  1233.                     SignatureHelper sigHelp;
  1234.                    
  1235.                     try {
  1236.                         sigHelp = SignatureHelper.GetMethodSigHelper(this, method.CallingConvention, method.ReturnType, method.ReturnParameter.GetRequiredCustomModifiers(), method.ReturnParameter.GetOptionalCustomModifiers(), parameterTypes, requiredCustomModifiers, optionalCustomModifiers);
  1237.                     }
  1238.                     catch (NotImplementedException) {
  1239.                         // Legacy code deriving from MethodInfo may not have implemented ReturnParameter.
  1240.                         sigHelp = SignatureHelper.GetMethodSigHelper(this, method.ReturnType, parameterTypes);
  1241.                     }
  1242.                    
  1243.                     int length;
  1244.                     byte[] sigBytes = sigHelp.InternalGetSignature(out length);
  1245.                     mr = InternalGetMemberRefFromSignature(tr, method.Name, sigBytes, length);
  1246.                 }
  1247.             }
  1248.            
  1249.             return new MethodToken(mr);
  1250.         }
  1251.        
  1252.         public MethodToken GetArrayMethodToken(Type arrayClass, string methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
  1253.         {
  1254.             if (Assembly.m_assemblyData.m_isSynchronized) {
  1255.                 lock (Assembly.m_assemblyData) {
  1256.                     return GetArrayMethodTokenNoLock(arrayClass, methodName, callingConvention, returnType, parameterTypes);
  1257.                 }
  1258.             }
  1259.             else {
  1260.                 return GetArrayMethodTokenNoLock(arrayClass, methodName, callingConvention, returnType, parameterTypes);
  1261.             }
  1262.         }
  1263.        
  1264.         private MethodToken GetArrayMethodTokenNoLock(Type arrayClass, string methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
  1265.         {
  1266.             CheckContext(returnType, arrayClass);
  1267.             CheckContext(parameterTypes);
  1268.            
  1269.             // Return a token for the MethodInfo for a method on an Array. This is primarily
  1270.             // used to get the LoadElementAddress method.
  1271.            
  1272.             Type baseType;
  1273.             int baseToken;
  1274.             int length;
  1275.            
  1276.             if (arrayClass == null)
  1277.                 throw new ArgumentNullException("arrayClass");
  1278.            
  1279.             if (methodName == null)
  1280.                 throw new ArgumentNullException("methodName");
  1281.            
  1282.             if (methodName.Length == 0)
  1283.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "methodName");
  1284.            
  1285.             if (arrayClass.IsArray == false)
  1286.                 throw new ArgumentException(Environment.GetResourceString("Argument_HasToBeArrayClass"));
  1287.            
  1288.             SignatureHelper sigHelp = SignatureHelper.GetMethodSigHelper(this, callingConvention, returnType, null, null, parameterTypes, null, null);
  1289.            
  1290.             byte[] sigBytes = sigHelp.InternalGetSignature(out length);
  1291.            
  1292.             // track the TypeRef of the array base class
  1293.             for (baseType = arrayClass; baseType.IsArray; baseType = baseType.GetElementType())
  1294.                 ;
  1295.             baseToken = GetTypeToken(baseType).Token;
  1296.            
  1297.             TypeToken typeSpec = GetTypeToken(arrayClass);
  1298.            
  1299.                 /* TODO: Remove */            return new MethodToken(nativeGetArrayMethodToken(typeSpec.Token, methodName, sigBytes, length, baseToken));
  1300.         }
  1301.        
  1302.         public MethodInfo GetArrayMethod(Type arrayClass, string methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
  1303.         {
  1304.             CheckContext(returnType, arrayClass);
  1305.             CheckContext(parameterTypes);
  1306.            
  1307.             // GetArrayMethod is useful when you have an array of a type whose definition has not been completed and
  1308.             // you want to access methods defined on Array. For example, you might define a type and want to define a
  1309.             // method that takes an array of the type as a parameter. In order to access the elements of the array,
  1310.             // you will need to call methods of the Array class.
  1311.            
  1312.             MethodToken token = GetArrayMethodToken(arrayClass, methodName, callingConvention, returnType, parameterTypes);
  1313.            
  1314.             return new SymbolMethod(this, token, arrayClass, methodName, callingConvention, returnType, parameterTypes);
  1315.         }
  1316.        
  1317.         [System.Runtime.InteropServices.ComVisible(true)]
  1318.         public MethodToken GetConstructorToken(ConstructorInfo con)
  1319.         {
  1320.             // Return a token for the ConstructorInfo relative to the Module.
  1321.             return InternalGetConstructorToken(con, false);
  1322.         }
  1323.        
  1324.         public FieldToken GetFieldToken(FieldInfo field)
  1325.         {
  1326.             if (Assembly.m_assemblyData.m_isSynchronized) {
  1327.                 lock (Assembly.m_assemblyData) {
  1328.                     return GetFieldTokenNoLock(field);
  1329.                 }
  1330.             }
  1331.             else {
  1332.                 return GetFieldTokenNoLock(field);
  1333.             }
  1334.         }
  1335.        
  1336.         private FieldToken GetFieldTokenNoLock(FieldInfo field)
  1337.         {
  1338.             int tr;
  1339.             int mr = 0;
  1340.            
  1341.             if (field == null) {
  1342.                 throw new ArgumentNullException("con");
  1343.             }
  1344.             else if (field is FieldBuilder) {
  1345.                 FieldBuilder fdBuilder = (FieldBuilder)field;
  1346.                
  1347.                 if (field.DeclaringType != null && field.DeclaringType.IsGenericType) {
  1348.                     int length;
  1349.                     byte[] sig = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length);
  1350.                     tr = InternalGetTypeSpecTokenWithBytes(sig, length);
  1351.                     mr = InternalGetMemberRef(this, tr, fdBuilder.GetToken().Token);
  1352.                 }
  1353.                 else if (fdBuilder.GetTypeBuilder().Module.Equals(this)) {
  1354.                     // field is defined in the same module
  1355.                     return fdBuilder.GetToken();
  1356.                 }
  1357.                 else {
  1358.                     // field is defined in a different module
  1359.                     if (field.DeclaringType == null) {
  1360.                         throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotImportGlobalFromDifferentModule"));
  1361.                     }
  1362.                     tr = GetTypeToken(field.DeclaringType).Token;
  1363.                     mr = InternalGetMemberRef(field.ReflectedType.Module, tr, fdBuilder.GetToken().Token);
  1364.                 }
  1365.             }
  1366.             else if (field is RuntimeFieldInfo) {
  1367.                 // FieldInfo is not an dynamic field
  1368.                
  1369.                 // We need to get the TypeRef tokens
  1370.                 if (field.DeclaringType == null) {
  1371.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotImportGlobalFromDifferentModule"));
  1372.                 }
  1373.                
  1374.                 if (field.DeclaringType != null && field.DeclaringType.IsGenericType) {
  1375.                     int length;
  1376.                     byte[] sig = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length);
  1377.                     tr = InternalGetTypeSpecTokenWithBytes(sig, length);
  1378.                     mr = InternalGetMemberRefOfFieldInfo(tr, field.DeclaringType.GetTypeHandleInternal(), field.MetadataTokenInternal);
  1379.                 }
  1380.                 else {
  1381.                     tr = GetTypeToken(field.DeclaringType).Token;
  1382.                     mr = InternalGetMemberRefOfFieldInfo(tr, field.DeclaringType.GetTypeHandleInternal(), field.MetadataTokenInternal);
  1383.                 }
  1384.             }
  1385.             else if (field is FieldOnTypeBuilderInstantiation) {
  1386.                 FieldInfo fb = ((FieldOnTypeBuilderInstantiation)field).FieldInfo;
  1387.                 int length;
  1388.                 byte[] sig = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length);
  1389.                 tr = InternalGetTypeSpecTokenWithBytes(sig, length);
  1390.                 mr = InternalGetMemberRef(fb.ReflectedType.Module, tr, fb.MetadataTokenInternal);
  1391.             }
  1392.             else {
  1393.                 // user defined FieldInfo
  1394.                 tr = GetTypeToken(field.ReflectedType).Token;
  1395.                
  1396.                 SignatureHelper sigHelp = SignatureHelper.GetFieldSigHelper(this);
  1397.                
  1398.                 sigHelp.AddArgument(field.FieldType, field.GetRequiredCustomModifiers(), field.GetOptionalCustomModifiers());
  1399.                
  1400.                 int length;
  1401.                 byte[] sigBytes = sigHelp.InternalGetSignature(out length);
  1402.                
  1403.                 mr = InternalGetMemberRefFromSignature(tr, field.Name, sigBytes, length);
  1404.             }
  1405.            
  1406.             return new FieldToken(mr, field.GetType());
  1407.         }
  1408.        
  1409.         public StringToken GetStringConstant(string str)
  1410.         {
  1411.             // Returns a token representing a String constant. If the string
  1412.             // value has already been defined, the existing token will be returned.
  1413.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  1414.             return new StringToken(InternalGetStringConstant(str));
  1415.         }
  1416.        
  1417.         public SignatureToken GetSignatureToken(SignatureHelper sigHelper)
  1418.         {
  1419.             // Define signature token given a signature helper. This will define a metadata
  1420.             // token for the signature described by SignatureHelper.
  1421.            
  1422.             int sigLength;
  1423.             byte[] sigBytes;
  1424.            
  1425.             if (sigHelper == null) {
  1426.                 throw new ArgumentNullException("sigHelper");
  1427.             }
  1428.            
  1429.             // get the signature in byte form
  1430.             sigBytes = sigHelper.InternalGetSignature(out sigLength);
  1431.             return new SignatureToken(TypeBuilder.InternalGetTokenFromSig(this, sigBytes, sigLength), this);
  1432.         }
  1433.         public SignatureToken GetSignatureToken(byte[] sigBytes, int sigLength)
  1434.         {
  1435.             byte[] localSigBytes = null;
  1436.            
  1437.             if (sigBytes != null) {
  1438.                 localSigBytes = new byte[sigBytes.Length];
  1439.                 Array.Copy(sigBytes, localSigBytes, sigBytes.Length);
  1440.             }
  1441.             return new SignatureToken(TypeBuilder.InternalGetTokenFromSig(this, localSigBytes, sigLength), this);
  1442.         }
  1443.        
  1444.         #endregion
  1445.        
  1446.         #region Other
  1447.         [System.Runtime.InteropServices.ComVisible(true)]
  1448.         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
  1449.         {
  1450.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  1451.             if (con == null)
  1452.                 throw new ArgumentNullException("con");
  1453.             if (binaryAttribute == null)
  1454.                 throw new ArgumentNullException("binaryAttribute");
  1455.            
  1456.                 // This is hard coding the module token to 1
  1457.             TypeBuilder.InternalCreateCustomAttribute(1, this.GetConstructorToken(con).Token, binaryAttribute, this, false);
  1458.         }
  1459.        
  1460.         public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
  1461.         {
  1462.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  1463.             if (customBuilder == null) {
  1464.                 throw new ArgumentNullException("customBuilder");
  1465.             }
  1466.            
  1467.             customBuilder.CreateCustomAttribute(this, 1);
  1468.             // This is hard coding the module token to 1
  1469.         }
  1470.        
  1471.         public ISymbolWriter GetSymWriter()
  1472.         {
  1473.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  1474.             return m_iSymWriter;
  1475.         }
  1476.        
  1477.         public ISymbolDocumentWriter DefineDocument(string url, Guid language, Guid languageVendor, Guid documentType)
  1478.         {
  1479.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  1480.             if (Assembly.m_assemblyData.m_isSynchronized) {
  1481.                 lock (Assembly.m_assemblyData) {
  1482.                     return DefineDocumentNoLock(url, language, languageVendor, documentType);
  1483.                 }
  1484.             }
  1485.             else {
  1486.                 return DefineDocumentNoLock(url, language, languageVendor, documentType);
  1487.             }
  1488.         }
  1489.        
  1490.         private ISymbolDocumentWriter DefineDocumentNoLock(string url, Guid language, Guid languageVendor, Guid documentType)
  1491.         {
  1492.             if (m_iSymWriter == null) {
  1493.                 // Cannot DefineDocument when it is not a debug module
  1494.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule"));
  1495.             }
  1496.            
  1497.             return m_iSymWriter.DefineDocument(url, language, languageVendor, documentType);
  1498.         }
  1499.        
  1500.         public void SetUserEntryPoint(MethodInfo entryPoint)
  1501.         {
  1502.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  1503.             if (Assembly.m_assemblyData.m_isSynchronized) {
  1504.                 lock (Assembly.m_assemblyData) {
  1505.                     SetUserEntryPointNoLock(entryPoint);
  1506.                 }
  1507.             }
  1508.             else {
  1509.                 SetUserEntryPointNoLock(entryPoint);
  1510.             }
  1511.         }
  1512.        
  1513.         private void SetUserEntryPointNoLock(MethodInfo entryPoint)
  1514.         {
  1515.             // Set the user entry point. Compiler may generate startup stub before calling user main.
  1516.             // The startup stub will be the entry point. While the user "main" will be the user entry
  1517.             // point so that debugger will not step into the compiler entry point.
  1518.            
  1519.             if (entryPoint == null) {
  1520.                 throw new ArgumentNullException("entryPoint");
  1521.             }
  1522.            
  1523.             if (m_iSymWriter == null) {
  1524.                 // Cannot set entry point when it is not a debug module
  1525.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule"));
  1526.             }
  1527.            
  1528.             if (entryPoint.DeclaringType != null) {
  1529.                 if (entryPoint.Module != this) {
  1530.                     // you cannot pass in a MethodInfo that is not contained by this ModuleBuilder
  1531.                     throw new InvalidOperationException(Environment.GetResourceString("Argument_NotInTheSameModuleBuilder"));
  1532.                 }
  1533.             }
  1534.             else {
  1535.                 MethodBuilder mb = entryPoint as MethodBuilder;
  1536.                 if (mb != null && mb.GetModule() != this) {
  1537.                     // you cannot pass in a MethodInfo that is not contained by this ModuleBuilder
  1538.                     throw new InvalidOperationException(Environment.GetResourceString("Argument_NotInTheSameModuleBuilder"));
  1539.                 }
  1540.             }
  1541.            
  1542.             // get the metadata token value and create the SymbolStore's token value class
  1543.             SymbolToken tkMethod = new SymbolToken(GetMethodToken(entryPoint).Token);
  1544.            
  1545.             // set the UserEntryPoint
  1546.             m_iSymWriter.SetUserEntryPoint(tkMethod);
  1547.         }
  1548.        
  1549.         public void SetSymCustomAttribute(string name, byte[] data)
  1550.         {
  1551.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  1552.             if (Assembly.m_assemblyData.m_isSynchronized) {
  1553.                 lock (Assembly.m_assemblyData) {
  1554.                     SetSymCustomAttributeNoLock(name, data);
  1555.                 }
  1556.             }
  1557.             else {
  1558.                 SetSymCustomAttributeNoLock(name, data);
  1559.             }
  1560.         }
  1561.        
  1562.         private void SetSymCustomAttributeNoLock(string name, byte[] data)
  1563.         {
  1564.             if (m_iSymWriter == null) {
  1565.                 // Cannot SetSymCustomAttribute when it is not a debug module
  1566.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule"));
  1567.             }
  1568.            
  1569.            
  1570.            
  1571.             //SymbolToken tk = new SymbolToken();
  1572.             //m_iSymWriter.SetSymAttribute(tk, name, data);
  1573.         }
  1574.        
  1575.         public bool IsTransient()
  1576.         {
  1577.             return m_moduleData.IsTransient();
  1578.         }
  1579.        
  1580.         #endregion
  1581.        
  1582.         #endregion
  1583.        
  1584.         void _ModuleBuilder.GetTypeInfoCount(out uint pcTInfo)
  1585.         {
  1586.             throw new NotImplementedException();
  1587.         }
  1588.        
  1589.         void _ModuleBuilder.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  1590.         {
  1591.             throw new NotImplementedException();
  1592.         }
  1593.        
  1594.         void _ModuleBuilder.GetIDsOfNames(        [In()]
  1595. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  1596.         {
  1597.             throw new NotImplementedException();
  1598.         }
  1599.        
  1600.         void _ModuleBuilder.Invoke(uint dispIdMember,         [In()]
  1601. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  1602.         {
  1603.             throw new NotImplementedException();
  1604.         }
  1605.     }
  1606. }

Developer Fusion