如何确保显式运算符在转换 null 时抛出异常？ （不可为空）

Question

I have an explicit operator on the class MyVO , which should be non-nullable.

public class MyVO : ValueObject<MyVO>
{
    public string Value { get; } // Should never be null

    private MyVO(string v) => Value = v;

    public static explicit operator MyVO(string vo)
    {
        if (string.IsNullOrWhiteSpace(vo)) throw new Exception('...');
        return new MyVO(vo);
    }

However, (MyVO)null will not raise an exception. The body of the method will not be run.

var myVO = (MyVO)null; // myVO will have the null value

How to make sure it's not null?

Answer 1

How to make sure it's not null?

By "it" I assume you mean "the result of the cast from null to MyVO ". If that is not what you mean, please clarify the question.

You cannot.

An important rule of C# is a user-defined conversion never "wins" when it conflicts with a built-in conversion . It is legal to convert null to any class type, and so a cast of MyVO on the expression null will always result in a null reference. The compiler does not even consider the user-defined conversions if a built-in conversion works. (Believe me; I wrote that code!)

As D Stanley's answer correctly points out, if the null is the value of any expression of type string then the user-defined conversion is called; there is no built-in conversion from string to MyVO so the compiler looks for an applicable user-defined conversion and finds one.

Since it hurts when you do what you're doing, you should probably stop doing what you are doing. An explicit conversion is probably not the right way to implement the desired behaviour.

I guess my question should be how to make MyVO not nullable.

Upgrade to C# 8. C# 8 supports non-nullable annotations on reference types.

Note that the non-nullable annotation should be properly thought of as an annotation . The type system does not guarantee that the value of a variable annotated with a non-nullable annotation will never be observed to be null. Rather, it does its best to warn you when the code looks like it is wrong.

---

While we are looking at your code, I notice that you are using ValueObject<T> , which I assume you have obtained from something like

https://enterprisecraftsmanship.com/posts/value-object-better-implementation/

Let me take this opportunity to caution you that there are pitfalls to using this pattern; the constraint that you think or want to be applied to T is not the constraint that is applied to T . We often see things like this:

abstract class V<T> where T : V<T>
{
  public void M(T t) { ... }  // M must take an instance of its own type
}

If we have class Banana : V<Banana> then Banana.M takes as its argument a Banana , which is what we want. But now suppose we have class Giraffe : V<Banana> . In this scenario, Giraffe.M does not take a giraffe; it takes a banana, even though Giraffe has no relationship with Banana at all.

The constraint does not mean that M always takes an instance of its own class. If you are trying to construct a generic type with this kind of constraint in C#, you cannot; the C# type system is not rich enough to express that constraint.

Answer 2

null can be implicitly converted to any reference type, so the compiler is not using your explicit cast operator. try

string s = null;
o = (MyVO)s;

or just inline it

o = (MyVO)((string)s);