An advantage of generic classes in C# is that one can put constraints on the types so only types who satisfy several constraints are accepted. For instance:

```
public class Foo<T> where T : Bar, IBaz, IFoobar {

    public Foo (T value) {
        //initialize
    }

}

```

This means `T` can only be unified with types who are derived from the three described classes.

When using methods one can make the methods generic as well. I was wondering however why one can't specify such constraint in a constructor. For instance:

```
public class Foo {

    public Foo (Bar & IBaz & IFoobar value) {
        //initialize (the "&" syntax is just an example)
    }

}

```

One can make the class generic, but this can be rather cumbersome if only the constructor will use the `value` and other methods of the class do not depend on `T`. Some problems might even be difficult to resolve with generic classes for instance one needs to write a comparer `SomeComparer<T,Q> : IComparer<Foo<T>,Foo<Q>>` introducing loads of generic classes who are in fact not generic at all.

I don't see why this is not implemented since the type system can easily check if an argument satisfies all type constraints.

What are the arguments not to define conjunctive types in the C# language specifications?