Converting from one nullable type to another nullable type

Question

How can one convert from a nullable instance of class A to nullable instance of class B, while B is subclass of A, I tried this but it crashes:

class A
{
}

class B:A
{
}

A? instance_1=something_maybe_null;

if (instance_1.GetType() == typeof(B))
{
    ((B)(instance_1))?.some_method_in_B(paramters);
}

And if I move ? into parathesis, it doesn't compile:

...
if (instance_1.GetType() == typeof(B))
{
    ((B)(instance_1)?).some_method_in_B(paramters);
}

You can't have nullable reference types, only nullable value-types! Classes are reference types that can be null by default. Therefore `A?` ist not valid if A is a class. — JanDotNet, Jun 06 '17 at 06:33
Check this : https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/using-nullable-types — AVEbrahimi, Jun 06 '17 at 06:40
`?.` is null-conditional operator, which check null value before performing member access operation (https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-conditional-operators). Entire operation stops if the left side operator contains null value. — Tetsuya Yamamoto, Jun 06 '17 at 06:44
@TetsuyaYamamoto: What you're saying is true, but `A? instance_1=something_maybe_null;` is not using the null conditional, it is a type declaration of type `A?` (which is shorthand for `Nullable`) — Flater, Jun 06 '17 at 07:12
@AVEbrahimi nullable types are *not* option types or values like those found in F# or Scala. They are a way to specify null for struct types *only*. You can't use them as the equivalent of `Option` — Panagiotis Kanavos, Jun 06 '17 at 07:14
`A? instance_1` certainly is a `Nullable` declaration, **but** `((B)(instance_1))?.some_method_in_B(parameters)` is null-conditional operation between `instance_1` cast and executing `some_method_in_B` if it's not null. If B is also a value type, you can use `((B?)(instance_1)).some_method_in_B(parameters)`. — Tetsuya Yamamoto, Jun 06 '17 at 07:16
@AVEbrahimi if you want Option types, check David Arno's [SuccincT](https://github.com/DavidArno/SuccincT) library and its [Option, Maybe classes and helpers](https://github.com/DavidArno/SuccincT/tree/master/src/SuccincT/Options). Pattern matching in C# 7 is another way you can implement and use Option classes — Panagiotis Kanavos, Jun 06 '17 at 07:17
Please note that `Nullable Reference Types` is a `C# 8` feature, and it's [already in prototype phase](https://www.infoq.com/news/2017/04/CSharp-Nullable). [Current proposal on Github](https://github.com/dotnet/csharplang/blob/master/proposals/nullable-reference-types.md), [Open Discussion on Github.](https://github.com/dotnet/csharplang/issues/36) — VMAtm, Jun 12 '17 at 15:41

Ilian · Accepted Answer · 2017-06-06T07:11:00.133

I am assuming this is a typo A? instance_1=something_maybe_null; because you cannot do nullable reference types (i.e. classes), at least in C# 6.

If I understand your intent correctly, you just want to conditionally call a method in B if the object is actually an instance of B. If so, then you can do this:

class A
{
}

class B : A
{
    public void SomeMethodInB() {  }
}

A instance_a = something_maybe_null;
B instance_b = instance_a as B;
instance_b?.SomeMethodInB();

Converting from one nullable type to another nullable type

1 Answers1