switch and nullable type in C# 2.0

[Yuriy Solodkyy]

Hi

VS 2005 beta 2 successfully compiles the following:

using System;
using System.Collecti ons.Generic;
using System.Text;

namespace ConsoleApplicat ion1 {
class Program {
enum A { a, b, c }
static void Main(string[] args) {
A? aaaa = null;
switch (aaaa) {
case null:
Console.WriteLi ne("null");
break;
default:
Console.WriteLi ne("def");
break;
}
}
}
}

Any comments on nullables in switch?

Thank you
Yuriy

[Oliver Sturm]

Yuriy Solodkyy wrote:

Any comments on nullables in switch?

I'm sure it's me, but I don't understand the question. :-)

Oliver Sturm
--
Expert programming and consulting services available
See http://www.sturmnet.org (try /blog as well)

[Octavio Hernandez]

Hi,

Don't see any problems with that...

Regards - Octavio

"Yuriy Solodkyy" <y.************ @gmail.com> escribió en el mensaje
news:7c******** *************** ***@msnews.micr osoft.com...

Hi

VS 2005 beta 2 successfully compiles the following:

using System;
using System.Collecti ons.Generic;
using System.Text;

namespace ConsoleApplicat ion1 {
class Program {
enum A { a, b, c }
static void Main(string[] args) {
A? aaaa = null;
switch (aaaa) {
case null:
Console.WriteLi ne("null");
break;
default:
Console.WriteLi ne("def");
break;
}
}
}
}

Any comments on nullables in switch?

Thank you
Yuriy

[Yuriy Solodkyy]

hi,

which types are allowed in switch? string and integral types?
or any type, if there is only one way of implicit convertion to any of the
types mentioned above.

Nullable<> is neither string nor integral type, and I cannot find anything
where it is said that C# 2.0 enhances a list of types allowed in switch.

yuriy

Yuriy Solodkyy wrote:

Any comments on nullables in switch?

I'm sure it's me, but I don't understand the question. :-)

Oliver Sturm

[Oliver Sturm]

Yuriy Solodkyy wrote:

which types are allowed in switch? string and integral types? or any
type, if there is only one way of implicit convertion to any of the types
mentioned above.

Nullable<> is neither string nor integral type, and I cannot find anything
where it is said that C# 2.0 enhances a list of types allowed in switch.

Here's what the specs say (C# 1.2):

The governing type of a switch statement is established by the switch
expression. If the type of the switch expression is sbyte, byte, short,
ushort, int, uint, long, ulong, char, string, or an enum-type, then that
is the governing type of the switch statement. Otherwise, exactly one
user-defined implicit conversion (§?6.4) must exist from the type of the
switch expression to one of the following possible governing types: sbyte,
byte, short, ushort, int, uint, long, ulong, char, string. If no such
implicit conversion exists, or if more than one such implicit conversion
exists, a compile-time error occurs.

The constant expression of each case label must denote a value of a type
that is implicitly convertible (§?6.1) to the governing type of the switch
statement. A compile-time error occurs if two or more case labels in the
same switch statement specify the same constant value.

Oliver Sturm
--
Expert programming and consulting services available
See http://www.sturmnet.org (try /blog as well)

[Yuriy Solodkyy]

What is Nullable<A> in this list? Do you know any implicit convertions from
A? to any of the types listed in spec?

yuriy

Yuriy Solodkyy wrote:

which types are allowed in switch? string and integral types? or
any type, if there is only one way of implicit convertion to any of
the types mentioned above.

Nullable<> is neither string nor integral type, and I cannot find
anything where it is said that C# 2.0 enhances a list of types
allowed in switch.

Here's what the specs say (C# 1.2):

The governing type of a switch statement is established by the switch
expression. If the type of the switch expression is sbyte, byte,
short, ushort, int, uint, long, ulong, char, string, or an enum-type,
then that is the governing type of the switch statement. Otherwise,
exactly one user-defined implicit conversion (§?6.4) must exist from
the type of the switch expression to one of the following possible
governing types: sbyte, byte, short, ushort, int, uint, long, ulong,
char, string. If no such implicit conversion exists, or if more than
one such implicit conversion exists, a compile-time error occurs.

