In .NET a value type (C# struct) can't have a constructor with no parameters. According to this post this is mandated by the CLI spec. What happes is that for every value-type a default constructor is created (by the compiler?) which initialized all members to zero (or null).

Does anyone know why it is disallowed to define such a default constructor?

Sure it should, that's why I wrote the default constructor in the first place, the CLR should use the default zeroing constructor when no explicit default ctor is defined, that way you only pay for what you use. Then if I want a container of 1000 non default Rationals (and want to optimize away the 1000 constructions) I will use a List<Rational> rather than an array.

This reason, in my mind, is not strong enough to prevent definition of a default constructor.

+1 had a similar problem once, finally converted the struct into a class.
–
Dirk Vollmar - 0xA3Dec 2 '08 at 12:46

3

The default parameters in C#4 cannot help because Rational() invokes the parameterless ctor rather than the Rational(long num=0, long denom=1).
–
LaTeXFeb 6 '11 at 15:05

SO what if you want to declare and use a complex value type that is a value in the DDD sense (i.e., immutable, and instantiate-able only through a static factory)? Is the only option to use a class instead?
–
Charles BretanaSep 11 '14 at 22:06

2

Note that in C# 6.0 which comes with Visual Studio 2015 it will be allowed to write zero-parameter instance constructors for structs. So new Rational() will invoke the constructor if it exists, however if it does not exist, new Rational() will be equivalent to default(Rational). In any case you are encouraged to use the syntax default(Rational) when your want the "zero value" of your struct (which is a "bad" number with your proposed design of Rational). The default value for a value type T is always default(T). So new Rational[1000] will never invoke struct constructors.
–
Jeppe Stig NielsenNov 20 '14 at 9:51

7 Answers
7

Note: the answer below was written a long time prior to C# 6, which is planning to introduce the ability to declare parameterless constructors in structs - but they still won't be called in all situations (e.g. for array creation).

EDIT: I've edited the answer below due to Grauenwolf's insight into the CLR.

The CLR allows value types to have parameterless constructors, but C# doesn't. I believe this is because it would introduce an expectation that the constructor would be called when it wouldn't. For instance, consider this:

MyStruct[] foo = new MyStruct[1000];

The CLR is able to do this very efficiently just by allocating the appropriate memory and zeroing it all out. If it had to run the MyStruct constructor 1000 times, that would be a lot less efficient. (In fact, it doesn't - if you do have a parameterless constructor, it doesn't get run when you create an array, or when you have an uninitialized instance variable.)

The basic rule in C# is "the default value for any type can't rely on any initialization". Now they could have allowed parameterless constructors to be defined, but then not required that constructor to be executed in all cases - but that would have led to more confusion. (Or at least, so I believe the argument goes.)

EDIT: To use your example, what would you want to happen when someone did:

Rational[] fractions = new Rational[1000];

Should it run through your constructor 1000 times?

If not, we end up with 1000 invalid rationals

If it does, then we've potentially wasted a load of work if we're about to fill in the array with real values.

EDIT: (Answering a bit more of the question) The parameterless constructor isn't created by the compiler. Value types don't have to have constructors as far as the CLR is concerned - although it turns out it can if you write it in IL. When you write "new Guid()" in C# that emits different IL to what you get if you call a normal constructor. See this SO question for a bit more on that aspect.

I suspect that there aren't any value types in the framework with parameterless constructors. No doubt NDepend could tell me if I asked it nicely enough... The fact that C# prohibits it is a big enough hint for me to think it's probably a bad idea.

Shorter explanation: In C++, struct and class were just two sides of the same coin. The only real difference is one was public by default and the other was private. In .Net, there is a much greater difference between a struct and a class, and it's important to understand it.
–
Joel CoehoornDec 2 '08 at 14:01

The CLR does allow value types to have parameterless constructors. And yes, it will run it for each and every element in an array. C# thinks this is a bad idea and doesn't allow it, but you could write a .NET language that does.
–
Jonathan AllenDec 3 '08 at 19:55

1

@Grauenwolf: I've managed to get a value type with a parameterless constructor to compile with ilasm, but the constructor isn't being run when I initialize an array. Is there anything special I'd need to put in the IL other than taking out the parameter from a parameterful constructor (cont)
–
Jon SkeetDec 3 '08 at 20:13

1

My information is based on "Framework Design Guidelines" 2nd edition. Upon rereading it, I think I may be wrong about it running the constructor for every slot in the array.
–
Jonathan AllenDec 3 '08 at 20:52

A struct is a value type and a value type must have a default value as soon as it is declared.

MyClass m;
MyStruct m2;

If you declare two fields as above without instantiating either, then break the debugger, m will be null but m2 will not. Given this, a parameterless constructor would make no sense, in fact all any constructor on a struct does is assign values, the thing itself already exists just by declaring it. Indeed m2 could quite happily be used in the above example and have its methods called, if any, and its fields and properties manipulated!

Not sure why someone voted you down. You appear to be the most correct answer on here.
–
pipTheGeekDec 3 '08 at 20:42

3

The behaviour in C++ is that if a type has a default constructor then that is used when such an object is created without an explicit constructor. This could have been used in C# to initialize m2 with the default constructor which is why this answer isn't helpful.
–
MottiDec 4 '08 at 8:46

I'm not really sure what you're looking for in an answer. I don't believe there is an overriding technical limitation, I believe it was a judgement call, personally I think a correct one. I wouldn't want my structs calling their own constructor when declared.
–
user42467Dec 5 '08 at 17:00

But you can't write special code for m2 = new MyStruct(); can you?
–
R. Martinho FernandesFeb 6 '09 at 12:14

1

onester: if you don't want the structs calling their own constructor when declared, then don't define such a default constructor! :) that's Motti's saying
–
Stefan MonovMay 22 '10 at 21:15

