Operator "is" Returns true for T and Non-null T?

The semantics of the is operator have been changed according to Nullable<T> boxing and unboxing changes. The following two examples equate to true when x is either T or a non-null T?. Otherwise, each example equates to false.

// true when x is T or a non-null T?; otherwise, false.x is T?
// true when x is T or a non-null T?; otherwise, false
x is T
Given the following initialization of x, y, and z, the Boolean values for b1, b2, b3, and b4 are determined as shown in the following example:
//

[c#]
int? x = null;
int? y = 10;
int z = 10;

// False; x is boxed as null, null is
// always false.

bool b1 = (x is int?);

// True; y is boxed as int, new behavior
// ensures this is true.

bool b2 = (y is int?);

// True; z is boxed as int, same as b2
// (cannot differentiate).

bool b3 = (z is int?);

// True; y and z are boxed as int, ordinary
// check applies.

bool b4 = (y is int) && (z is int);

int i = 5;
if ( i == null )
  Console.WriteLine ("null");
if ( 5 == null )
  Console.WriteLine ("null");

A__>>Так же, как компилируется i is object, i is SomeType и проч. зачем тогда вообще нужен is? Я понимаю, четыре часа ночи...

M>            int i;
M>            Console.Write( i is int? );
M>

M>            int? i;
M>            Console.Write( i is int );
M>

An is expression evaluates to true if the provided expression is non-null, and the provided object can be cast to the provided type without causing an exception to be thrown.

An is expression evaluates to true if the provided expression is non-null, and the provided object can be cast to the provided type without causing an exception to be thrown.

Mab>VS2005 считает такой код корректным (а вот Решарпер не считает, о чем уже оформлен соответствующий баг )

        Console.WriteLine(TypeOf i Is Integer)
        Console.WriteLine(TypeOf i Is Test(Of Integer)()) ' а тут false
        Console.WriteLine(TypeOf i Is Nullable(Of Integer))

is (C# Reference)

Checks if an object is compatible with a given type...

. . .

An is expression evaluates to true if ... object can be cast to the provided type without causing an exception to be thrown

            int i = 0;
            int? ni;
            ni = (int?)i;

Note that the is operator only considers reference conversions, boxing conversions, and unboxing conversions. Other conversions, such as user-defined conversions, are not considered.

The is operator (§7.9.9) is extended to support nullable types. An operation of the form e is T, where e is an expression and T is a type, is evaluated as follows, after type arguments have been substituted for all type parameters:
• If the type of e is a reference type or a nullable type and the value of e is null, the result is false.
• Otherwise, let D represent the dynamic type of e as follows:
o If the type of e is a reference type, D is the run-time type of the instance reference by e.
o If the type of e is a nullable type, D is the underlying type of that nullable type.
o If the type of e is a non-nullable value type, D is the type of e.
• The result of the operation depends on D and T as follows:
o If T is a reference type, the result is true if D and T are the same type, if D is a reference type and an implicit reference conversion from D to T exists, or if D is a value type and a boxing conversion from D to T exists.
o If T is a nullable type, the result is true if D is the underlying type of T.
o If T is a non-nullable value type, the result is true if D and T are the same type.
o Otherwise, the result is false.

void f()
{
    int a = 0;
    int b = a is int + a is int; // int b = ( ( a is int ) + a ) is int;
    int b = a is int? + a is int; // int b = ( a is int ) ? ( ( + a ) is int ); error: expected ':'
}

void f()
{
    int a = 0;
    int b = a is int? + a is int? + a : a;
}

VD>int i = 0;
VD>Console.WriteLine(i is int?);
VD>Console.WriteLine(i is int? "+" : "-");

Console.WriteLine(i is int ? ? "+" ?? "*" : "-");

1.1.4 stable rev. 510

int? a = 5;
int b = 5;

(TimeSpan.FromDays(1)+(DateTime?)Now).HasValue;

1.1.4 stable rev. 510

14.2.7 Lifted operators
Lifted operators permit predefined and user-defined operators that operate on non-nullable value types to
also be used with nullable forms of those types. Lifted operators are constructed from predefined and userdefined
operators that meet certain requirements, as described in the following:
• For the unary operators
+ ++ — -- ! ~
a lifted form of an operator exists if the operand and result types are both non-nullable value types. The
lifted form is constructed by adding a single ? modifier to the operand and result types. The lifted operator
produces a null value if the operand is null. Otherwise, the lifted operator unwraps the operand, applies the
underlying operator, and wraps the result.
...