The constant expression of each case label must denote a value of a
type that is implicitly convertible (§?6.1) to the governing type of
the switch statement. A compile-time error occurs if two or more case
labels in the same switch statement specify the same constant value.

Oliver Sturm

[Oliver Sturm]

Yuriy Solodkyy wrote:

What is Nullable<A> in this list? Do you know any implicit convertions
from A? to any of the types listed in spec?

A Nullable<T> can be used in a switch statement if T itself has an
implicit conversion to one of the listed types, or is a listed type. In
your case, that's the Enum. If you try your sample with a Nullable<T>
where T is an arbitrary class, you'll see that the compiler complains
about it, even if you're still only checking for the null case.

I wonder why you're wondering about this so much... to my mind, this
construct behaves just like one would think it should, doesn't it? IOW, if
a type T can be used in a switch, then T? can be used as well, and can
additionally be checked for the null case. Makes a lot of sense to me.
Oliver Sturm
--
Expert programming and consulting services available
See http://www.sturmnet.org (try /blog as well)

[Yuriy Solodkyy]

Nullable<Snum> is not enum itself. It is just value type, which has no implicit
conversion to niether the enum or listed type. so, according to your explanation
in cannot be used in switch, but it works.

Yuriy Solodkyy wrote:

What is Nullable<A> in this list? Do you know any implicit
convertions from A? to any of the types listed in spec?

A Nullable<T> can be used in a switch statement if T itself has an
implicit conversion to one of the listed types, or is a listed type.
In your case, that's the Enum. If you try your sample with a
Nullable<T> where T is an arbitrary class, you'll see that the
compiler complains about it, even if you're still only checking for
the null case.

I wonder why you're wondering about this so much... to my mind, this
construct behaves just like one would think it should, doesn't it?
IOW, if a type T can be used in a switch, then T? can be used as well,
and can additionally be checked for the null case. Makes a lot of
sense to me.

Oliver Sturm

[Octavio Hernandez]

Yuri,

Quoting the C# Specification, 3rd Edition (p. 228):

"The governing type of a switch statement is established by the switch
expression. If the type of the switch
expression is sbyte, byte, short, ushort, int, uint, long, ulong, char,
string, or an enum-type,

then that is the governing type of the switch statement. Otherwise, exactly
one user-defined implicit

conversion operator (§13.4) shall exist from the type of the switch
expression or a base type of this type to

one of the following possible governing types: sbyte, byte, short, ushort,
int, uint, long, ulong,

char, string. If no such implicit conversion operator exists, or if more
than one such implicit conversion

operator exists, a compile-time error occurs."

This covers the case of a nullable type as switch expression, right?

The standard is at www.ecma-international.org.

Privet - Octavio

"Yuriy Solodkyy" <y.************ @gmail.com> escribió en el mensaje
news:7c******** *************** ***@msnews.micr osoft.com...

hi,

which types are allowed in switch? string and integral types? or any
type, if there is only one way of implicit convertion to any of the types
mentioned above.

Nullable<> is neither string nor integral type, and I cannot find anything
where it is said that C# 2.0 enhances a list of types allowed in switch.

yuriy

Yuriy Solodkyy wrote:

Any comments on nullables in switch?

I'm sure it's me, but I don't understand the question. :-)

Oliver Sturm

[Oliver Sturm]

Yuriy Solodkyy wrote:

Nullable<Snu m> is not enum itself. It is just value type, which has no
implicit conversion to niether the enum or listed type. so, according to
your explanation in cannot be used in switch, but it works.

I wasn't saying that Nullable<Enum> is an Enum. I'm sure the conversion
that's taking place is actually covered by paragraph 24.2 of the C# 2.0
specs - read it if you like, I guess the relevant point for your sample is
the last one in 24.2.2:

If the nullable conversion is from S? to T, the conversion is evaluated as an unwrapping from S? to S followed by the underlying conversion from S to T.

If you decompile a program similar to your sample, you'll see that the
compiler creates calls to the GetValueOrDefau lt method of the Nullable<T>,
before the comparison itself takes place. This allows for constructs like

int? foo = 42;
if (foo == 42)
...

Or of course for the use of the Nullable<T> in a switch statement, such as
we were discussing.
Oliver Sturm
--
Expert programming and consulting services available
See http://www.sturmnet.org (try /blog as well)