In C++, struct and class were just two sides of the same coin. The only real difference is that one was public by default and the other was private.

In .NET, there is a much greater difference between a struct and a class. The main thing is that struct provides value-type semantics, while class provides reference-type semantics. When you start thinking about the implications of this change, other changes start to make more sense as well, including the constructor behavior you describe.

You'll have to be a bit more explicit about how this is implied by the value vs. reference type split I don't get it...
–
MottiDec 2 '08 at 19:05

Value types have a default value- they are not null, even if you don't define a constructor. While at first glance this doesn't preclude also defining a default constructor, the framework using this feature internal to make certain assumptions about structs.
–
Joel CoehoornDec 2 '08 at 21:50

4

one wonders why other constructors are allowed then
–
annakataFeb 6 '09 at 12:22

@annakata: Other constructors are probably useful in some scenarios involving Reflection. Also, if generics were ever enhanced to allow a parameterized "new" constraint, it would be useful to have structs that could comply with them.
–
supercatFeb 24 '12 at 1:39

Me personally wouldn't like my classes/structs to have this kind of behaviour. Failing silently (or recovering in the way the dev guesses is best for you) is the road to uncaught mistakes.
–
Boris CallensDec 3 '08 at 9:15

1

+1 This is a good answer, because for value types, you have to take into account their default value. This let's you "set" the default value with its behaviour.
–
IllidanS4Jul 16 at 23:22

Although the CLR allows it, C# does not allow structs to have a default parameter less
constructor. The reason is that, for a value type, compilers by default neither generate a
default constructor, nor do they generate a call to the default constructor. So, even if you
happened to define a default constructor, it will not be called and that will only confuse you.
To avoid such problems, the C# compiler disallows definition of a default constructor by the
user. And because it doesn't generate a default constructor, you can't initialize fields when
defining them.

Or the big reason is that structure is value type and value type are initialized by default
value and constructor is used for initialization.

You don't have to instantiate your struct with the new keyword. It instead works like an int
you can directly access it

A default(parameterless)constructor for a structcould setdifferent
values than the all-zeroed state which would be unexpected behavior. The.NetRuntime
therefore prohabits default constructors for struct.