Saving Dynamic Module

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;

namespace reflectionExperiment
{
    class myCLass
    {
        static void Main(string[] args)
        {
            var myType = ClassBuilder.BuildDynamicType();
            var myObj = Activator.CreateInstance(myType);

        }
    }


    public class SWTTFields
    {
        public string fieldName;
        public int startPosition;
        public int endPosition;

        public static SWTTFields ISO = new SWTTFields("ISO", 1, 2);
        public static SWTTFields EPC = new SWTTFields("EPC", 3, 4);

        private SWTTFields(String fieldName, Int32 startPositon, Int32 endPositon)
        {
            this.fieldName = fieldName;
                this.startPosition = startPositon;
                this.endPosition = endPositon;
        }
    }

    class ClassBuilder
    {

        public static Type BuildDynamicType()
        {
            AppDomain myDomain = Thread.GetDomain();
            AssemblyName myAsmName = new AssemblyName();
            myAsmName.Name = "MyDynamicAssembly";

            // To generate a persistable assembly, specify AssemblyBuilderAccess.RunAndSave.
            AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,
                                                            AssemblyBuilderAccess.RunAndSave);
            // Generate a persistable single-module assembly.
            ModuleBuilder myModBuilder =
                myAsmBuilder.DefineDynamicModule("ModuleOne", "ModuleOne.dll", true);

            TypeBuilder myTypeBuilder = myModBuilder.DefineType("SWT",
                                                            TypeAttributes.Public);

            FieldBuilder fieldName_field = myTypeBuilder.DefineField("fieldName",
                                                            typeof(string),
                                                            FieldAttributes.Public);

            FieldBuilder startPosition_field = myTypeBuilder.DefineField("startPosition",
                                                            typeof(int),
                                                            FieldAttributes.Public);

            FieldBuilder endPosition_field = myTypeBuilder.DefineField("endPosition",
                                                           typeof(int),
                                                           FieldAttributes.Public );

            FieldBuilder ISO_field =
                myTypeBuilder.DefineField("ISO",myTypeBuilder.GetType(),
                                          FieldAttributes.Public | FieldAttributes.Static);


            FieldBuilder EPC_field =
                myTypeBuilder.DefineField("EPC", myTypeBuilder.GetType(),
                                          FieldAttributes.Public | FieldAttributes.Static);

            // create instance parameterless ctor
            var parameterlessCtor = myTypeBuilder.DefineDefaultConstructor(MethodAttributes.Public);

            //Instance private ctor
            //parameters: stringFieldName, int StartPosition, int endPositio
            var instanceCtor = myTypeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard,
                new Type[] { typeof(string), typeof(int), typeof(int) });
            // generate IL
            ILGenerator ILGener_instance = instanceCtor.GetILGenerator();
            //pass "this"
            ILGener_instance.Emit(OpCodes.Ldarg_0);
            //call baseclass ctor
            ILGener_instance.Emit(OpCodes.Call, typeof(Object).GetConstructor(Type.EmptyTypes));
            // ???
            ILGener_instance.Emit(OpCodes.Nop);
            ILGener_instance.Emit(OpCodes.Nop);

            //store first argument
            ILGener_instance.Emit(OpCodes.Ldarg_0);
            ILGener_instance.Emit(OpCodes.Ldarg_1);
            ILGener_instance.Emit(OpCodes.Stfld, fieldName_field);

            //store second argument
            ILGener_instance.Emit(OpCodes.Ldarg_0);
            ILGener_instance.Emit(OpCodes.Ldarg_2);
            ILGener_instance.Emit(OpCodes.Stfld, startPosition_field);

            //store third argument
            ILGener_instance.Emit(OpCodes.Ldarg_0);
            ILGener_instance.Emit(OpCodes.Ldarg_2);
            ILGener_instance.Emit(OpCodes.Stfld, endPosition_field);

            ILGener_instance.Emit(OpCodes.Nop);
            ILGener_instance.Emit(OpCodes.Ret); // done, return

            //Static ctor (MethodAttributes already preset for static ctor)
            var staticCtor = myTypeBuilder.DefineTypeInitializer();
            ILGenerator ILGener_static = staticCtor.GetILGenerator();

            //Load "ISO" string onto stack
            ILGener_static.Emit(OpCodes.Ldstr, "ISO");
            //load integer 1 & 2 into stack
            ILGener_static.Emit(OpCodes.Ldc_I4, 1);
            ILGener_static.Emit(OpCodes.Ldc_I4, 2);

            // new object
            ILGener_static.Emit(OpCodes.Newobj, instanceCtor);
            ILGener_static.Emit(OpCodes.Stsfld, ISO_field);

            //Load "ISO" string onto stack
            ILGener_static.Emit(OpCodes.Ldstr, "EPC");
            //load integer 1 & 2 into stack
            ILGener_static.Emit(OpCodes.Ldc_I4, 3);
            ILGener_static.Emit(OpCodes.Ldc_I4, 4);

            ILGener_static.Emit(OpCodes.Newobj, instanceCtor);
            ILGener_static.Emit(OpCodes.Stsfld, EPC_field);
            ILGener_static.Emit(OpCodes.Ret); //done, return

            // Save the assembly so it can be examined with Ildasm.exe,
            // or referenced by a test program.
            myAsmBuilder.Save("ModuleOne.dll");
            return myTypeBuilder.CreateType();
        }
    }
}