C# Expression Bodied Constructor - Is there a way to combine with null checking? - c#-7.0

Question

Is there a recommended or prefered way to combine C#7 "Expression Bodied Constructors" with other activities, such as null checking and exception throwing?
When writing a C# class, I am accustomed to being able to test arguments for nulls (and throw exceptions if needed) in my constructor, like this:-
class Person
{
private string _name;
private SomeClass _someClass;
public Person(string name, SomeClass someClass)
{
_name = name ?? throw new ArgumentNullException(nameof(name));
_someClass = someClass?? throw new ArgumentNullException(nameof(someClass));
}
}
I have just learned about Expression Bodied Constructors, where a simple version of my code could look like this:-
class Person
{
private string _name;
private SomeClass _someClass;
public Person(string name, SomeClass someClass)
=> (_name, _someClass) = (name, someClass);
}
The above initially seems appealing because of the potential to reduce the amount of boilerplate code needed to assign arguments to member variables.
However, I seem to have lost the opportunity to include activities such as the aforementioned null checking, as there is no longer a constructor body.
As far as I can tell, the only way around this is to inline code, such as my null-coalesce check, like this :-
...
public Person(string name, SomeClass someClass)
=> (_name, _someClass) =
(
name ?? throw new ArgumentNullException(nameof(name ),
someClass ?? throw new ArgumentNullException(nameof(someClass)
));
Even though I have attempted to improve legibility through spacing, in my opinion, the above is not as easy to read as the original example - and has not really saved any typing.
Q: Is there a better way that I could approach this, or am I defeating the purpose of this new style of constructor? (i.e. should I just stick with the original approach)

Answer 1

I'm not going to criticize you for trying. 😊
The fact is that both versions generate pretty much the same code.
class Person
{
private string _name;
private string _someClass;
public Person(string name, string someClass)
{
_name = name ?? throw new ArgumentNullException(nameof(name));
_someClass = someClass?? throw new ArgumentNullException(nameof(someClass));
}
}
becomes
class Person
{
private string _name;
private string _someClass;
public Person(string name, string someClass)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
_name = name;
if (someClass == null)
{
throw new ArgumentNullException("someClass");
}
_someClass = someClass;
}
}
see it on sharplab.io
and
class Person
{
private string _name;
private string _someClass;
public Person(string name, string someClass)
=> (_name, _someClass) =
(
name ?? throw new ArgumentNullException(nameof(name)),
someClass ?? throw new ArgumentNullException(nameof(someClass))
);
}
becomes
class Person
{
private string _name;
private string _someClass;
public Person(string name, string someClass)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (someClass == null)
{
throw new ArgumentNullException("someClass");
}
_name = name;
_someClass = someClass;
}
}
see it on sharplab.io

Answer 2

I see the "Tuple assignment" style as a nice brief way to say "my class is initialised from these members and nothing else is going on". I can glance at it and immediately know that's what the author intended.
As soon as one more thing is happening (validation in your example), then you should use a full blown constructor. As you say, you can do it, but it reads a lot worse.
Really, we're only using this style because we don't have record types yet. When we have those, I don't think we'll see this cropping up in code so much.