We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

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

SSCLI
  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. // ==--==
  16. namespace System.Reflection.Emit
  17. {
  18.     using System.Runtime.InteropServices;
  19.     using System;
  20.     using IList = System.Collections.IList;
  21.     using ArrayList = System.Collections.ArrayList;
  22.     using CultureInfo = System.Globalization.CultureInfo;
  23.     using ResourceWriter = System.Resources.ResourceWriter;
  24.     using IResourceWriter = System.Resources.IResourceWriter;
  25.     using System.Diagnostics.SymbolStore;
  26.     using System.Reflection;
  27.     using System.Diagnostics;
  28.     using System.IO;
  29.     using System.Security;
  30.     using System.Security.Permissions;
  31.     using System.Runtime.Serialization;
  32.     using System.Text;
  33.     using System.Threading;
  34.     using System.Runtime.Versioning;
  35.    
  36.     // deliberately not [serializable]
  37.     [HostProtection(MayLeakOnAbort = true)]
  38.     [ClassInterface(ClassInterfaceType.None)]
  39.     [ComDefaultInterface(typeof(_ModuleBuilder))]
  40.     [System.Runtime.InteropServices.ComVisible(true)]
  41.     public class ModuleBuilder : Module, _ModuleBuilder
  42.     {
  43.         #region Internal Static Members
  44.         static internal string UnmangleTypeName(string typeName)
  45.         {
  46.             // Gets the original type name, without '+' name mangling.
  47.            
  48.             int i = typeName.Length - 1;
  49.             while (true) {
  50.                 i = typeName.LastIndexOf('+', i);
  51.                 if (i == -1)
  52.                     break;
  53.                
  54.                 bool evenSlashes = true;
  55.                 int iSlash = i;
  56.                 while (typeName[--iSlash] == '\\')
  57.                     evenSlashes = !evenSlashes;
  58.                
  59.                 // Even number of slashes means this '+' is a name separator
  60.                 if (evenSlashes)
  61.                     break;
  62.                
  63.                 i = iSlash;
  64.             }
  65.            
  66.             return typeName.Substring(i + 1);
  67.         }
  68.        
  69.         #endregion
  70.        
  71.         #region Private Data Members
  72.         // WARNING!! WARNING!!
  73.         // ModuleBuilder should not contain any data members as its reflectbase is the same as Module.
  74.         #endregion
  75.        
  76.         #region Constructor
  77.         private ModuleBuilder()
  78.         {
  79.         }
  80.        
  81.         #endregion
  82.        
  83.         #region Private Members
  84.         private Type GetType(string strFormat, Type baseType)
  85.         {
  86.             // This function takes a string to describe the compound type, such as "[,][]", and a baseType.
  87.            
  88.             if (strFormat == null || strFormat.Equals(String.Empty)) {
  89.                 return baseType;
  90.             }
  91.            
  92.             // convert the format string to byte array and then call FormCompoundType
  93.             char[] bFormat = strFormat.ToCharArray();
  94.             return SymbolType.FormCompoundType(bFormat, baseType, 0);
  95.            
  96.         }
  97.        
  98.        
  99.         internal void CheckContext(params Type[][] typess)
  100.         {
  101.             ((AssemblyBuilder)Assembly).CheckContext(typess);
  102.         }
  103.         internal void CheckContext(params Type[] types)
  104.         {
  105.             ((AssemblyBuilder)Assembly).CheckContext(types);
  106.         }
  107.         #endregion
  108.        
  109.         #region Internal Members
  110.         internal virtual Type FindTypeBuilderWithName(string strTypeName, bool ignoreCase)
  111.         {
  112.             int size = m_TypeBuilderList.Count;
  113.             int i;
  114.             Type typeTemp = null;
  115.            
  116.             for (i = 0; i < size; i++) {
  117.                 typeTemp = (Type)m_TypeBuilderList[i];
  118.                 if (ignoreCase == true) {
  119.                     if (String.Compare(typeTemp.FullName, strTypeName, ((ignoreCase) ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) == 0)
  120.                         break;
  121.                 }
  122.                 else {
  123.                     if (typeTemp.FullName.Equals(strTypeName))
  124.                         break;
  125.                 }
  126.             }
  127.             if (i == size)
  128.                 typeTemp = null;
  129.            
  130.             return typeTemp;
  131.         }
  132.        
  133.         internal Type GetRootElementType(Type type)
  134.         {
  135.             // This function will walk compound type to the inner most BaseType. Such as returning int for "ptr[] int".
  136.             if (type.IsByRef == false && type.IsPointer == false && type.IsArray == false)
  137.                 return type;
  138.            
  139.             return GetRootElementType(type.GetElementType());
  140.         }
  141.        
  142.         internal void SetEntryPoint(MethodInfo entryPoint)
  143.         {
  144.             // Sets the entry point of the module to be a given method. If no entry point
  145.             // is specified, calling EmitPEFile will generate a dll.
  146.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  147.             m_EntryPoint = GetMethodToken(entryPoint);
  148.         }
  149.        
  150.        
  151.         internal void PreSave(string fileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  152.         {
  153.             if (Assembly.m_assemblyData.m_isSynchronized) {
  154.                 lock (Assembly.m_assemblyData) {
  155.                     PreSaveNoLock(fileName, portableExecutableKind, imageFileMachine);
  156.                 }
  157.             }
  158.             else {
  159.                 PreSaveNoLock(fileName, portableExecutableKind, imageFileMachine);
  160.             }
  161.         }
  162.        
  163.         private void PreSaveNoLock(string fileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  164.         {
  165.             // This is a helper called by AssemblyBuilder save to presave information for the persistable modules.
  166.             object item;
  167.             TypeBuilder typeBuilder;
  168.             if (m_moduleData.m_isSaved == true) {
  169.                 // can only save once
  170.                 throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("InvalidOperation_ModuleHasBeenSaved"), m_moduleData.m_strModuleName));
  171.             }
  172.            
  173.             if (m_moduleData.m_fGlobalBeenCreated == false && m_moduleData.m_fHasGlobal == true)
  174.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_GlobalFunctionNotBaked"));
  175.            
  176.             int size = m_TypeBuilderList.Count;
  177.             for (int i = 0; i < size; i++) {
  178.                 item = m_TypeBuilderList[i];
  179.                 if (item is TypeBuilder) {
  180.                     typeBuilder = (TypeBuilder)item;
  181.                 }
  182.                 else {
  183.                     EnumBuilder enumBuilder = (EnumBuilder)item;
  184.                     typeBuilder = enumBuilder.m_typeBuilder;
  185.                 }
  186.                 if (typeBuilder.m_hasBeenCreated == false && typeBuilder.m_isHiddenType == false) {
  187.                     // cannot save to PE file without creating all of the types first
  188.                     throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("NotSupported_NotAllTypesAreBaked"), typeBuilder.FullName));
  189.                 }
  190.             }
  191.            
  192.             InternalPreSavePEFile((int)portableExecutableKind, (int)imageFileMachine);
  193.         }
  194.        
  195.         internal void Save(string fileName, bool isAssemblyFile, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  196.         {
  197.             if (Assembly.m_assemblyData.m_isSynchronized) {
  198.                 lock (Assembly.m_assemblyData) {
  199.                     SaveNoLock(fileName, isAssemblyFile, portableExecutableKind, imageFileMachine);
  200.                 }
  201.             }
  202.             else {
  203.                 SaveNoLock(fileName, isAssemblyFile, portableExecutableKind, imageFileMachine);
  204.             }
  205.         }
  206.        
  207.         private void SaveNoLock(string fileName, bool isAssemblyFile, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  208.         {
  209.             // This is a helper called by AssemblyBuilder save to save information for the persistable modules.
  210.             if (m_moduleData.m_embeddedRes != null) {
  211.                 // There are embedded resources for this module
  212.                 ResWriterData resWriter;
  213.                 int iCount;
  214.                
  215.                 // Set the number of resources embedded in this PE
  216.                 for (resWriter = m_moduleData.m_embeddedRes,iCount = 0; resWriter != null; resWriter = resWriter.m_nextResWriter,iCount++)
  217.                     ;
  218.                 InternalSetResourceCounts(iCount);
  219.                
  220.                 // Add each resource content into the to be saved PE file
  221.                 for (resWriter = m_moduleData.m_embeddedRes; resWriter != null; resWriter = resWriter.m_nextResWriter) {
  222.                     if (resWriter.m_resWriter != null)
  223.                         resWriter.m_resWriter.Generate();
  224.                    
  225.                     byte[] resBytes = new byte[resWriter.m_memoryStream.Length];
  226.                     resWriter.m_memoryStream.Flush();
  227.                     resWriter.m_memoryStream.Position = 0;
  228.                     resWriter.m_memoryStream.Read(resBytes, 0, resBytes.Length);
  229.                     InternalAddResource(resWriter.m_strName, resBytes, resBytes.Length, m_moduleData.m_tkFile, (int)resWriter.m_attribute, (int)portableExecutableKind, (int)imageFileMachine);
  230.                 }
  231.             }
  232.            
  233.            
  234.             if (isAssemblyFile)
  235.                 InternalSavePEFile(fileName, m_EntryPoint, (int)Assembly.m_assemblyData.m_peFileKind, true);
  236.             else
  237.                 InternalSavePEFile(fileName, m_EntryPoint, (int)PEFileKinds.Dll, false);
  238.             m_moduleData.m_isSaved = true;
  239.         }
  240.        
  241.         internal int GetTypeRefNested(Type type, Module refedModule, string strRefedModuleFileName)
  242.         {
  243.             // This function will generate correct TypeRef token for top level type and nested type.
  244.            
  245.             Type enclosingType = type.DeclaringType;
  246.             int tkResolution = 0;
  247.             string typeName = type.FullName;
  248.            
  249.             if (enclosingType != null) {
  250.                 tkResolution = GetTypeRefNested(enclosingType, refedModule, strRefedModuleFileName);
  251.                 typeName = UnmangleTypeName(typeName);
  252.             }
  253.            
  254.             return InternalGetTypeToken(typeName, refedModule, strRefedModuleFileName, tkResolution);
  255.         }
  256.        
  257.         internal MethodToken InternalGetConstructorToken(ConstructorInfo con, bool usingRef)
  258.         {
  259.             // Helper to get constructor token. If usingRef is true, we will never use the def token
  260.            
  261.            
  262.             int tr;
  263.             int mr = 0;
  264.            
  265.             if (con == null)
  266.                 throw new ArgumentNullException("con");
  267.            
  268.             if (con is ConstructorBuilder) {
  269.                 ConstructorBuilder conBuilder = con as ConstructorBuilder;
  270.                 if (usingRef == false && conBuilder.ReflectedType.Module.Equals(this))
  271.                     return conBuilder.GetToken();
  272.                
  273.                 // constructor is defined in a different module
  274.                 tr = GetTypeToken(con.ReflectedType).Token;
  275.                 mr = InternalGetMemberRef(con.ReflectedType.Module, tr, conBuilder.GetToken().Token);
  276.             }
  277.             else if (con is ConstructorOnTypeBuilderInstantiation) {
  278.                 ConstructorOnTypeBuilderInstantiation conBuilder = con as ConstructorOnTypeBuilderInstantiation;
  279.                 if (usingRef == true)
  280.                     throw new InvalidOperationException();
  281.                
  282.                 tr = GetTypeToken(con.DeclaringType).Token;
  283.                 mr = InternalGetMemberRef(con.DeclaringType.Module, tr, conBuilder.m_ctor.MetadataTokenInternal);
  284.             }
  285.             else if (con is RuntimeConstructorInfo && con.ReflectedType.IsArray == false) {
  286.                 // constructor is not a dynamic field
  287.                 // We need to get the TypeRef tokens
  288.                
  289.                 tr = GetTypeToken(con.ReflectedType).Token;
  290.                 mr = InternalGetMemberRefOfMethodInfo(tr, con.GetMethodHandle());
  291.             }
  292.             else {
  293.                 // some user derived ConstructorInfo
  294.                 // go through the slower code path, i.e. retrieve parameters and form signature helper.
  295.                 ParameterInfo[] parameters = con.GetParameters();
  296.                 Type[] parameterTypes = new Type[parameters.Length];
  297.                 Type[][] requiredCustomModifiers = new Type[parameterTypes.Length][];
  298.                 Type[][] optionalCustomModifiers = new Type[parameterTypes.Length][];
  299.                
  300.                 for (int i = 0; i < parameters.Length; i++) {
  301.                     parameterTypes[i] = parameters[i].ParameterType;
  302.                     requiredCustomModifiers[i] = parameters[i].GetRequiredCustomModifiers();
  303.                     optionalCustomModifiers[i] = parameters[i].GetOptionalCustomModifiers();
  304.                 }
  305.                
  306.                 tr = GetTypeToken(con.ReflectedType).Token;
  307.                
  308.                 SignatureHelper sigHelp = SignatureHelper.GetMethodSigHelper(this, con.CallingConvention, null, null, null, parameterTypes, requiredCustomModifiers, optionalCustomModifiers);
  309.                 int length;
  310.                 byte[] sigBytes = sigHelp.InternalGetSignature(out length);
  311.                
  312.                 mr = InternalGetMemberRefFromSignature(tr, con.Name, sigBytes, length);
  313.             }
  314.            
  315.             return new MethodToken(mr);
  316.         }
  317.        
  318.         internal void Init(string strModuleName, string strFileName, ISymbolWriter writer)
  319.         {
  320.             m_moduleData = new ModuleBuilderData(this, strModuleName, strFileName);
  321.             m_TypeBuilderList = new ArrayList();
  322.             m_iSymWriter = writer;
  323.            
  324.             if (writer != null) {
  325.                 // Set the underlying writer for the managed writer
  326.                 // that we're using. Note that this function requires
  327.                 // unmanaged code access.
  328.                 new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
  329.                 writer.SetUnderlyingWriter(m_pInternalSymWriter);
  330.             }
  331.         }
  332.        
  333.         [ResourceExposure(ResourceScope.Machine)]
  334.         [ResourceConsumption(ResourceScope.Machine)]
  335.         internal void DefineUnmanagedResourceFileInternal(string resourceFileName)
  336.         {
  337.             // Shouldn't have resource bytes, but a previous file is OK, because assemblyBuilder.Save
  338.             // creates then deletes a temp file.
  339.             if (m_moduleData.m_resourceBytes != null)
  340.                 throw new ArgumentException(Environment.GetResourceString("Argument_NativeResourceAlreadyDefined"));
  341.            
  342.             if (resourceFileName == null)
  343.                 throw new ArgumentNullException("resourceFileName");
  344.            
  345.             if (m_moduleData.m_fHasExplicitUnmanagedResource)
  346.                 throw new ArgumentException(Environment.GetResourceString("Argument_NativeResourceAlreadyDefined"));
  347.            
  348.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  349.            
  350.             // Check caller has the right to read the file.
  351.             string strFullFileName;
  352.             strFullFileName = Path.GetFullPath(resourceFileName);
  353.             new FileIOPermission(FileIOPermissionAccess.Read, strFullFileName).Demand();
  354.            
  355.             new EnvironmentPermission(PermissionState.Unrestricted).Assert();
  356.             try {
  357.                 if (File.Exists(resourceFileName) == false)
  358.                     throw new FileNotFoundException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("IO.FileNotFound_FileName"), resourceFileName), resourceFileName);
  359.             }
  360.             finally {
  361.                 CodeAccessPermission.RevertAssert();
  362.             }
  363.            
  364.             m_moduleData.m_strResourceFileName = strFullFileName;
  365.         }
  366.        
  367.         #endregion
  368.        
  369.         #region Module Overrides
  370.         public override Type[] GetTypes()
  371.         {
  372.             int size = m_TypeBuilderList.Count;
  373.             Type[] moduleTypes = new Type[size];
  374.             TypeBuilder tmpTypeBldr;
  375.             int filtered = 0;
  376.            
  377.             for (int i = 0; i < size; i++) {
  378.                 EnumBuilder enumBldr = m_TypeBuilderList[i] as EnumBuilder;
  379.                 tmpTypeBldr = m_TypeBuilderList[i] as TypeBuilder;
  380.                 if (enumBldr != null)
  381.                     tmpTypeBldr = enumBldr.m_typeBuilder;
  382.                
  383.                 if (tmpTypeBldr != null) {
  384.                     if (tmpTypeBldr.m_hasBeenCreated)
  385.                         moduleTypes[i] = tmpTypeBldr.UnderlyingSystemType;
  386.                     else
  387.                         moduleTypes[i] = tmpTypeBldr;
  388.                 }
  389.                 else {
  390.                     // RuntimeType case: This will happen in TlbImp.
  391.                     moduleTypes[i] = (Type)m_TypeBuilderList[i];
  392.                 }
  393.             }
  394.            
  395.             if (filtered > 0) {
  396.                 Type[] filteredTypes = new Type[size - filtered];
  397.                 int src;
  398.                 int dst;
  399.                 for (src = 0,dst = 0; src < size; src++) {
  400.                     if (moduleTypes[src] != null) {
  401.                         filteredTypes[dst] = moduleTypes[src];
  402.                         dst++;
  403.                     }
  404.                 }
  405.                 moduleTypes = filteredTypes;
  406.             }
  407.            
  408.             return moduleTypes;
  409.         }
  410.        
  411.         [System.Runtime.InteropServices.ComVisible(true)]
  412.         public override Type GetType(string className)
  413.         {
  414.             return GetType(className, false, false);
  415.         }
  416.        
  417.         [System.Runtime.InteropServices.ComVisible(true)]
  418.         public override Type GetType(string className, bool ignoreCase)
  419.         {
  420.             return GetType(className, false, ignoreCase);
  421.         }
  422.        
  423.         [System.Runtime.InteropServices.ComVisible(true)]
  424.         public override Type GetType(string className, bool throwOnError, bool ignoreCase)
  425.         {
  426.             if (Assembly.m_assemblyData.m_isSynchronized) {
  427.                 lock (Assembly.m_assemblyData) {
  428.                     return GetTypeNoLock(className, throwOnError, ignoreCase);
  429.                 }
  430.             }
  431.             else {
  432.                 return GetTypeNoLock(className, throwOnError, ignoreCase);
  433.             }
  434.         }
  435.        
  436.         private Type GetTypeNoLock(string className, bool throwOnError, bool ignoreCase)
  437.         {
  438.             // public API to to a type. The reason that we need this function override from module
  439.             // is because clients might need to get foo[] when foo is being built. For example, if
  440.             // foo class contains a data member of type foo[].
  441.             // This API first delegate to the Module.GetType implementation. If succeeded, great!
  442.             // If not, we have to look up the current module to find the TypeBuilder to represent the base
  443.             // type and form the Type object for "foo[,]".
  444.            
  445.             // Module.GetType() will verify className.
  446.             Type baseType = base.GetType(className, throwOnError, ignoreCase);
  447.             if (baseType != null)
  448.                 return baseType;
  449.            
  450.             // Now try to see if we contain a TypeBuilder for this type or not.
  451.             // Might have a compound type name, indicated via an unescaped
  452.             // '[', '*' or '&'. Split the name at this point.
  453.             string baseName = null;
  454.             string parameters = null;
  455.             int startIndex = 0;
  456.            
  457.             while (startIndex <= className.Length) {
  458.                 // Are there any possible special characters left?
  459.                 int i = className.IndexOfAny(new char[] {'[', '*', '&'}, startIndex);
  460.                 if (i == -1) {
  461.                     // No, type name is simple.
  462.                     baseName = className;
  463.                     parameters = null;
  464.                     break;
  465.                 }
  466.                
  467.                 // Found a potential special character, but it might be escaped.
  468.                 int slashes = 0;
  469.                 for (int j = i - 1; j >= 0 && className[j] == '\\'; j--)
  470.                     slashes++;
  471.                
  472.                 // Odd number of slashes indicates escaping.
  473.                 if (slashes % 2 == 1) {
  474.                     startIndex = i + 1;
  475.                     continue;
  476.                 }
  477.                
  478.                 // Found the end of the base type name.
  479.                 baseName = className.Substring(0, i);
  480.                 parameters = className.Substring(i);
  481.                 break;
  482.             }
  483.            
  484.             // If we didn't find a basename yet, the entire class name is
  485.             // the base name and we don't have a composite type.
  486.             if (baseName == null) {
  487.                 baseName = className;
  488.                 parameters = null;
  489.             }
  490.            
  491.             baseName = baseName.Replace("\\\\", "\\").Replace("\\[", "[").Replace("\\*", "*").Replace("\\&", "&");
  492.            
  493.             if (parameters != null) {
  494.                 // try to see if reflection can find the base type. It can be such that reflection
  495.                 // does not support the complex format string yet!
  496.                
  497.                 baseType = base.GetType(baseName, false, ignoreCase);
  498.             }
  499.            
  500.             if (baseType == null) {
  501.                 // try to find it among the unbaked types.
  502.                 // starting with the current module first of all.
  503.                 baseType = FindTypeBuilderWithName(baseName, ignoreCase);
  504.                 if (baseType == null && Assembly is AssemblyBuilder) {
  505.                     // now goto Assembly level to find the type.
  506.                     int size;
  507.                     ArrayList modList;
  508.                    
  509.                     modList = Assembly.m_assemblyData.m_moduleBuilderList;
  510.                     size = modList.Count;
  511.                     for (int i = 0; i < size && baseType == null; i++) {
  512.                         ModuleBuilder mBuilder = (ModuleBuilder)modList[i];
  513.                         baseType = mBuilder.FindTypeBuilderWithName(baseName, ignoreCase);
  514.                     }
  515.                 }
  516.                 if (baseType == null)
  517.                     return null;
  518.             }
  519.            
  520.             if (parameters == null)
  521.                 return baseType;
  522.            
  523.             return GetType(parameters, baseType);
  524.         }
  525.        
  526.         public override string FullyQualifiedName {
  527.             [ResourceExposure(ResourceScope.Machine)]
  528.             [ResourceConsumption(ResourceScope.Machine)]
  529.             get {
  530.                 string fullyQualifiedName = m_moduleData.m_strFileName;
  531.                 if (fullyQualifiedName == null)
  532.                     return null;
  533.                 if (Assembly.m_assemblyData.m_strDir != null) {
  534.                     fullyQualifiedName = Path.Combine(Assembly.m_assemblyData.m_strDir, fullyQualifiedName);
  535.                     fullyQualifiedName = Path.GetFullPath(fullyQualifiedName);
  536.                 }
  537.                
  538.                 if (Assembly.m_assemblyData.m_strDir != null && fullyQualifiedName != null) {
  539.                     new FileIOPermission(FileIOPermissionAccess.PathDiscovery, fullyQualifiedName).Demand();
  540.                 }
  541.                
  542.                 return fullyQualifiedName;
  543.             }
  544.         }
  545.        
  546.         #endregion
  547.        
  548.         #region Public Members
  549.        
  550.         #region Define Type
  551.         public TypeBuilder DefineType(string name)
  552.         {
  553.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  554.             if (Assembly.m_assemblyData.m_isSynchronized) {
  555.                 lock (Assembly.m_assemblyData) {
  556.                     return DefineTypeNoLock(name);
  557.                 }
  558.             }
  559.             else {
  560.                 return DefineTypeNoLock(name);
  561.             }
  562.         }
  563.        
  564.         private TypeBuilder DefineTypeNoLock(string name)
  565.         {
  566.             TypeBuilder typeBuilder;
  567.             typeBuilder = new TypeBuilder(name, TypeAttributes.NotPublic, null, null, this, PackingSize.Unspecified, null);
  568.             m_TypeBuilderList.Add(typeBuilder);
  569.             return typeBuilder;
  570.         }
  571.        
  572.         public TypeBuilder DefineType(string name, TypeAttributes attr)
  573.         {
  574.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  575.             if (Assembly.m_assemblyData.m_isSynchronized) {
  576.                 lock (Assembly.m_assemblyData) {
  577.                     return DefineTypeNoLock(name, attr);
  578.                 }
  579.             }
  580.             else {
  581.                 return DefineTypeNoLock(name, attr);
  582.             }
  583.         }
  584.        
  585.         private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr)
  586.         {
  587.             TypeBuilder typeBuilder;
  588.             typeBuilder = new TypeBuilder(name, attr, null, null, this, PackingSize.Unspecified, null);
  589.             m_TypeBuilderList.Add(typeBuilder);
  590.             return typeBuilder;
  591.         }
  592.        
  593.         public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent)
  594.         {
  595.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  596.             if (Assembly.m_assemblyData.m_isSynchronized) {
  597.                 lock (Assembly.m_assemblyData) {
  598.                     return DefineTypeNoLock(name, attr, parent);
  599.                 }
  600.             }
  601.             else {
  602.                 return DefineTypeNoLock(name, attr, parent);
  603.             }
  604.         }
  605.        
  606.         private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr, Type parent)
  607.         {
  608.             CheckContext(parent);
  609.            
  610.             TypeBuilder typeBuilder;
  611.            
  612.             typeBuilder = new TypeBuilder(name, attr, parent, null, this, PackingSize.Unspecified, null);
  613.             m_TypeBuilderList.Add(typeBuilder);
  614.             return typeBuilder;
  615.         }
  616.        
  617.         public TypeBuilder DefineType(string name, TypeAttributes attr, Type parent, int typesize)
  618.         {
  619.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  620.             if (Assembly.m_assemblyData.m_isSynchronized) {
  621.                 lock (Assembly.m_assemblyData) {
  622.                     return DefineTypeNoLock(name, attr, parent, typesize);
  623.                 }
  624.             }
  625.             else {
  626.