By Motti


2008-12-02 12:39:25 8 Comments

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 specification. What happens is that for every value-type a default constructor is created (by the compiler?) which initialized all members to zero (or null).

Why is it disallowed to define such a default constructor?

One trivial use is for rational numbers:

public struct Rational {
    private long numerator;
    private long denominator;

    public Rational(long num, long denom)
    { /* Todo: Find GCD etc. */ }

    public Rational(long num)
    {
        numerator = num;
        denominator = 1;
    }

    public Rational() // This is not allowed
    {
        numerator = 0;
        denominator = 1;
    }
}

Using current version of C#, a default Rational is 0/0 which is not so cool.

PS: Will default parameters help solve this for C# 4.0 or will the CLR-defined default constructor be called?


Jon Skeet answered:

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?

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 constructor 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.

10 comments

@eMeL 2018-08-17 18:23:23

public struct Rational 
{
    private long numerator;
    private long denominator;

    public Rational(long num = 0, long denom = 1)   // This is allowed!!!
    {
        numerator   = num;
        denominator = denom;
    }
}

@Motti 2018-08-19 06:32:58

It's allowed but it's not used when no parameters are specified ideone.com/xsLloQ

@Skasel 2009-01-11 17:14:33

You can make a static property that initializes and returns a default "rational" number:

public static Rational One => new Rational(0, 1); 

And use it like:

var rat = Rational.One;

@tbridge 2011-12-19 22:56:06

this seems like a good work around, its what i generally do

@Kevin 2013-11-15 09:14:44

In this case, Rational.Zero might be a bit less confusing.

@M.kazem Akhgary 2017-09-27 17:31:39

I haven't seen equivalent to late solution I'm going to give, so here it is.

