Preparation for Name hashing performance update and Host Precompilation performance update.

Author: DerekGooding

EnumSourceGenerator/EnumGenerator.cs

@@ -30,12 +30,13 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 if (iContentInterface?.TypeArguments.FirstOrDefault() is not INamedTypeSymbol typeArgument) continue;
 
                 // Extract enum member names from the All property of the class
+                var structName = typeArgument.Name;
                 var enumMembers = ExtractEnumMembers(ctx, classSymbol).ToImmutableArray();
 
                 var source = GenerateEnumSource(classSymbol.Name, enumMembers);
                 ctx.AddSource($"{classSymbol.Name}TypeEnum.g.cs", SourceText.From(source, Encoding.UTF8));
 
-                var helper = GeneratePartialHelper(classSymbol.Name,
+                var helper = GeneratePartialHelper(classSymbol.Name, structName,
                                                       classSymbol.ContainingNamespace.ToDisplayString(),
                                                       typeArgument.ToDisplayString(), enumMembers);
                 ctx.AddSource($"{classSymbol.Name}Helper.g.cs", SourceText.From(helper, Encoding.UTF8));
@@ -196,14 +197,19 @@ public enum {className}Type
 }}";
     }
 
-    private static string GeneratePartialHelper(string className, string fullNamespace, string typeArgument, ImmutableArray<string> enumMembers)
+    private static string GeneratePartialHelper(string className, string structName, string fullNamespace, string typeArgument, ImmutableArray<string> enumMembers)
     {
         var membersSource = string.Join(";\n", enumMembers.Select((m, i) => $"        public {typeArgument} {m} => All[{i}]"));
         return $@"// Auto-generated code
 using ContentEnums;
 
 namespace {fullNamespace}
 {{
+    public partial record struct {structName}
+    {{
+        public bool Equals({structName} other) => string.Equals(Name, other.Name);
+        public override int GetHashCode() => Name?.GetHashCode() ?? 0;
+    }}
     public partial class {className}
     {{
         public {typeArgument} Get({className}Type type) => All[(int)type];

EnumSourceGenerator/HostGenerator.cs

@@ -0,0 +1,63 @@
+//using Microsoft.CodeAnalysis;
+//using Microsoft.CodeAnalysis.CSharp;
+//using Microsoft.CodeAnalysis.CSharp.Syntax;
+//using Microsoft.CodeAnalysis.Text;
+//using System.Linq;
+//using System.Text;
+
+//namespace EnumSourceGenerator;
+
+//[Generator]
+//public class HostGenerator : IIncrementalGenerator
+//{
+//    public void Initialize(IncrementalGeneratorInitializationContext context)
+//    {
+//        var classDeclarations = context.SyntaxProvider
+//            .CreateSyntaxProvider(
+//                predicate: static (s, _) => s is ClassDeclarationSyntax,
+//                transform: static (ctx, _) =>
+//                {
+//                    var classSyntax = (ClassDeclarationSyntax)ctx.Node;
+//                    var symbol = ctx.SemanticModel.GetDeclaredSymbol(classSyntax);
+
+//                    return symbol?.GetAttributes().Any(a =>
+//                        a.AttributeClass?.Name == "SingletonAttribute") == true
+//                        ? symbol
+//                        : null;
+//                })
+//            .Where(static symbol => symbol is not null);
+
+//        var compilationAndClasses = context.CompilationProvider.Combine(classDeclarations.Collect());
+
+//        context.RegisterSourceOutput(compilationAndClasses, (spc, source) =>
+//        {
+//            var (compilation, classes) = source;
+//            var sb = new StringBuilder();
+//            sb.AppendLine("namespace SimpleInjection;");
+//            sb.AppendLine("public static partial class Host");
+//            sb.AppendLine("{");
+//            sb.AppendLine("    public static Host Configure()");
+//            sb.AppendLine("    {");
+//            sb.AppendLine("        var host = new Host();");
+
+//            foreach (var impl in classes.Distinct())
+//            {
+//                var attr = impl.GetAttributes().FirstOrDefault(a =>
+//                    a.AttributeClass?.Name == "SingletonAttribute");
+
+//                var iface = attr?.ConstructorArguments[0].Value as INamedTypeSymbol;
+
+//                if (iface != null)
+//                {
+//                    sb.AppendLine($"        host._services.AddSingleton<{iface.ToDisplayString()}, {impl.ToDisplayString()}>();");
+//                }
+//            }
+
+//            sb.AppendLine("        return host;");
+//            sb.AppendLine("    }");
+//            sb.AppendLine("}");
+
+//            spc.AddSource("Host.Configure.g.cs", SourceText.From(sb.ToString(), Encoding.UTF8));
+//        });
+//    }
+//}

SimpleInjection.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
-VisualStudioVersion = 17.14.36203.30 d17.14
+VisualStudioVersion = 17.14.36203.30
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SimpleInjection", "SimpleInjection\SimpleInjection.csproj", "{EBCC1F56-6AF3-475D-8DD9-12ADEDD53E9C}"
 EndProject

SimpleInjection/Injection/Host.cs

@@ -9,7 +9,7 @@
 /// initialization and dependency resolution. It automatically discovers attributed classes and registers them
 /// with their appropriate lifetimes.
 /// </remarks>
-public sealed class Host
+public sealed partial class Host
 {
     private readonly List<ServiceDescriptor> _serviceDescriptors = [];
     private readonly Dictionary<Type, object> _singletonInstances = [];
@@ -28,6 +28,7 @@ private Host() { }
     /// with service lifetime attributes (<see cref="SingletonAttribute"/>, <see cref="ScopedAttribute"/>,
     /// <see cref="TransientAttribute"/>). It then creates a new host and registers these types with appropriate lifetimes.
     /// </remarks>
+    //[Obsolete("Use Host.Configure() instead. This method will be removed in future versions.")]
     public static Host Initialize()
     {
         var host = new Host();