Using the "params" keyword for generic parameters in C#

C++11 has the feature that you're essentially talking about. They call it variadic templates.

C# generics aren't quite like C++ templates, though, and would make it difficult to build quite the same thing.

In the C++ case, the templates are expanded at compile time into whichever concrete types are used. In the C# case, the type specification happens entirely at runtime. And the resulting IL would need to support the number of different types encountered.

No, this cannot be done.

It's not as simple as treating it as an array of types (a concept which doesn't even exist in C#). Consider Func - the number of type parameters must be the same as the number of parameters of the delegate's Invoke method. But how would the programmer express such a relation between type parameters and regular parameters?

However, this feature does exist in C++11 - variadic templates. Note that C++ doesn't allow accessing the individual type parameters using array syntax - instead, functions usually separate the first type parameter from the rest, and use recursive calls to unpack the rest.

I just found myself curious to see if anyone else had a use for this. I just wrote a generic composer to build composites from mixins assembled using Castle Dynamic Proxy.

I built the composer to support two mixins and was about to proceed on "copying and pasting and adjusting (bleh)" the two mixin composer into 15 more variations up to a 17 mixing composer (similar to Func<T> through Func<T1...T16, T>). But then I thought, wouldn't it be great if I could just define Composer<TComposer, TIComposite, params TIMixin[]>!

Sadly, I'm off to copy and paste and adjust away (the very activity that generics help us avoid).

I had similar type of problem. I needed params KeyValuePair<Base, Implementation>[] pairs, where Implementation was inherited of Base.

Initially, I thought about IDictionary<Type, Type>, but that would kill Generics usage here.

So, what I did was create an Interface:

public interface IMapping
{
    Type Key { get; }
    Type Value { get; }
}

And its implementation:

public class Mapping<Base, Implementation> : IMapping where Base : class where Implementation : class, Base
{
    public Type Key => typeof(Base);
    public Type Value => typeof(Implementation);

}

Created a method:

public static void Initialize(params IMapping[] mappings)
{
    foreach (var mapping in mappings)
    {
        //We got our mapping, let's map
    }
}

And used it as:

Initialize(
    new Mapping<IMainView, MainView>(),
    new Mapping<IDashboardView, DashboardView>()
);

No, it is not possible to have an arbitrary number of generic arguments. It's probably also a silly idea, because generic type parameters aren't resolved at runtime, they're resolved at compile time, and so iterating over them like that isn't at all an obvious thing to be doing.

You might also think that Tuple<,,,,,,,,> might be an obvious place for it, but the solution there is when you run out of generic arguments, you make the last one a Tuple<,,,,> for the remaining fields.

I don't know if this would be useful, but a workaround could be :

Func<List<object>>

You would have to manually convert each element to the respective data type. You can use this iteratively:

 Convert.ChangeType(obj, obj.GetType())//using System;

And you could have the set of variables you want.