Some of the existing answers aren't quite right. You can't use non-nullable types with as
, because the result of as
is the null value of the type if the first operand isn't actually of an appropriate type.
However, you can use as
with value types... if they're nullable:
int a = 10;
object o = a;
int? x = o as int?; // x is a Nullable<int> with value 10
long? y = o as long?; // y is a Nullable<long> with the null value
So you could use:
Call? call = line.Tag as Call?;
Then you can use it as:
if (call != null)
{
// Do stuff with call.Value
}
Two caveats though:
- In my experience this is slower than just using
is
followed by a cast
- You should seriously reconsider your current
Call
type:
- It's exposing public fields, which is generally poor encapsulation
- It's a mutable value type, which is almost certainly a mistake
I would strongly suggest you make it a class instead - at which point this problem goes away anyway.
Another thought: if the tag should always be a Call
, then it's better to cast it:
Call call = (Call) line.Tag;
That way, if the data doesn't match your expectation (i.e. there's some bug such that the Tag
isn't a Call
) then you get to find out about it early, rather than after you've potentially done some other work. Note that this cast will behave differently depending on whether Call
is a struct or a class, if Tag
is null - you can cast a null value to a variable of a reference type (or a nullable value type), but not to a non-nullable value type.
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…