add comments

Author: nogic1008

ColumnInfo.cs

@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-
 namespace T4Sample
 {
     public class ColumnInfo

ITextTemplate.cs

@@ -2,8 +2,26 @@
 
 namespace T4Sample
 {
+    /// <summary>
+    /// Preprocessed text template.
+    /// </summary>
+    /// <remarks>
+    /// This interface is used to avoid compile errors in code that calls T4 classes,
+    /// and uses the "default implementation of interfaces" feature.
+    /// Learn More: https://devblogs.microsoft.com/dotnet/default-implementations-in-interfaces/
+    /// </remarks>
     public interface ITextTemplate
     {
+        /// <summary>
+        /// Generate the output text of the transformation.
+        /// </summary>
+        /// <returns>
+        /// Throws <see cref="NotImplementedException"/>.
+        /// After build, it should be overridden by the implementation.
+        /// </returns>
+        /// <exception cref="NotImplementedException">
+        /// Throws when the default implementation is called.
+        /// </exception>
         string TransformText() => throw new NotImplementedException();
     }
 }

Program.cs

@@ -7,13 +7,15 @@ class Program
     {
         static void Main()
         {
+            // DB Type => .NET Type
             var typeDef = new Dictionary<string, string>()
             {
                 { "integer", "int" },
                 { "varchar", "string" },
                 { "date", "DateTime" },
             };
 
+            // Mock Table Data
             var table = new TableInfo()
             {
                 Name = "staff_master",
@@ -27,8 +29,11 @@ static void Main()
                 }
             };
 
+            // This variable type should be an interface because avoid CS1061 compile error.
+            // At runtime, the implementation's TransformText() is called.
             ITextTemplate template = new TableEntityTemplate(typeDef, "MyNameSpace", table);
 
+            // Actually, you can output to a file like "StaffMaster.cs".
             Console.WriteLine(template.TransformText());
         }
     }

StringHelper.cs

@@ -1,43 +1,60 @@
 using System;
-using System.Buffers;
 
 namespace T4Sample
 {
+    /// <summary>
+    /// Extension methods for <see cref="string"/>.
+    /// </summary>
     public static class StringHelper
     {
+        /// <summary>
+        /// Convert snake_case to PascalCase(UpperCamel).
+        /// </summary>
+        /// <param name="snakeCaseString">snake_case string.</param>
+        /// <returns>PascalCase string.</returns>
         public static string ToPascalCase(this string snakeCaseString)
-            => string.IsNullOrEmpty(snakeCaseString) ? snakeCaseString : ToCamelCaseInner(snakeCaseString.AsSpan(), true);
+            => string.IsNullOrEmpty(snakeCaseString) ?
+                snakeCaseString : ToCamelCaseInner(snakeCaseString.AsSpan(), true);
+
+        /// <summary>
+        /// Convert snake_case to camelCase(lowerCamel).
+        /// </summary>
+        /// <param name="snakeCaseString">snake_case string.</param>
+        /// <returns>camelCase string.</returns>
         public static string ToCamelCase(this string snakeCaseString)
-            => string.IsNullOrEmpty(snakeCaseString) ? snakeCaseString : ToCamelCaseInner(snakeCaseString.AsSpan(), false);
+            => string.IsNullOrEmpty(snakeCaseString) ?
+                snakeCaseString : ToCamelCaseInner(snakeCaseString.AsSpan(), false);
 
+        /// <summary>
+        /// Inner Method for <see cref="ToPascalCase(string)"/> and <see cref="ToCamelCase(string)"/>.
+        /// </summary>
+        /// <param name="source">snake_case chars span.</param>
+        /// <param name="isUpper">First Letter is Upper or Lower.</param>
+        /// <returns>(Upper|Lower) camelCase string.</returns>
         private static string ToCamelCaseInner(ReadOnlySpan<char> source, bool isUpper)
         {
-            var buffer = ArrayPool<char>.Shared.Rent(source.Length);
-            try
-            {
-                var bufferSpan = buffer.AsSpan();
+            // if length is short, use stackalloc to avoid `new`.
+            // TODO: use ArrayPool to avoid `new` completely.
+            var buffer = source.Length <= 100 ?
+                stackalloc char[source.Length] : new char[source.Length];
 
-                int written = 0;
-                foreach (var c in source)
+            int written = 0;
+            foreach (var c in source)
+            {
+                if (c == '_')
                 {
-                    if (c == '_')
-                    {
-                        // (written != 0) means "Is Not First Letter".
-                        // if camelCase, isUpper switches `true` when "Is Not First Letter" and comes "_".
-                        // if PascalCase, isUpper switches `true` when comes "_".
-                        isUpper |= (written != 0);
-                        continue;
-                    }
-
-                    bufferSpan[written++] = isUpper ? char.ToUpperInvariant(c) : char.ToLowerInvariant(c);
-                    isUpper = false;
+                    // (written != 0) means "Is Not First Letter".
+                    // if camelCase and first letter, (isUpper | "Is Not First Letter") is false.
+                    // if PascalCase and first letter, (isUpper | "Is Not First Letter") is true.
+                    // if not first letter, (isUpper | "Is Not First Letter") is true whether isUpper is true or not.
+                    isUpper |= (written != 0);
+                    continue;
                 }
-                return (written == 0) ? "" : new string(bufferSpan.Slice(0, written));
-            }
-            finally
-            {
-                ArrayPool<char>.Shared.Return(buffer);
+
+                buffer[written++] = isUpper ? char.ToUpperInvariant(c) : char.ToLowerInvariant(c);
+                isUpper = false;
             }
+            return (written == 0) ? "" : new string(buffer.Slice(0, written));
         }
     }
 }

TableEntityTemplate.cs

@@ -4,15 +4,39 @@ namespace T4Sample
 {
     public partial class TableEntityTemplate : ITextTemplate
     {
+        /// <summary>
+        /// Assigns Databases Column Type Name to .NET Type Name.
+        /// </summary>
         private readonly Dictionary<string, string> _typeDictionary;
 
+        /// <summary>
+        /// Entity's Namespace.
+        /// </summary>
         public string NameSpace { get; }
 
+        /// <summary>
+        /// Table Data.
+        /// </summary>
         public TableInfo Table { get; }
 
+        /// <summary>
+        /// Creates an Instance of TableEntityTemplate.
+        /// </summary>
+        /// <param name="typeDictionary">Assigns Databases Column Type Name to .NET Type Name.</param>
+        /// <param name="nameSpace">Entity's Namespace.</param>
+        /// <param name="table">Table Data.</param>
         public TableEntityTemplate(Dictionary<string, string> typeDictionary, string nameSpace, TableInfo table)
             => (_typeDictionary, NameSpace, Table) = (typeDictionary, nameSpace, table);
 
+        /// <summary>
+        /// Get .NET Type Name from typeDictionary.
+        /// </summary>
+        /// <param name="column">Column's Data.</param>
+        /// <returns>
+        /// Returns typeDictionary's value if found.
+        /// Returns <see cref="ColumnInfo.Type"/> if not found.
+        /// If the column is nullable, add "?" To the return value.
+        /// </returns>
         public string GetColumnType(ColumnInfo column)
             => _typeDictionary.TryGetValue(column.Type, out var n) ? n : column.Type
                 + (column.NotNull ? "" : "?");