System.Text.RegularExpressions.RegexTypeCompiler.FactoryTypeFromCode C# (CSharp) Method

        internal Type FactoryTypeFromCode(RegexCode code, RegexOptions options, String typeprefix) {
            String runnertypename;
            String runnerfactoryname;
            Type runnertype;
            Type factory;
        
            _code       = code;
            _codes      = code._codes;
            _strings    = code._strings;
            _fcPrefix   = code._fcPrefix;
            _bmPrefix   = code._bmPrefix;
            _anchors    = code._anchors;
            _trackcount = code._trackcount;
            _options    = options;
        
            // pick a name for the class
            int typenum = Interlocked.Increment(ref _typeCount);
            string typenumString = typenum.ToString(CultureInfo.InvariantCulture);
            runnertypename = typeprefix + "Runner" + typenumString ;
            runnerfactoryname = typeprefix + "Factory" + typenumString;
        
            // Generate a RegexRunner class
            // (blocks are simply illustrative)
        
            DefineType(runnertypename, false, typeof(RegexRunner));
            {
                DefineMethod("Go", null);
                {
                    GenerateGo();
                    BakeMethod();
                }
        
                DefineMethod("FindFirstChar", typeof(bool));
                {
                    GenerateFindFirstChar();
                    BakeMethod();
                }
        
                DefineMethod("InitTrackCount", null);
                {
                    GenerateInitTrackCount();
                    BakeMethod();
                }
        
                runnertype = BakeType();
            }
        
            // Generate a RegexRunnerFactory class
        
            DefineType(runnerfactoryname, false, typeof(RegexRunnerFactory));
            {
                DefineMethod("CreateInstance", typeof(RegexRunner));
                {
                    GenerateCreateInstance(runnertype);
                    BakeMethod();
                }
        
                factory = BakeType();
            }
        
            return factory;
        }
        

 internal static void CompileToAssembly(RegexCompilationInfo[] regexes, AssemblyName an, CustomAttributeBuilder[] attribs, String resourceFile, Evidence evidence) {
     RegexTypeCompiler c = new RegexTypeCompiler(an, attribs, resourceFile, evidence);
 
     for (int i=0; i<regexes.Length; i++) {
         String pattern = regexes[i].Pattern;
         RegexOptions options = regexes[i].Options;
         String fullname;
         if (regexes[i].Namespace.Length == 0)
             fullname = regexes[i].Name;
         else
             fullname = regexes[i].Namespace + "." + regexes[i].Name;
 
         RegexTree tree = RegexParser.Parse(pattern, options);
         RegexCode code = RegexWriter.Write(tree);
 
         Type factory;
 
         new ReflectionPermission(PermissionState.Unrestricted).Assert();
         try {
             factory = c.FactoryTypeFromCode(code, options, fullname);
             c.GenerateRegexType(pattern, options, fullname, regexes[i].IsPublic, code, tree, factory);
         }
         finally {
             CodeAccessPermission.RevertAssert();
         }
     }
 
     c.Save();
 }