Can you have default parameters on a readonly struct in c#?

Question

It appears that default parameters do not work on a readonly struct in c#. Am I misunderstanding something?

   public readonly struct ReadonlyStruct
   {
      public ReadonlyStruct(int p1 = 1, byte p2 = 2, bool p3 = true)
      {
         P1 = p1;
         P2 = p2;
         P3 = p3;
      }

      public int P1 { get; }
      public byte P2 { get; }
      public bool P3 { get; }
   }

Instantiating an instance of this struct using var test = new ReadonlyStruct(); does not appear to honor the default values. What am I doing wrong?

Answer 1

Counter-intuitively you can't have all default parameters or an explicit parameterless constructor on a struct, this is not limited to readonly struct.

Unlike a class, a struct is value-type and is not required to have a constructor, so in your case you aren't providing any parameters at all, hence the constructor never gets called.

_{As noted in the documentation}

Limitations with the design of a structure type

When you design a structure type, you have the same capabilities as with a class type, with the following exceptions:

You can't declare a parameterless constructor. Every structure type already provides an implicit parameterless constructor that produces the default value of the type.

When you don't supply parameters, the generated IL will call

OpCodes.Initobj Field

Initializes each field of the value type at a specified address to a null reference or a 0 of the appropriate primitive type.

Furthermore

Unlike Newobj, initobj does not call the constructor method. Initobj is intended for initializing value types, while newobj is used to allocate and initialize objects.

In contrast, in the following case it will. Defaults will be initalized the way you expect.

var asd = new ReadonlyStruct(2);

The following generated IL will be

newobj instance void ReadonlyStruct::.ctor(int32, uint8, bool)

OpCodes.Newobj Field

The newobj instruction allocates a new instance of the class associated with ctor and initializes all the fields in the new instance to 0 (of the proper type) or null references as appropriate. It then calls the constructor ctor with the given arguments along with the newly created instance. After the constructor has been called, the now initialized object reference (type O) is pushed on the stack.

In short, you may need to rethink your problem or use a static create method.