klod68/gen-factory-class

name: gen-factory-class description: "Use when creating a static factory for a strategy or provider pattern in a black-box library (no DI container). Generates a thread-safe cached static factory dispatching by enum key with typed convenience methods. Also invoke when the user mentions: static factory, provider factory, enum-keyed factory, library factory pattern. Domain: Code Generation, Design Patterns. Level: Intermediate."

Generate a cached static factory for creating ${1:IInterfaceName} implementations dispatched by ${2:EnumName}.

Context

• Namespace root: ${3:MyApp}
• Enum values and their implementation classes: ${4:Value1 → Impl1Class, Value2 → Impl2Class, Value3 → Impl3Class}

Required output — generate ALL of the following:

1. Factory class

${3}.Factories.${1/^I//}Factory.cs

/// <summary>
/// Thread-safe cached factory for <see cref="${1}"/> implementations.
/// </summary>
public static class ${1/^I//}Factory
{
    private static readonly ConcurrentDictionary<${2}, ${1}> s_cache = new();

    /// <summary>
    /// Returns a cached <see cref="${1}"/> for the specified <paramref name="type"/>.
    /// </summary>
    /// <param name="type">The implementation type to create or retrieve.</param>
    /// <returns>A cached <see cref="${1}"/> instance.</returns>
    /// <exception cref="ArgumentOutOfRangeException">
    /// Thrown when <paramref name="type"/> has no registered implementation.
    /// </exception>
    public static ${1} Create(${2} type)
        => s_cache.GetOrAdd(type, static key => key switch
        {
            // one case per enum value — filled from context above
            _ => throw new ArgumentOutOfRangeException(
                     nameof(type), type, $"No implementation registered for {nameof(${2})}.{type}.")
        });

    // Typed convenience methods — one per enum value
}

2. Internal implementation classes

${3}.Instances.{Domain}/{ImplN}Class.cs   ← one file per implementation

• internal sealed class {ImplN} : ${1}
• Constructor-free where possible (no state needed for strategy/provider)
• Full implementation of all interface members
• DbC guard clauses on every method parameter

3. Enum (if not already present)

${3}.Domain.${2}.cs

• One value per implementation
• XML doc on the enum and every value

Rules

• Factory class is public static — it is the only public entry point for instances
• All concrete implementations are internal sealed — never public
• ConcurrentDictionary.GetOrAdd with a static lambda for thread-safe allocation-free caching
• switch expression (not if-else) for exhaustive enum dispatch
• Throw ArgumentOutOfRangeException for unknown values — never NotImplementedException
• Factory methods return ${1} (the interface) — never a concrete type
• Typed convenience methods (CreateValue1(), CreateValue2()) wrap the main Create method
• XML doc on the factory class, Create method, and every convenience method

Constraints

• Follow all rules in the workspace root instruction file
• No DI container references in the factory or implementations
• Factory is stateless — only the cache dictionary is held
• Implementations must be safe to share across threads (stateless or using thread-safe state)