C# Generic Interface and Factory Pattern

Usually for that Factory using some DI container (DI can be useful, for example, when GenericInt or GenericString has dependencies), but to demonstrate just Idea how you can resolve this:

void Main()
{
    GenericFactory.CreateGeneric<int>();
    GenericFactory.CreateGeneric<string>();
}

public static class GenericFactory
{
    private static Dictionary<Type, Type> registeredTypes = new Dictionary<System.Type, System.Type>();

    static GenericFactory()
    {
        registeredTypes.Add(typeof(int), typeof(GenericInt));
        registeredTypes.Add(typeof(string), typeof(GenericString));
    }

    public static IGeneric<T> CreateGeneric<T>()
    {
        var t = typeof(T);
        if (registeredTypes.ContainsKey(t) == false) throw new NotSupportedException();

        var typeToCreate = registeredTypes[t];
        return Activator.CreateInstance(typeToCreate, true) as IGeneric<T>;
    }

}

public interface IGeneric<TId>
{
    TId Id { get; set; }

    void ProcessEntity(TId id);
}

public class GenericInt : IGeneric<int>
{
    public int Id { get; set; }

    public void ProcessEntity(int id)
    {
        Console.WriteLine(id);
    }
}

public class GenericString : IGeneric<string>
{
    public string Id { get; set; }

    public void ProcessEntity(string id)
    {
        Console.WriteLine(id);
    }
}

The answer marked correct is fine if you want to use Static class but but what if you want to return an DI injected type instead of newing an object? I suggest the following!

public interface IGenericFactory
{
    IGeneric<T> GetGeneric<T>() where T : class;
}

public class GenericFactory: IGenericFactory
{
    private readonly IGeneric<int> intGeneric;
    private readonly IGeneric<string> stringGeneric;
    public GenericFactory(IGeneric<int> intG, IGeneric<string> stringG)
    {
        intGeneric = intG;
        stringG = stringG;
    }

    public IGeneric<T> GetGeneric<T>() where T : class
    {
        if (typeof(T) == typeof(IGeneric<int>))
            return (IGeneric<T>)Convert.ChangeType(intGeneric, typeof(IGeneric<T>));

        if (typeof(T) == typeof(IGeneric<string>))
            return (IGeneric<T>)Convert.ChangeType(stringGeneric,typeof(IGeneric<T>));
        else 
            throw new NotSupportedException();
    }
}

Please note i simply injected the two expected return types for clarity in the constructor. I could have implemented the factory as a Dictionary and injected the return objects into this Dictionary. Hope it helps.

I'm thinking you don't want to have to enter the type parameter similar to the LINQ methods. However the magic behind that happens because the type parameter is used in the normal parameter definitions. For example in the ToList<string>() method you can see that TSource is used between the parenthesis.

public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source);

That's how the compiler knows that you want a List<string> if you call ToList() instead of ToList<string>() when called from an IEnumerable<string>

However, I don't think you need a generic type parameter in your factory method at all. All you have to do is create a non-generic version of your TGeneric<TId>

public interface IGeneric { }
public interface IGeneric<TId> : IGeneric
{
    void ProcessEntity(TId id);
}

And remove the <WhatGoesHere> from the CreateGeneric method:

public static IGeneric CreateGeneric(string recordType)
{
    if (recordType == "Client")
    {
        return new ClientEntity();
    }
    if (recordType == "Invoice")
    {
        return new InvoiceEntity();
    }
    return null;
}

If the function does not know the type, make it generic.

If the children are generics of different types (<int>, <string>), return object and cast inside the same factory class (Factory<T>), It is safe by typeof.

Personally, I prefer to specify the type with generics, without using an additional parameter, eg a string.

public class Program
{
    public static void Main(string[] args)
    {
        List<Number> something = new();
        Do(something);
    }
    public static void Do<T>(List<T> list) 
    {
        list.Add(Factory<T>.Create());
    }
}

public abstract class Factory<T>
{
     private static Object ConcreteF()
     {
          if (typeof(T) == typeof(Number))
                return new ChildGenericNumber();
          throw new Exception("");
     }
     public static T Create()
     {
          return (Factory<T>)ConcreteF()).Build();
     }
     protected abstract T Build();
}

What is required could be achieved may be not by Factory but a kind of Processor type of implementation.

Let say below is the generic interface:

public interface IGeneric<TId>
{
    void ProcessEntity(TId id);
}

Let say 2 classes which implement it are:

public class GenericInt : IGeneric<int>
{
        // DI Ctor
        public GenericInt(IDep1 dep, IDep2 dep2)
        {
            
        }
        public void ProcessEntity(int id)
        {
        }
}

public class GenericString : IGeneric<string>
{
        // DI Ctor
        public GenericString(IDep1 dep, IDep2 dep2)
        {
            
        }
        public void ProcessEntity(string id)
        {
        }
}

Now the below class is not exactly a factory but kind of processor:

public class Processor
{
    public Processor(IServiceProvider)
    {
       _serviceProvider = serviceProvider;
    }
    public void Execute(object o)
    {
        var handlerType = typeof(IGeneric<>).MakeGenericType(o.GetType());
        var handler = _serviceProvider.GetService(handlerType);
        var method = handlerType.GetMethod("ProcessEntity");
        method.Invoke(handler, new object[] { o });
    }
} 

It can be used as below:

   public class Program
    {
       public void Main()
       {
         // Here ioc is actually service provider -> IServiceProvider
         var handlerProvider = ioc.GetRequiredService<Processor>();
         handlerProvider.Execute("string"); // string
         handlerProvider.Execute(123); // int
       }
      
    }

Above approach won't give the object of the type but in a generic way we can execute the required function without the orchestrating code (Program in our case) knowing about it.