Compiler Error CS0702

[=?Utf-8?B?UElFQkFMRA==?=]

I'd really like to be able to constrain a generic type to System.Enum or,
better, enum. But of course that results in "Compiler Error CS0702".

So far I've been checking the type parameter at runtime and throwing an
exception if the provided type is not an enum. That works, but it just
doesn't seem quite right.

After reading through section 4.4.4 of the C# 3.0 spec I see no reason why
constraining to System.Enum should not be allowed.

So my questions are:
Are there reasons why these types can't or shouldn't be supported as
constraints?
(If so, the documentation of Compiler Error CS0702 ought to state them.)
Is this simply a limitation of the compiler rather than of the language?
Are efforts being to made to support these types as constraints?

[Peter Duniho]

On Thu, 17 Apr 2008 09:31:03 -0700, PIEBALD
<PI*****@discus sions.microsoft .comwrote:

I'd really like to be able to constrain a generic type to System.Enum or,
better, enum. But of course that results in "Compiler Error CS0702".

So far I've been checking the type parameter at runtime and throwing an
exception if the provided type is not an enum. That works, but it just
doesn't seem quite right.

After reading through section 4.4.4 of the C# 3.0 spec I see no reason
why
constraining to System.Enum should not be allowed.

I guess I'm a bit confused about the relationship between C# version and
specification version.

I'm looking at "Standard ECMA-334", 4th edition, June 2006. There's no
"section 4.4.4". The document I'm looking at describes generic
constraints on page 405, section 25.7. And it describes the allowable
constraints to clearly exclude enums or other value types. The only
primary constraints allowed are an actual reference (class) type, or the
keywords "class" or "struct".

What is giving you the impression that the specification would allow an
enum as a type constraint?

So my questions are:
Are there reasons why these types can't or shouldn't be supported as
constraints?

Well, I think the most obvious reason is that since value types can't
inherit other value types, if you're constraining the class to allow only
one specific value type, then there's no need for the class to be generic
in the first place. You'd only ever be able to use that generic class
with one specific type.

Since an enum is a value type, it would fall into that same reasoning.

(If so, the documentation of Compiler Error CS0702 ought to state them.)
Is this simply a limitation of the compiler rather than of the language?

See above. As I read it, this is clearly described as part of thelanguage.

Are efforts being to made to support these types as constraints?

Not to my knowledge. I don't see why any effort would be made, given the
above.

Pete

[Peter Duniho]

On Thu, 17 Apr 2008 09:57:50 -0700, Peter Duniho
<Np*********@nn owslpianmk.comw rote:

[...]

>After reading through section 4.4.4 of the C# 3.0 spec I see no reason
why
constraining to System.Enum should not be allowed.

I guess I'm a bit confused about the relationship between C# version and
specification version.

I'm looking at "Standard ECMA-334", 4th edition, June 2006. There's no
"section 4.4.4". The document I'm looking at describes generic
constraints on page 405, section 25.7. And it describes the allowable
constraints to clearly exclude enums or other value types. The only
primary constraints allowed are an actual reference (class) type, or the
keywords "class" or "struct".

Okay...I found the C# 3.0 specification. I guess ECMA hasn't adopted it
yet? I don't see it anywhere on their web site.

Anyway, section 4.4.4 has to do with satistfying constraints when _using_
a generic. I don't see how that's relevant with respect to what
constraints you can declare for a generic.

Which brings me back to my previous question:

What is giving you the impression that the specification would allow an
enum as a type constraint?

Specifically, can you quote any text from the C# specification that
directly leads you to believe that you should be able to specify an enum
type as a constraint for a generic?

Pete

[=?Utf-8?B?UElFQkFMRA==?=]

I'm looking at "Standard ECMA-334", 4th edition, June 2006. There's no

I'm looking at the "C# Language Specification Version 3.0" available at
http://msdn2.microsoft.com/en-us/vcsharp/aa336809.aspx

[Paul E Collins]

"PIEBALD" <PI*****@discus sions.microsoft .comwrote:

I'd really like to be able to constrain a generic type to System.Enum
or, better, enum. But of course that results in "Compiler Error
CS0702". [...] Are there reasons why these types can't or shouldn't be
supported as constraints?

This is basically because enum types aren't really inherited from the
base types, despite the colon notation. For example, if you write "enum
X : byte", it means that every member of X *is* a byte and not that X is
anything like a class derived from byte. (If you try to derive a class
from byte, you'll see that you can't possibly do so: it's a sealed
class.)

So far I've been checking the type parameter at runtime and throwing
an exception if the provided type is not an enum. That works, but it
just doesn't seem quite right.

An alternative would be to require a type "where T : MyEnumWrapper", and
have MyEnumWrapper be a wrapper for a single value of that particular
enum. Ugly, certainly, but you could have compile-time type safety if
you did that.

Eq.

[Peter Duniho]

On Thu, 17 Apr 2008 10:33:20 -0700, Paul E Collins
<fi************ ******@CL4.orgw rote:

"PIEBALD" <PI*****@discus sions.microsoft .comwrote:

>I'd really like to be able to constrain a generic type to System.Enum
or, better, enum. But of course that results in "Compiler Error
CS0702". [...] Are there reasons why these types can't or shouldn't be
supported as constraints?

This is basically because enum types aren't really inherited from the
base types, despite the colon notation. For example, if you write "enum
X : byte", it means that every member of X *is* a byte and not that X is
anything like a class derived from byte. (If you try to derive a class
from byte, you'll see that you can't possibly do so: it's a sealed
class.)

