Częściowa specjalizacja szablonów w C#

Cześć
w cpp jest takie coś jak specjalizacja szablonów oraz szablon dla przypadków ogólnych wtedy wpisuje się <char> <int> i wtedy kompilator zależnie od typu wywołuje albo specjalizację albo przypadek ogólny
jak takie coś zrobić w C#
mam np dwa typy Creator, Participant przetwarzam je, każdy na swój sposób, a na wyjściu mam szczegóły zdarzenia EventData

jak to zrobić żeby było dobrze
na razie zrobione jest to tak, ale nie podoba mi się to za bardzo

namespace Processor.Events
{
    public class RowProcessor
    {
        private sealed class RowProcessorCreator : IRowProcessor<Creator>
        {
            public IList<EventData> Process(IList<Creator> rows)
            {
             //do sth
            }
        }

        private sealed class RowProcessorParticipant : IRowProcessor<Participant>
        {
            public IList<EventData> Process(IList<Participant> rows)
            {
                //do sth
            }
        }

        public IList<EventData> Process<T>(IList<T> rows) where T : class
        {
            IRowProcessor<T> rowProcessor;
            if (typeof(T) == typeof(Participant))
            {
                rowProcessor = new RowProcessorParticipant() as IRowProcessor<T>;
            }
            else if (typeof(T) == typeof(Creator))
            {
                rowProcessor = new RowProcessorCreator() as IRowProcessor<T>;
            }
            else
            {
                throw new NotSupportedException("Row processor is not supported.");
            }

            return rowProcessor.Process(rows);
        }
    }
}

ale czy da się to jakoś lepiej - bez sprawdzania typu np, jako extension method
próby były - bez powodzenia

z góry dziękuję za pomoc i odpowiedź

po co komu jakieś patterny gdy jest refleksja? :D :D

jeszcze tylko dodać cache na <T, Implementation> i jest złoto :D

public class RowProcessorA : IRowProcessor<Participant>
{
	public IList<EventData> Process(IList<Participant> rows)
	{
		Console.WriteLine("A");
		return new List<EventData>();
	}
}

public class RowProcessoB : IRowProcessor<Creator>
{
	public IList<EventData> Process(IList<Creator> rows)
	{
		Console.WriteLine("B");
		return new List<EventData>();
	}
}

public static IList<EventData> Process<T>(IList<T> rows)
{
	var type = typeof(IRowProcessor<T>);

	var implementation = Assembly
						 .GetExecutingAssembly() // be careful
						 .GetTypes()
						 .FirstOrDefault(p => type.IsAssignableFrom(p));

	if (implementation == null)
	{
		throw new Exception("Row processor is not supported.");
	}

	var strategy = (IRowProcessor<T>)Activator.CreateInstance(implementation, new object[] { });

	return strategy.Process(rows);
}

public static void Main()
{
	var rows = new List<Participant>
	{
		new Participant()
	};

	Process(rows);
}