Zetbox.Generator.ResourceBasedGenerationHost.Initialize C# (CSharp) Method

        public void Initialize(NameValueCollection settings)
        {
            if (settings == null) { throw new ArgumentNullException("settings"); }

            // Store settings:
            this.settings = settings;

            if (!_arebisInitialized)
            {
                lock (_lock)
                {
                    if (!_arebisInitialized)
                    {
                        // Setup generation language settings:
                        GenerationLanguage.DefaultNameSpace = "Arebis.DynamicAssembly";
                        GenerationLanguage.DefaultBaseClass = "Arebis.CodeGeneration.CodeTemplate";
                        GenerationLanguage.CodeBuilders["vb"] = typeof(VBCodeBuilder);
                        GenerationLanguage.CodeBuilders["c#"] = typeof(CSCodeBuilder);
                        GenerationLanguage.DefaultTemplateLanguage = "c#";
                        _arebisInitialized = true;
                    }
                }
            }

            // Default to T3 syntax:
            new Arebis.CodeGenerator.Templated.Syntax.T3Syntax().Setup(this.settings);

            // Run GenerationSetup if any:
            foreach (string generationSetupTypeName in settings.GetValues("generatorsetup") ?? new string[0])
            {
                try
                {
                    ((IGenerationSetup)Activator.CreateInstance(Type.GetType(generationSetupTypeName)))
                    .Setup(this.settings);
                }
                catch (Exception ex)
                {
                    throw new ApplicationException(String.Format("Failed to setup generator by '{0}': {1}", generationSetupTypeName, ex.Message));
                }
            }

            // Build initial context writer:
            this.contextWriter = new Stack<TextWriter>();
            this.contextWriter.Push(new StringWriter());

            // Set output directory:
            this.outputDirectory = Path.Combine(Environment.CurrentDirectory, (this.Settings["targetdir"] ?? "."));

            // Initialize compiled templates:
            this.templates = new Dictionary<string, TemplateInfo>();

            // Initialize filewriters:
            this.fileWriters = new List<IFileWriter>();
            foreach (string writer in settings.GetValues("filewriter") ?? new string[0])
            {
                try
                {
                    Type writerType = Type.GetType(writer);
                    IFileWriter instance = (IFileWriter)Activator.CreateInstance(writerType);
                    this.fileWriters.Add(instance);
                }
                catch (ArgumentNullException)
                {
                    throw new ApplicationException(String.Format("Failed to instantiate the filewriter \"{0}\". Check classname and referencepath.", writer));
                }
            }

            // Add default filewriter:
            this.fileWriters.Add(new DefaultFileWriter());

            // Link & initialize file writers:
            for (int i = 0; i < this.fileWriters.Count; i++)
            {
                // Set host:
                this.fileWriters[i].Host = this;
                // Connect to previous (if any):
                if (i > 0)
                {
                    this.fileWriters[i - 1].NextWriter = this.fileWriters[i];
                }
            }
        }

        public virtual int ExecuteTemplate(ResourceBasedGenerationHost genHost, string templateFilename, string outputFilename, object[] templateParameters)
        {
            if (genHost == null)
            {
                throw new ArgumentNullException("genHost");
            }

            using (log4net.NDC.Push(templateFilename))
            {
                try
                {
                    if (Log.IsDebugEnabled)
                    {
                        Log.DebugFormat("Executing template");
                    }
                    genHost.Initialize(this.Settings);
                    genHost.CallTemplateToFile(templateFilename, outputFilename, templateParameters);
                    return(0);
                }
                catch (CompilationFailedException ex)
                {
                    Log.Error("Template compilation failed", ex);
                    foreach (CompilerError err in ex.Errors)
                    {
                        Log.WarnFormat("{0} {1}: {2}\r\n  \"{3}\", line #{4}",
                                       err.IsWarning ? "Warning" : "Error",
                                       err.ErrorNumber,
                                       err.ErrorText,
                                       err.FileName,
                                       err.Line);
                    }
                    throw;
                }
            }
        }