Nesting generic parameters

Question

Is possible to nest generic parameters like class MyClass<TG<TM>>{} ?

I tried some ways and got the following code that works, but the class declaration needs to receive the two parameters separated:

class MyClass1<TG, TM>
    where TM : MyType
    where TG : OtherType<TM> {

    public TM DoSomething() {
    }

    public TG DoSomething2() {
    }
}

Is that the only way ?

EDIT:

As you can see, I need the two generic parameters inside the class (members that use both: TM and TG), so TG is a generic parameter and cannot be a type (in that case), the answers and comments suggesting me to 'hardcode' one of the two parameters doesn't contribute to this question.

Well, with the above sample we can use it like (and works):

new MyClass<A<B>, B>();

The second parameter, in my case, would be always the same used with the nested parameter for the first parameter. So, I asked if we could omit the second parameter and the compiler infer it from the parameter of the first parameter.

Is something like that possible instead of having two separated parameters ?

Why are using two regular generic parameters a problem? You should describe what you're trying to do and why using that doesn't work. — Servy, Jan 30 '13 at 17:54
Would your invalid syntax have a different meaning to the compiler? Or are you just unhappy with the aesthetics? — itsme86, Jan 30 '13 at 17:55
What you want is that `MyClass1` has only one parameter, which itself is another generic type; so try `MyClass1 where TG : IEnumerable where TM : MyType`. — poke, Jan 30 '13 at 17:59
How are you use the `TG` type (both inside and out of `MyClass1` as DoSomething2 returns `TG`)? It may be possible for you to replace all reference of `TG` with `IEnumerable` and just get rid of the `TG` type parameter. — JG in SD, Jan 30 '13 at 18:09

score 2 · Answer 1 · answered Jan 30 '13 at 17:54

It depends on what you want to achieve. If you want MyClass1 to have two different generic parameters, the code you showed is the way to go.

class MyClass<TG<TM>>{}: That actually means that MyClass has a generic argument. And you are passing in TG<TM>, which means that TG also is a generic class that receives TM as its generic parameter.

So, to make that code work, you would need the following:

class TM {}
class TG<T> {}
class MyClass<T> {}

Now, you could call this:

new MyClass<TG<TM>>();

Nesting generic parameters

1 Answers1