"byte" isn't a class at all, never mind a sealed one. It's a struct
(thus, a value type):
http://msdn2.microsoft.com/en-us/system.byte.aspx

Likewise, an enum is a value type.

>So far I've been checking the type parameter at runtime and throwing
an exception if the provided type is not an enum. That works, but it
just doesn't seem quite right.

An alternative would be to require a type "where T : MyEnumWrapper", and
have MyEnumWrapper be a wrapper for a single value of that particular
enum. Ugly, certainly, but you could have compile-time type safety if
you did that.

Even more so than a generic constrained to just a single type, I don't see
what the value in a generic constrained to a single value of a single type
would be.

Pete

[=?Utf-8?B?UElFQkFMRA==?=]

What is giving you the impression that the specification would allow an

enum as a type constraint?

Specifically, can you quote any text from the C# specification that
directly leads you to believe that you should be able to specify an enum
type as a constraint for a generic?

More the _absence_ of a restriction in that section.
According to http://msdn2.microsoft.com/en-us/lib...tem.enum.aspx:

"
Enum Class
Provides the base class for enumerations.
"

all enums derive from System.Enum. System.Enum _should_ satisfy section 4.4.4

"
o An implicit reference conversion (§6.1.6)
"

"
6.1.6 Implicit reference conversions
The implicit reference conversions are:
....
• From any class-type S to any class-type T, provided S is derived from T
....
"

So, it seems to me that System.Enum is a class and a particular enum derives
from it, so the language seems to allow it.

BUT, the Microsoft _implementation _ of the C# language (Visual C#) targets
..net, and in fact, the error says:

"
CS0702: Constraint cannot be special class 'System.Enum'
"

and I draw particular attention to the word "special". Of all the classes in
..net, very few are "special".

The existence of System.Enum as a base class for enums should _enable_ its
use as constraints. I see no restriction in the specification to _disallow_
it.

[=?Utf-8?B?UElFQkFMRA==?=]

P.S. If not 6.1.6:

all enums derive from System.Enum. System.Enum _should_ satisfy section 4.4.4

"
o A boxing conversion (§6.1.7), provided that type A is a non-nullable value
type.
"

"
6.1.7 Boxing conversions
A boxing conversion permits a value-type to be implicitly converted to a
reference type. A boxing conversion exists from any non-nullable-value-type
to object, to System.ValueTyp e and to any interface-type implemented by the
non-nullable-value-type. Furthermore an enum-type can be converted to the
type System.Enum.
"

[Peter Duniho]

On Thu, 17 Apr 2008 11:16:01 -0700, PIEBALD
<PI*****@discus sions.microsoft .comwrote:

[...]
and I draw particular attention to the word "special". Of all the
classes in
.net, very few are "special".

That's correct. And the "special" is IMHO important. They are telling
you that it's not really a class. You can't inherit it, for example.
It's a façade, one that exists to make particular aspects of the type more
seamless. The type isn't _really_ a class.

An enum is still basically a value type...that is, it behaves more like a
value type than a reference type, and it's reference types that can be
used as a constraint.

The existence of System.Enum as a base class for enums should _enable_
its
use as constraints. I see no restriction in the specification to
_disallow_
it.

Well, this seems like a classic example of how biases affect our reading
of information. You want to constrain the generic to only support enums,
so of course you're predisposed to not read the information in a way that
would contradict that. On the other hand, my bias is towards explaining
how the specification adequately describes what you're seeing, so I'm
predisposed to reading the information in a way that does contradict your
position.

Sorry to say, there's really not much way around that. The fact is, you
can't constrain your type parameters to the System.Enum. You can insist
that the specification doesn't address that issue all you want, it's not
going to change how things work.

By the way, in the ECMA specification, they suggest using a static
constructor for checking the constraint, for situations where the language
doesn't support the constraint you want. That would at least ensure that
the constraint is checked only once, when you first use the class with
that specific enum type, rather than for each instance of the class you
create.

Of course, if you're trying to constrain something other than a class, I
guess that wouldn't apply. :)

Pete

[=?Utf-8?B?UElFQkFMRA==?=]

my bias is towards explaining how the specification adequately describes
what you're seeing

No, the specification doesn't. Certainly the specification allows the
keywords class and struct as constraints while (regrettably) omitting enum
(and delegate and event), so perhaps one can read _that_ as a statement in
your favor. But...

From a language standpoint (not an implementation standpoint) I see no
reason to omit enum as a constraint in the first place.

If an implementer (and there _could_ conceivably be many implementations for
various platforms) chooses to implement enum as a class, then that class
_should_ be allowed as a constraint. But while Microsoft chose to use a class
to implement enums, for some unexplained reason, they also chose to make it
"special".

The fact is, you
can't constrain your type parameters to the System.Enum. You can insist
that the specification doesn't address that issue all you want, it's not
going to change how things work.

No, the specification knows nothing of System.Enum, that's merely a matter
of implementation.

The specification says that if a type has a base class you can use that base
class as a constraint. But, when implementing .net and its associated
compiler, someone decided that that shouldn't hold true for some classes even
though there appears to be no reason for that decision.

By the way, in the ECMA specification, they suggest using a static
constructor for checking the constraint, for situations where the language
doesn't support the constraint you want. That would at least ensure that
the constraint is checked only once, when you first use the class with
that specific enum type, rather than for each instance of the class you
create.

I'll take a look.