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.

share|improve this question
3  
+1 had a similar problem once, finally converted the struct into a class. – Dirk Vollmar Dec 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). – LaTeX Feb 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 Bretana Sep 11 '14 at 22:06
3  
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 Nielsen Nov 20 '14 at 9:51
3  
To solve this specific problem you can store denominator - 1 inside the struct, so that the default value becomes 0/1 – miniBill Aug 19 '15 at 14:04
up vote 143 down vote accepted

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.

share|improve this answer
7  
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 Coehoorn Dec 2 '08 at 14:01
22  
@Joel: That doesn't really explain this particular restriction though, does it? – Jon Skeet Dec 2 '08 at 14:36
6  
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 Allen Dec 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 Skeet Dec 3 '08 at 20:13
2  
@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. – Jon Skeet Jun 13 '14 at 6:18

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;
    }
}
share|improve this answer

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.

share|improve this answer
    
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. – talles Nov 5 '15 at 20:06
    
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). – Elo Feb 18 '16 at 10:53

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!

share|improve this answer
2  
Not sure why someone voted you down. You appear to be the most correct answer on here. – pipTheGeek Dec 3 '08 at 20:42
4  
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. – Motti Dec 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. – user42467 Dec 5 '08 at 17:00
2  
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 Monov May 22 '10 at 21:15
2  
@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 ? – Elo Feb 18 '16 at 10:38

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.

share|improve this answer
2  
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... – Motti Dec 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 Coehoorn Dec 2 '08 at 21:50
4  
one wonders why other constructors are allowed then – annakata Feb 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. – supercat Feb 24 '12 at 1:39
    
@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. – v.oddou Aug 25 '16 at 9:36

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

public static Rational One { get { return new Rational(0, 1); } }

And use it like:

var rat = Rational.One;
share|improve this answer
    
this seems like a good work around, its what i generally do – tbridge Dec 19 '11 at 22:56
19  
In this case, Rational.Zero might be a bit less confusing. – Kevin Nov 15 '13 at 9:14

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.

share|improve this answer
    
In C#, classes and structs are semantically different. A struct is a value type, while a class is a reference type. – Tom Sarduy Jun 14 '11 at 8:15

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.

share|improve this answer
3  
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 Callens Dec 3 '08 at 9:15
2  
+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. – IllidanS4 Jul 16 '15 at 23:22
    
This is exactly how they implement classes such as Nullable<T> (e.g. int?). – Jonathan Allen Jan 31 at 21:01

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.