public DynamicAssembly()
        {
            int assemblyNumber = Interlocked.Increment(ref _assemblyCount);
            _assemblyName = new AssemblyName {
                Name = String.Format("Quokka.DynamicAssembly.N{0}", assemblyNumber)
            };
            string moduleName = AssemblyName.Name;
            _dynamicClassNamespace = AssemblyName.Name;

            if (CreateFiles)
            {
                _assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(
                    AssemblyName, AssemblyBuilderAccess.RunAndSave);

                // Add a debuggable attribute to the assembly saying to disable optimizations
                // See http://blogs.msdn.com/rmbyers/archive/2005/06/26/432922.aspx
                Type daType = typeof (DebuggableAttribute);
                ConstructorInfo daCtor = daType.GetConstructor(new[] {typeof (bool), typeof (bool)});
                var daBuilder = new CustomAttributeBuilder(daCtor, new object[] {true, true});
                _assemblyBuilder.SetCustomAttribute(daBuilder);

                _moduleBuilder = _assemblyBuilder.DefineDynamicModule(moduleName);
                _canSave = true;
            }
            else
            {
                _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess.Run);
                _moduleBuilder = _assemblyBuilder.DefineDynamicModule(moduleName);
            }
        }

            public CustAttr(CustomAttributeBuilder customBuilder)
            {
                if (customBuilder == null)
                    throw new ArgumentNullException("customBuilder");

                m_customBuilder = customBuilder;
            }

        private Type GenerateAnonymousType(ModuleBuilder dynamicTypeModule)
        {
            var dynamicType = dynamicTypeModule.DefineType(ClassName, TypeAttributes.BeforeFieldInit | TypeAttributes.Sealed);
            var builderArray = dynamicType.DefineGenericParameters(GenericClassParameterNames);
            var fields = new List<FieldBuilder>();
            for (var i = 0; i < FieldNames.Length; i++)
            {
                var item = dynamicType.DefineField(FieldNames[i], builderArray[i], FieldAttributes.InitOnly | FieldAttributes.Private);
                var type = typeof(DebuggerBrowsableAttribute);
                var customBuilder = new CustomAttributeBuilder(type.GetConstructor(new Type[] { typeof(DebuggerBrowsableState) }), new object[] { DebuggerBrowsableState.Never });
                item.SetCustomAttribute(customBuilder);
                fields.Add(item);
            }
            var list2 = new List<PropertyBuilder>();
            for (var j = 0; j < PropertyNames.Length; j++)
            {
                var builder4 = GenerateProperty(dynamicType, PropertyNames[j], fields[j]);
//                var type = typeof(JsonPropertyAttribute);
//                var customBuilder2 = new CustomAttributeBuilder(type.GetConstructor(new Type[0]), new object[0]);
//                builder4.SetCustomAttribute(customBuilder2);
                list2.Add(builder4);
            }
            GenerateClassAttributes(dynamicType, PropertyNames);
            GenerateConstructor(dynamicType, PropertyNames, fields);
            GenerateEqualsMethod(dynamicType, fields.ToArray());
            GenerateGetHashCodeMethod(dynamicType, fields.ToArray());
            GenerateToStringMethod(dynamicType, PropertyNames, fields.ToArray());
            return dynamicType.CreateType().MakeGenericType(PropertyTypes);
        }

        protected RegexDynamicModule(int moduleNum, AssemblyName an, CustomAttributeBuilder[] attribs, String resourceFile) {
            new ReflectionPermission(PermissionState.Unrestricted).Assert();
            try {
                if (an == null) {
                    an = new AssemblyName();
                    an.Name = "RegexAssembly" +  AppDomain.CurrentDomain.GetHashCode().ToString() + "_" + moduleNum.ToString();
                    _assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
                }
                else {
                    _assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.RunAndSave);
                }

                _module = _assembly.DefineDynamicModule(an.Name + ".dll");

                if (attribs != null) {
                    for (int i=0; i<attribs.Length; i++) {
                        _assembly.SetCustomAttribute(attribs[i]);
                    }
                }

                if (resourceFile != null) {
		    // unmanaged resources are not supported
                    throw new ArgumentOutOfRangeException("resourceFile");
	        }
            }
            finally {
                CodeAccessPermission.RevertAssert();
            }
        }

 internal RegexTypeCompiler(AssemblyName an, CustomAttributeBuilder[] attribs, string resourceFile)
 {
     new ReflectionPermission(PermissionState.Unrestricted).Assert();
     try
     {
         List<CustomAttributeBuilder> assemblyAttributes = new List<CustomAttributeBuilder>();
         CustomAttributeBuilder item = new CustomAttributeBuilder(typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
         assemblyAttributes.Add(item);
         CustomAttributeBuilder builder2 = new CustomAttributeBuilder(typeof(SecurityRulesAttribute).GetConstructor(new Type[] { typeof(SecurityRuleSet) }), new object[] { SecurityRuleSet.Level2 });
         assemblyAttributes.Add(builder2);
         this._assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.RunAndSave, assemblyAttributes);
         this._module = this._assembly.DefineDynamicModule(an.Name + ".dll");
         if (attribs != null)
         {
             for (int i = 0; i < attribs.Length; i++)
             {
                 this._assembly.SetCustomAttribute(attribs[i]);
             }
         }
         if (resourceFile != null)
         {
             this._assembly.DefineUnmanagedResource(resourceFile);
         }
     }
     finally
     {
         CodeAccessPermission.RevertAssert();
     }
 }

		public static void Main()
		{			
			AssemblyName assemblyName = new AssemblyName();
			assemblyName.Name = "DynamicllyGeneratedAssembly";
			AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
			
			ConstructorInfo daCtor = typeof(DebuggableAttribute).GetConstructor(new Type[] { typeof(DebuggableAttribute.DebuggingModes) });
			CustomAttributeBuilder daBuilder = new CustomAttributeBuilder(daCtor, new object[] { DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.Default });
			assemblyBuilder.SetCustomAttribute(daBuilder);
			
			ModuleBuilder module = assemblyBuilder.DefineDynamicModule("DynamicllyGeneratedModule.exe", true);
			
			ISymbolDocumentWriter doc = module.DefineDocument(@"Source.txt", Guid.Empty, Guid.Empty, Guid.Empty);
			TypeBuilder typeBuilder = module.DefineType("DynamicllyGeneratedType", TypeAttributes.Public | TypeAttributes.Class);
			MethodBuilder methodbuilder = typeBuilder.DefineMethod("Main", MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.Public, typeof(void), new Type[] { typeof(string[]) });
			ILGenerator ilGenerator = methodbuilder.GetILGenerator();
			
			ilGenerator.MarkSequencePoint(doc, 1, 1, 1, 100);
			ilGenerator.Emit(OpCodes.Ldstr, "Hello world!");
			MethodInfo infoWriteLine = typeof(System.Console).GetMethod("WriteLine", new Type[] { typeof(string) });
			ilGenerator.EmitCall(OpCodes.Call, infoWriteLine, null);
			
			ilGenerator.MarkSequencePoint(doc, 2, 1, 2, 100);
			ilGenerator.Emit(OpCodes.Ret);
			
			Type helloWorldType = typeBuilder.CreateType();			
			
			System.Diagnostics.Debugger.Break();
			helloWorldType.GetMethod("Main").Invoke(null, new string[] { null });
		}

        private static TypeBuilder Create(string tableName, List<FieldItem> fields)
        {
            //在模块中创建类型
            TypeBuilder typeBuilder = GetTypeBuilder(tableName);

            //设置类型的父类
            //typeBuilder.SetParent(typeof(Core));

            //创建构造函数
            ConstructorBuilder consBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
            ILGenerator ctorIL = consBuilder.GetILGenerator();
            ctorIL.Emit(OpCodes.Ret);
            ConstructorInfo classCtorInfo = typeof(DMTableAttribute).GetConstructor(new Type[] { typeof(string), typeof(string), typeof(bool) });
            CustomAttributeBuilder attr = new CustomAttributeBuilder(
                        classCtorInfo,
                        new object[] { tableName, "ContentID", true });

            typeBuilder.SetCustomAttribute(attr);

            foreach (var pi in fields)
            {
                CreateProperty(typeBuilder, pi.Name, pi.PropertyType);
            }

            return typeBuilder;
        }

 public static void AddAttribute(this AssemblyBuilder assemblyBuilder, Type attributeType)
 {
     ConstructorInfo attributeCtor = attributeType.GetConstructor(new Type[] { });
     CustomAttributeBuilder attributeBuilder =
         new CustomAttributeBuilder(attributeCtor, new object[] { });
     assemblyBuilder.SetCustomAttribute(attributeBuilder);
 }

        public void Create_class()
        {
            ILGenerator ilGenerator;
            AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                new AssemblyName("Scenarios"), AssemblyBuilderAccess.RunAndSave);

            ModuleBuilder moduleBuilder = asmBuilder.DefineDynamicModule("Scenarios", "Scenarios.dll");

            var typeBuilder = moduleBuilder.DefineType("Scenario_Checkout", TypeAttributes.Class | TypeAttributes.Public);
            var attrBuilder = new CustomAttributeBuilder(typeof(TestFixtureAttribute).GetConstructor(new Type[]{ }), new Object[]{ });
            typeBuilder.SetCustomAttribute(attrBuilder);

            var method = typeBuilder.DefineMethod("ShouldGetLatestChangeset", MethodAttributes.Public);
            attrBuilder = new CustomAttributeBuilder(typeof(TestAttribute).GetConstructor(new Type[]{ }), new Object[]{ });
            method.SetCustomAttribute(attrBuilder);
            ilGenerator = method.GetILGenerator();
            ilGenerator.Emit(OpCodes.Ldstr, "Hello world");
            ilGenerator.Emit(OpCodes.Call,
                typeof(Console).GetMethod("WriteLine",
                    new Type[] { typeof(string)}));
            //ilGenerator.Emit(OpCodes.Ldc_I4_0);
            ilGenerator.Emit(OpCodes.Ret);
            /*
            var thisType = typeof(CreateCodeAtRuntimeTests);
            var methodBody = thisType.GetMethod("Haldis").GetMethodBody().GetILAsByteArray();
            method.CreateMethodBody(methodBody, methodBody.Length);
            */
            typeBuilder.CreateType();

            asmBuilder.Save("Scenarios.dll");
        }

 public void PosTest1()
 {
     TypeBuilder typebuilder = GetTypeBuilder();
     ConstructorInfo constructorinfo = typeof(ClassCreator).GetConstructor(new Type[] { typeof(string) });
     CustomAttributeBuilder cuatbu = new CustomAttributeBuilder(constructorinfo, new object[] { "hello" });
     typebuilder.SetCustomAttribute(cuatbu);
 }

		public static void CompileToAssembly
			(RegexCompilationInfo[] regexes, AssemblyName aname,
			 CustomAttributeBuilder[] attribs, string resourceFile)
		{
			throw new NotImplementedException ();
			// TODO : Make use of attribs and resourceFile parameters
			/*
			AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.RunAndSave);
			ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("InnerRegexModule",aname.Name);
			Parser psr = new Parser ();	
			
			System.Console.WriteLine("CompileToAssembly");
			       
			for(int i=0; i < regexes.Length; i++)
				{
					System.Console.WriteLine("Compiling expression :" + regexes[i].Pattern);
					RegularExpression re = psr.ParseRegularExpression (regexes[i].Pattern, regexes[i].Options);
					
					// compile
										
					CILCompiler cmp = new CILCompiler (modBuilder, i);
					bool reverse = (regexes[i].Options & RegexOptions.RightToLeft) !=0;
					re.Compile (cmp, reverse);
					cmp.Close();
					
				}
		       

			// Define a runtime class with specified name and attributes.
			TypeBuilder builder = modBuilder.DefineType("ITest");
			builder.CreateType();
			asmBuilder.Save(aname.Name);
			*/
		}

        // In here, we're defining a class, foo_Task, derived from our DefinedTask class. This allows us to write the bulk of the code
        // in real C#, rather than attempting to build it here.
        // This means that we have Task <- DefinedTask <- foo_Task.
        // We also need a module and an assembly to hold the class, so we do that, too.
        protected override void ExecuteTask()
        {
            AssemblyName assemblyName = new AssemblyName();
            assemblyName.Name = _taskName + "_Assembly";

            AssemblyBuilder assemblyBuilder =
                AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(_taskName + "_Module");

            // Now we've got an assembly and a module for the task to live in, we can define the actual task class.
            TypeBuilder typeBuilder = moduleBuilder.DefineType(_taskName + "_Task", TypeAttributes.Public);
            typeBuilder.SetParent(typeof(DefinedTask));

            // It needs a [TaskName] attribute.
            ConstructorInfo taskNameAttributeConstructor =
                typeof(TaskNameAttribute).GetConstructor(new Type[] { typeof(string) });
            CustomAttributeBuilder taskNameAttributeBuilder =
                new CustomAttributeBuilder(taskNameAttributeConstructor, new object[] { _taskName });
            typeBuilder.SetCustomAttribute(taskNameAttributeBuilder);

            // We're done. Create it.
            Type taskType = typeBuilder.CreateType();

            // Stash the XML in our static. We'll need it in DefinedTask later.
            DefinedTaskDefinitions.Add(_taskName, XmlNode);

            // Hook that up into NAnt.
            TaskBuilder taskBuilder = new TaskBuilder(taskType.Assembly, taskType.FullName);
            TypeFactory.TaskBuilders.Add(taskBuilder);
        }

		public AssemblyAlgorithmIdAttributeTest ()
		{
			//create a dynamic assembly with the required attribute
			//and check for the validity

			dynAsmName.Name = "TestAssembly";

			dynAssembly = Thread.GetDomain ().DefineDynamicAssembly (
				dynAsmName,AssemblyBuilderAccess.Run
				);

			// Set the required Attribute of the assembly.
			Type attribute = typeof (AssemblyAlgorithmIdAttribute);
			ConstructorInfo ctrInfo = attribute.GetConstructor (
				new Type [] { typeof (AssemblyHashAlgorithm) }
				);
			CustomAttributeBuilder attrBuilder =
				new CustomAttributeBuilder (
				ctrInfo,
				new object [1] { AssemblyHashAlgorithm.MD5 }
				);
			dynAssembly.SetCustomAttribute (attrBuilder);
			object [] attributes = dynAssembly.GetCustomAttributes (true);
			attr = attributes [0] as AssemblyAlgorithmIdAttribute;
		}

		public static CodeCustomAttribute Create (Type attributeType, Type [] ctorArgTypes, CodeLiteral [] ctorArgs, MemberInfo [] members, CodeLiteral [] values)
		{
			ArrayList props = new ArrayList ();
			ArrayList pvalues  = new ArrayList ();
			ArrayList fields = new ArrayList ();
			ArrayList fvalues = new ArrayList ();
			for (int i = 0; i < members.Length; i++) {
				if (members [i] == null)
					throw new ArgumentException (String.Format ("MemberInfo at {0} was null for type {1}.", i, attributeType));
				if (members [i] is PropertyInfo) {
					props.Add ((PropertyInfo) members [i]);
					pvalues.Add (values [i].Value);
				} else {
					fields.Add ((FieldInfo) members [i]);
					fvalues.Add (values [i].Value);
				}
			}

			ConstructorInfo ci = attributeType.GetConstructor (ctorArgTypes);
			CustomAttributeBuilder cab = new CustomAttributeBuilder (
				ci, ctorArgs,
				(PropertyInfo []) props.ToArray (typeof (PropertyInfo)), pvalues.ToArray (),
				(FieldInfo []) fields.ToArray (typeof (FieldInfo)), fvalues.ToArray ());

			CodeCustomAttribute attr = new CodeCustomAttribute (
				cab, attributeType, ci, ctorArgs, members, values);

			return attr;
		}

        protected ParameterDescriptor ParseQueueTrigger(JObject trigger, Type triggerParameterType = null)
        {
            if (triggerParameterType == null)
            {
                triggerParameterType = typeof(string);
            }

            ConstructorInfo ctorInfo = typeof(QueueTriggerAttribute).GetConstructor(new Type[] { typeof(string) });
            string queueName = (string)trigger["queueName"];
            CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder(ctorInfo, new object[] { queueName });

            string parameterName = (string)trigger["name"];
            ParameterDescriptor triggerParameter = new ParameterDescriptor
            {
                Name = parameterName,
                Type = triggerParameterType,
                Attributes = ParameterAttributes.None,
                CustomAttributes = new Collection<CustomAttributeBuilder>
                {
                    attributeBuilder
                }
            };

            return triggerParameter;
        }

        public void TestSetCustomAttribute()
        {
            MethodAttributes getMethodAttr = MethodAttributes.Public |
                                             MethodAttributes.SpecialName |
                                             MethodAttributes.HideBySig;
            Type returnType = typeof(int);
            Type[] ctorParamTypes = new Type[] { typeof(int) };
            int expectedValue = _generator.GetInt32();
            object[] ctorParamValues = new object[] { expectedValue };
            CustomAttributeBuilder customAttrBuilder = new CustomAttributeBuilder(
                                                            typeof(PBMyAttribute).GetConstructor(ctorParamTypes),
                                                            ctorParamValues);
            object[] actualCustomAttrs;

            actualCustomAttrs = ExecutePosTest(
                                        customAttrBuilder,
                                        getMethodAttr,
                                        returnType,
                                        new Type[0],
                                        BindingFlags.Public |
                                        BindingFlags.Instance |
                                        BindingFlags.NonPublic |
                                        BindingFlags.Static);
            Assert.Equal(1, actualCustomAttrs.Length);
            Assert.True(actualCustomAttrs[0] is PBMyAttribute);
            Assert.Equal(expectedValue, (actualCustomAttrs[0] as PBMyAttribute).Value);
        }

        private object[] ExecutePosTest(
                            CustomAttributeBuilder customAttrBuilder,
                            MethodAttributes getMethodAttr,
                            Type returnType,
                            Type[] paramTypes,
                            BindingFlags bindingAttr)
        {
            TypeBuilder myTypeBuilder = GetTypeBuilder(TypeAttributes.Class | TypeAttributes.Public);

            PropertyBuilder myPropertyBuilder = myTypeBuilder.DefineProperty(DynamicPropertyName,
                                                                             PropertyAttributes.HasDefault,
                                                                             returnType, null);
            myPropertyBuilder.SetCustomAttribute(customAttrBuilder);
            // Define the "get" accessor method for DynamicPropertyName
            MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod(DynamicMethodName,
                                                                       getMethodAttr, returnType, paramTypes);
            ILGenerator methodILGenerator = myMethodBuilder.GetILGenerator();
            methodILGenerator.Emit(OpCodes.Ldarg_0);
            methodILGenerator.Emit(OpCodes.Ret);

            // Map the 'get' method created above to our PropertyBuilder
            myPropertyBuilder.SetGetMethod(myMethodBuilder);

            Type myType = myTypeBuilder.CreateTypeInfo().AsType();

            PropertyInfo myProperty = myType.GetProperty(DynamicPropertyName, bindingAttr);
            return myProperty.GetCustomAttributes(false).Select(a => (object)a).ToArray();
        }

        public static Type CreateTest()
        {
            AppDomain currentDomain = Thread.GetDomain();

            AssemblyName assName = new AssemblyName();
            assName.Name = "DynamicTest";
            AssemblyBuilder assemblyBuilder = currentDomain.DefineDynamicAssembly(assName, AssemblyBuilderAccess.Run);
            
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicModule");

            TypeBuilder typeBuilder = moduleBuilder.DefineType("DynamicType", TypeAttributes.Public);

            CustomAttributeBuilder customTypeAttributeBuilder = new CustomAttributeBuilder(typeof(TestClassAttribute).GetConstructors()[0], new object[]{});
            typeBuilder.SetCustomAttribute(customTypeAttributeBuilder);

            MethodBuilder methodBuilder = typeBuilder.DefineMethod("DynamicTestMethod", MethodAttributes.Public, null, new Type[] { });
            CustomAttributeBuilder customMethodAttributeBuilder = new CustomAttributeBuilder(typeof(TestMethodAttribute).GetConstructors()[0], new object[] { });
            methodBuilder.SetCustomAttribute(customMethodAttributeBuilder);


            ILGenerator il = methodBuilder.GetILGenerator();

            il.EmitWriteLine("Hello world");
            il.Emit(OpCodes.Ret);
            return typeBuilder.CreateType();

        }

        public void PosTest1()
        {
            string name = "Assembly1";
            AssemblyName asmname = new AssemblyName();
            asmname.Name = name;

            AssemblyBuilder asmbuild = AssemblyBuilder.DefineDynamicAssembly(asmname, AssemblyBuilderAccess.Run);

            ModuleBuilder modbuild = TestLibrary.Utilities.GetModuleBuilder(asmbuild, "Module1");
            TypeBuilder tpbuild = modbuild.DefineType("C1");

            Type attrType = typeof(TBMyAttribute1);
            ConstructorInfo ci = attrType.GetConstructors()[0];
            FieldInfo fi = attrType.GetField("Field12345");


            CustomAttributeBuilder cab = new CustomAttributeBuilder(ci,
                                                                    new object[] { 4 },
                                                                    new FieldInfo[] { fi },
                                                                    new object[] { "hello" });
            tpbuild.SetCustomAttribute(cab);
            tpbuild.CreateTypeInfo().AsType();

            // VERIFY
            object[] attribs = tpbuild.GetCustomAttributes(false).Select(a => (object)a).ToArray();

            Assert.Equal(1, attribs.Length);
            TBMyAttribute1 obj = (TBMyAttribute1)attribs[0];

            Assert.Equal("hello", obj.Field12345);
            Assert.Equal(4, obj.m_ctorType2);
        }

 internal static void Compile(EnumMetadataEnum enumMetadata)
 {
     Type type;
     EnumBuilder builder2;
     string enumFullName = GetEnumFullName(enumMetadata);
     if (enumMetadata.UnderlyingType != null)
     {
         type = (Type) LanguagePrimitives.ConvertTo(enumMetadata.UnderlyingType, typeof(Type), CultureInfo.InvariantCulture);
     }
     else
     {
         type = typeof(int);
     }
     ModuleBuilder builder = _moduleBuilder.Value;
     lock (_moduleBuilderUsageLock)
     {
         builder2 = builder.DefineEnum(enumFullName, TypeAttributes.Public, type);
     }
     if (enumMetadata.BitwiseFlagsSpecified && enumMetadata.BitwiseFlags)
     {
         CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(typeof(FlagsAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
         builder2.SetCustomAttribute(customBuilder);
     }
     foreach (EnumMetadataEnumValue value2 in enumMetadata.Value)
     {
         string name = value2.Name;
         object literalValue = LanguagePrimitives.ConvertTo(value2.Value, type, CultureInfo.InvariantCulture);
         builder2.DefineLiteral(name, literalValue);
     }
     builder2.CreateType();
 }