refactor: improve FlatBufferEx architecture and reliability

- Implement service-based architecture with DI
- Add centralized configuration management
- Improve error handling and validation
- Add XML documentation and code standards
- Fix template rendering and file handling
- Update build system and dependencies
- Add proper cleanup of temporary files

Author: boyism80

Configuration/AppConfiguration.cs

@@ -0,0 +1,159 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace FlatBufferEx.Configuration
+{
+    /// <summary>
+    /// Application configuration class that holds all settings for the FlatBuffer code generator
+    /// </summary>
+    public class AppConfiguration
+    {
+        /// <summary>
+        /// Input directory path containing .fbs schema files
+        /// </summary>
+        public string InputPath { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Target languages for code generation (e.g., "c++|c#")
+        /// </summary>
+        public string Languages { get; set; } = "c#";
+
+        /// <summary>
+        /// Output directory path for generated code
+        /// </summary>
+        public string OutputPath { get; set; } = "output";
+
+        /// <summary>
+        /// Include directory path for additional schema files
+        /// </summary>
+        public string IncludePath { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Supported languages
+        /// </summary>
+        public static readonly HashSet<string> SupportedLanguages = new() { "c++", "c#" };
+
+        /// <summary>
+        /// Default FlatBuffer compiler download URL
+        /// </summary>
+        public string FlatBufferCompilerUrl { get; set; } = "https://github.com/google/flatbuffers/releases/download/v25.2.10/Windows.flatc.binary.zip";
+
+        /// <summary>
+        /// Temporary directory for raw FlatBuffer files
+        /// </summary>
+        public string TempDirectory { get; set; } = "raw";
+
+        /// <summary>
+        /// FlatBuffer compiler directory
+        /// </summary>
+        public string CompilerDirectory { get; set; } = "flatbuffer";
+
+        /// <summary>
+        /// Template directory path
+        /// </summary>
+        public string TemplateDirectory { get; set; } = "Template";
+
+        /// <summary>
+        /// Gets the parsed target languages
+        /// </summary>
+        public IEnumerable<string> GetTargetLanguages()
+        {
+            return Languages
+                .Split('|')
+                .Select(x => x.Trim().ToLower())
+                .Where(x => !string.IsNullOrEmpty(x))
+                .Distinct();
+        }
+
+        /// <summary>
+        /// Validates the configuration and returns validation errors
+        /// </summary>
+        /// <param name="errors">Collection of validation errors</param>
+        /// <returns>True if configuration is valid, false otherwise</returns>
+        public bool IsValid(out List<string> errors)
+        {
+            errors = new List<string>();
+
+            // Validate input path
+            if (string.IsNullOrWhiteSpace(InputPath))
+            {
+                errors.Add("Input path is required");
+            }
+            else if (!Directory.Exists(InputPath))
+            {
+                errors.Add($"Input directory does not exist: {InputPath}");
+            }
+
+            // Validate output path
+            if (string.IsNullOrWhiteSpace(OutputPath))
+            {
+                errors.Add("Output path is required");
+            }
+
+            // Validate languages
+            if (string.IsNullOrWhiteSpace(Languages))
+            {
+                errors.Add("At least one target language must be specified");
+            }
+            else
+            {
+                var targetLanguages = GetTargetLanguages().ToList();
+                if (!targetLanguages.Any())
+                {
+                    errors.Add("No valid target languages specified");
+                }
+
+                var unsupportedLanguages = targetLanguages.Where(lang => !SupportedLanguages.Contains(lang)).ToList();
+                if (unsupportedLanguages.Any())
+                {
+                    errors.Add($"Unsupported languages: {string.Join(", ", unsupportedLanguages)}. Supported languages: {string.Join(", ", SupportedLanguages)}");
+                }
+            }
+
+            // Validate template directory
+            if (!Directory.Exists(TemplateDirectory))
+            {
+                errors.Add($"Template directory does not exist: {TemplateDirectory}");
+            }
+
+            return !errors.Any();
+        }
+
+        /// <summary>
+        /// Gets the full output path
+        /// </summary>
+        public string GetFullOutputPath()
+        {
+            return Path.GetFullPath(OutputPath);
+        }
+
+        /// <summary>
+        /// Gets the language-specific compiler environment name
+        /// </summary>
+        /// <param name="language">Target language</param>
+        /// <returns>Compiler environment name</returns>
+        public string GetCompilerEnvironment(string language)
+        {
+            return language switch
+            {
+                "c++" => "cpp",
+                "c#" => "csharp",
+                _ => throw new ArgumentException($"Unsupported language: {language}")
+            };
+        }
+
+        /// <summary>
+        /// Gets the file extension for the target language
+        /// </summary>
+        /// <param name="language">Target language</param>
+        /// <returns>File extension</returns>
+        public string GetFileExtension(string language)
+        {
+            return language switch
+            {
+                "c++" => ".h",
+                "c#" => ".cs",
+                _ => throw new ArgumentException($"Unsupported language: {language}")
+            };
+        }
+    }
+}

FlatBufferEx.csproj

@@ -4,6 +4,10 @@
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>disable</Nullable>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <WarningsAsErrors />
+    <WarningsNotAsErrors>CS0618</WarningsNotAsErrors>
   </PropertyGroup>
 
   <ItemGroup>
@@ -17,6 +21,7 @@
     <PackageReference Include="NDesk.Options.Core" Version="1.2.8" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="Scriban" Version="5.10.0" />
+    <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>

Generator.cs

@@ -1,4 +1,5 @@
 using FlatBufferEx.Model;
+using FlatBufferEx.Services;
 using Scriban;
 
 namespace FlatBufferEx
@@ -7,11 +8,12 @@ namespace FlatBufferEx
     /// Static generator class for creating FlatBuffer schema content
     /// Generates raw FlatBuffer (.fbs) content for tables and enums using Scriban templates
     /// </summary>
+    [Obsolete("Use ITemplateService instead. This class is kept for backward compatibility.")]
     public static class Generator
     {
         // Pre-compiled Scriban templates for generating raw FlatBuffer content
-        private static readonly Template RawTableTemplate = Template.Parse(File.ReadAllText("Template/raw.table.txt"));
-        private static readonly Template RawEnumTemplate = Template.Parse(File.ReadAllText("Template/raw.enum.txt"));
+        private static readonly Lazy<Template> RawTableTemplate = new(() => Template.Parse(File.ReadAllText("Template/raw.table.txt")));
+        private static readonly Lazy<Template> RawEnumTemplate = new(() => Template.Parse(File.ReadAllText("Template/raw.enum.txt")));
 
         /// <summary>
         /// Generates raw FlatBuffer table content using the table template
@@ -29,7 +31,7 @@ public static string RawFlatBufferTableContents(Model.Table table, string lang)
             ctx.PushGlobal(obj);
 
             // Render the template with the context
-            return RawTableTemplate.Render(ctx);
+            return RawTableTemplate.Value.Render(ctx);
         }
 
         /// <summary>
@@ -48,7 +50,7 @@ public static string RawFlatBufferEnumContents(Model.Enum e, string lang)
             ctx.PushGlobal(obj);
 
             // Render the template with the context
-            return RawEnumTemplate.Render(ctx);
+            return RawEnumTemplate.Value.Render(ctx);
         }
     }
 }