use offsets to move values from default 0 into any value you like. here properties must be used instead of directly accessing fields. (maybe with possible c#7 feature you better define property scoped fields so they remain protected from being directly accessed in code.)

This solution works for simple structs with only value types (no ref type or nullable struct).

public struct Tempo
{
    const double DefaultBpm = 120;
    private double _bpm; // this field must not be modified other than with its property.

    public double BeatsPerMinute
    {
        get => _bpm + DefaultBpm;
        set => _bpm = value - DefaultBpm;
    }
}

This is different than this answer, this approach is not especial casing but its using offset which will work for all ranges.

example with enums as field.

public struct Difficaulty
{
    Easy,
    Medium,
    Hard
}

public struct Level
{
    const Difficaulty DefaultLevel = Difficaulty.Medium;
    private Difficaulty _level; // this field must not be modified other than with its property.

    public Difficaulty Difficaulty
    {
        get => _level + DefaultLevel;
        set => _level = value - DefaultLevel;
    }
}

As I said this trick may not work in all cases, even if struct has only value fields, only you know that if it works in your case or not. just examine. but you get the general idea.

@Motti 2017-09-27 19:13:38

This is a good solution for the example I gave but it was really only supposed to be an example, the question is general.

@G1xb17 2016-11-13 19:20:12

Here's my solution to the no default constructor dilemma. I know this is a late solution, but I think it's worth noting this is a solution.

public struct Point2D {
    public static Point2D NULL = new Point2D(-1,-1);
    private int[] Data;

    public int X {
        get {
            return this.Data[ 0 ];
        }
        set {
            try {
                this.Data[ 0 ] = value;
            } catch( Exception ) {
                this.Data = new int[ 2 ];
            } finally {
                this.Data[ 0 ] = value;
            }
        }
    }

    public int Z {
        get {
            return this.Data[ 1 ];
        }
        set {
            try {
                this.Data[ 1 ] = value;
            } catch( Exception ) {
                this.Data = new int[ 2 ];
            } finally {
                this.Data[ 1 ] = value;
            }
        }
    }

    public Point2D( int x , int z ) {
        this.Data = new int[ 2 ] { x , z };
    }

    public static Point2D operator +( Point2D A , Point2D B ) {
        return new Point2D( A.X + B.X , A.Z + B.Z );
    }

    public static Point2D operator -( Point2D A , Point2D B ) {
        return new Point2D( A.X - B.X , A.Z - B.Z );
    }

    public static Point2D operator *( Point2D A , int B ) {
        return new Point2D( B * A.X , B * A.Z );
    }

    public static Point2D operator *( int A , Point2D B ) {
        return new Point2D( A * B.Z , A * B.Z );
    }

    public override string ToString() {
        return string.Format( "({0},{1})" , this.X , this.Z );
    }
}

ignoring the fact I have a static struct called null, (Note: This is for all positive quadrant only), using get;set; in C#, you can have a try/catch/finally, for dealing with the errors where a particular data type is not initialized by the default constructor Point2D(). I guess this is elusive as a solution to some people on this answer. Thats mostly why i'm adding mine. Using the getter and setter functionality in C# will allow you to bypass this default constructor non-sense and put a try catch around what you dont have initialized. For me this works fine, for someone else you might want to add some if statements. So, In the case where you would want a Numerator/Denominator setup, this code might help. I'd just like to reiterate that this solution does not look nice, probably works even worse from an efficiency standpoint, but, for someone coming from an older version of C#, using array data types gives you this functionality. If you just want something that works, try this:

public struct Rational {
    private long[] Data;

    public long Numerator {
        get {
            try {
                return this.Data[ 0 ];
            } catch( Exception ) {
                this.Data = new long[ 2 ] { 0 , 1 };
                return this.Data[ 0 ];
            }
        }
        set {
            try {
                this.Data[ 0 ] = value;
            } catch( Exception ) {
                this.Data = new long[ 2 ] { 0 , 1 };
                this.Data[ 0 ] = value;
            }
        }
    }

    public long Denominator {
        get {
            try {
                return this.Data[ 1 ];
            } catch( Exception ) {
                this.Data = new long[ 2 ] { 0 , 1 };
                return this.Data[ 1 ];
            }
        }
        set {
            try {
                this.Data[ 1 ] = value;
            } catch( Exception ) {
                this.Data = new long[ 2 ] { 0 , 1 };
                this.Data[ 1 ] = value;
            }
        }
    }

    public Rational( long num , long denom ) {
        this.Data = new long[ 2 ] { num , denom };
        /* Todo: Find GCD etc. */
    }

    public Rational( long num ) {
        this.Data = new long[ 2 ] { num , 1 };
        this.Numerator = num;
        this.Denominator = 1;
    }
}

@Mike Rosoft 2019-08-05 11:41:20

This is very bad code. Why do you have an array reference in a struct? Why don't you simply have the X and Y coordinates as fields? And using exceptions for flow control is a bad idea; you should generally write your code in such a way that NullReferenceException never occurs. If you really need this - though such a construct would be better suited for a class rather than a struct - then you should use lazy initialization. (And technically, you are - completely needlessly in every but the first setting of a coordinate - setting each coordinate twice.)

@Adiii 2015-01-19 12:04:16

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 a structure is a value type and value types are initialized by a default value and the 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.

Structs cannot contain explicit parameterless constructors. Struct members are automatically initialized to their default values.

A default (parameter-less) constructor for a struct could set different values than the all-zeroed state which would be unexpected behavior. The .NET runtime therefore prohibits default constructors for a struct.

@talles 2015-11-05 20:06:11

This answer is by far the best. In the end the whole point of restricting is to avoid surprises such MyStruct s; not calling the default constructor you provided.

@Elo 2016-02-18 10:53:07

Thank you for the explanation. So it is only a compiler lack that would have to be improved, there is no theoretical good reason to forbid parameterless constructors (as soon as they could be restricted to only access properties).

@Jon Skeet 2008-12-02 12:48:21

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) (in the end this feature was not added to C# 6).


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.

@Joel Coehoorn 2008-12-02 14:01:15

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.

@Jon Skeet 2008-12-02 14:36:20

@Joel: That doesn't really explain this particular restriction though, does it?

@Jonathan Allen 2008-12-03 19:55:07

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.

@Jon Skeet 2008-12-03 20:13:31

@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 Skeet 2008-12-03 20:14:03

(That's how I got the IL in the first place - a C# struct with a parameterful constructor.) I'll edit my answer to explain the bit we've got to so far...

@Jonathan Allen 2008-12-03 20:52:38

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.

@Jon Skeet 2008-12-03 21:18:30

That would certainly explain it :) I'll edit the answer. Thanks so much for correcting me though - that's a really good catch!

@supercat 2014-04-29 14:06:18

@JonathanAllen: FYI, there's a .NET method which will run a defined default constructor upon every slot in an array; I think there may have been an intention to have languages call this method when creating new arrays of structure types, but that philosophy has since been abandoned.

@Kakira 2014-05-03 02:09:24

@JonSkeet, forgive me for my ignorance, but could you please elaborate on this: The basic rule in C# is "the default value for any type can't rely on any initialization". Aren't the usual value types (int, float etc) assigned default values by calling their value type ctors?

@Jon Skeet 2014-05-03 06:01:07

@Kakira: No, they're assigned default values by wiping the memory, basically. The default value is always "what you'd get by wiping memory". You can't provide any explicit implementation which will always be called.

@kiss my armpit 2014-06-13 06:16:55

Sorry, I am a bit confused with the following. Does Rational[] fractions = new Rational[1000]; also waste a load of work if Rational is a class instead of a struct? If so, why do classes have a default ctor?

@Jon Skeet 2014-06-13 06:18:30

@FifaEarthCup2014: You'd have to be more specific about what you mean by "waste a load of work". But when either way, it's not going to call the constructor 1000 times. If Rational is a class, you'll end up with an array of 1000 null references.

@kiss my armpit 2014-06-15 21:55:32

Sorry. Why does class have to have a default parameterless constructor if no ctor is explicitly defined by us as programmers?

@Jon Skeet 2014-06-16 05:47:26

@FifaEarthCup2014: Ah, I see. That's a decision by the C# designers - it's not required by the CLR. I believe it was intended to make development simpler, by providing you with some code by default. Personally I think it was probably a slightly bad idea, but that's a different matter. (It follows Java's lead here - Java behaves the same way.)

@Jean Hominal 2014-11-26 09:50:13

@JonSkeet: Now would probably be a good time to review this answer for C# 6.0's expected inclusion of parameterless constructors for structs. New Features in C# 6 on MSDN

@Jon Skeet 2014-11-26 09:51:18

@JeanHominal: I'll add a note to say that things may change for C# 6 - I think there's just about enough chance that it will change between now and release that I'd rather not be too definite though.

@Alex Booker 2015-07-26 12:40:40

@JonSkeet It changed, didn't it?

@Jon Skeet 2015-07-26 12:41:11

@Petrichor: Yes, I'll edit this answer later.

@solstice333 2019-02-02 05:31:08

Ouch, something like public Ctor(x=10) {} hurts since it never gets called when you do var x = new Ctor(). I'll try to remember to always require 1 or more parameters for a struct ctor, make all ctors private (probably only need one designated ctor anyway), always implement factory pattern for structs...sheez...

@user42467 2008-12-02 16:58:28

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!

@pipTheGeek 2008-12-03 20:42:45

Not sure why someone voted you down. You appear to be the most correct answer on here.

@Motti 2008-12-04 08:46:18

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.

@user42467 2008-12-05 17:00:33

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.

@R. Martinho Fernandes 2009-02-06 12:14:42

But you can't write special code for m2 = new MyStruct(); can you?

@Stefan Monov 2010-05-22 21:15:56

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

@supercat 2012-10-31 19:54:34

@user42467: If the default value of every type is simply all-bits-zero, that means that the code which creates a new blank instance of a type need not know anything about it other than its size. By contrast, if the default value of a struct could be made to be anything other than all-bits-zero, then the code which creates a new blank instance of any type containing that struct would have to know about it. This could greatly complicate object construction, especially if one considers the implications for generic types.

@Tarik 2014-10-10 14:34:11

I think you gave the most comprehensible answer in this post. I think this is the root cause why we are not allowed to use default constructor in C#.

@Elo 2016-02-18 10:38:42

@Tarik. I do not agree. On the contrary, a parameterless constructor would make full sense : if I want to create a "Matrix" struct wich always have an identity matrix as a default value, how could you do it by other means ?

@Joel Coehoorn 2008-12-02 14:03:56

Shorter explanation:

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.

@Motti 2008-12-02 19:05:32

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...

@Joel Coehoorn 2008-12-02 21:50:31

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.

@annakata 2009-02-06 12:22:49

one wonders why other constructors are allowed then

@supercat 2012-02-24 01:39:26

@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.

@v.oddou 2016-08-25 09:36:01

@annakata I believe it's because C# has a particular strong requirement that new really must be written to call a constructor. In C++ constructors are called in hidden ways, at declaration or instanciation of arrays. In C# either everything is a pointer so start at null, either it's a struct and must start at something, but when you cannot write new... (like array init), that would break a strong C# rule.

@Jonathan Allen 2008-12-03 19:53:48

You can't define a default constructor because you are using C#.

Structs can have default constructors in .NET, though I don't know of any specific language that supports it.

@Tom Sarduy 2011-06-14 08:15:43

In C#, classes and structs are semantically different. A struct is a value type, while a class is a reference type.

@Jonathan Allen 2008-12-03 07:59:06

Just special-case it. If you see a numerator of 0 and a denominator of 0, pretend like it has the values you really want.

@Boris Callens 2008-12-03 09:15:00

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.

@IllidanS4 2015-07-16 23:22:00

+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.

@Jonathan Allen 2017-01-31 21:01:19

This is exactly how they implement classes such as Nullable<T> (e.g. int?).

@Mike Rosoft 2019-07-23 11:53:58

That's a very bad idea. 0/0 should always be an invalid fraction (NaN). What if somebody calls new Rational(x,y) where x and y happens to be 0?

@Jonathan Allen 2019-07-29 14:02:47

If you have an actual constructor then you can throw an exception, preventing a real 0/0 from happening. Or if you do want it to happen, you have to add an extra bool to distinguish between default and 0/0.

Related Questions

Sponsored Content

16 Answered Questions

[SOLVED] Why are mutable structs “evil”?

17 Answered Questions

[SOLVED] Interface defining a constructor signature?

1 Answered Questions

How can I create a .NET struct with parameterless constructor?

16 Answered Questions

[SOLVED] Why Choose Struct Over Class?

18 Answered Questions

[SOLVED] What's the difference between struct and class in .NET?

11 Answered Questions

[SOLVED] Why isn't sizeof for a struct equal to the sum of sizeof of each member?

16 Answered Questions

[SOLVED] Struct Constructor in C++?

4 Answered Questions

[SOLVED] hide parameterless constructor on struct

  • 2009-02-11 03:40:59
  • ChrisCa
  • 11693 View
  • 25 Score
  • 4 Answer
  • Tags:   c# .net struct

5 Answered Questions

1 Answered Questions

Why can classes have explicit parameterless constructors but structs cannot?

Sponsored Content