How to prevent a struct's default constructor to be called?

You cannot.

By nature,

• all fields of a struct must be initialized to some value.
• a struct cannot have a parameter-less constructor
• the parameter-less constructor will be implicitly called, there's no way around it.

Either use a class if you need such behavior or review your design.

When you're dealing with structs, C# wants to make sure that you've initialized all of the struct's fields.

One option is to provide a constructor that will call the default constructor first, then do your custom initialization later:

 public S(int x) : this()
 {
     /* custom initialization logic */
 }

Another option is to provide a constructor that provably initializes all fields of the struct in its own body, in which case you don't need to chain the default constructor:

 public S(int x)
 {
     this.X = x;
     /* custom initialization logic */
 }

Another option is to skip calling a constructor, and instead initialize the struct manually, just before you actually use it:

S s;
s.X = 5;

Out of the above options, only the first performs a logical call to the default constructor, while the other two skip the call.

The bad news is that, behind the scenes, the CLR will always give you zero-initialized memory for safety reasons, which is pretty much exactly equivalent to calling the C# default constructor. You can observe it like this:

S s;
S* ptr = &s;
int x = (*ptr).X;
Console.WriteLine(x); // will print 0

The good news is that, for most cases, this doesn't matter. The C# default constructors aren't really constructors in the CLR sense. The expression new T() for any T : struct is equivalent to default(T), which is simply a way to express getting a zero-initialized instance of a struct of type T. It's also why you can't make it private or add custom logic to it.

Therefore, C# default struct constructors cannot have any logical externally observable side-effects. Which brings us to a question: what kinds of effects are you trying to avoid?

Keep in mind that if your problem is that your struct is invalid for the all-zero bit pattern and you're afraid that some client code might attempt to use it like that, there is a workaround:

struct S
{
    private bool _isValid;
    /* rest of your struct */
}

Any zero-initialized struct will have its validity flag not set, and you can use that to throw exceptions as soon as any operation (that you can control) is performed on your struct.

After all this, if for any reason you still need to a struct instance that has somehow skipped calling any constructor (whether a real or an apparent one), you'll have to allocate some memory for the struct yourself:

S* ptr = (S*) Marshal.AllocHGlobal(Marshal.SizeOf<S>());

You can now use expressions of the form (*ptr).X or ptr->X to read and write to that struct directly.

Starting with C# 10 you can do this:

public struct MyStruct
{
    [Obsolete("You may not use the parameterless constructor.", error: true)]
    public MyStruct()
    {
        throw new InvalidOperationException("You may not use the parameterless constructor.");
    }
}

This doesn't change the fact that structs can still be initialized without using any constructor. For example:

MyStruct uninitialized = default;

var allUninitialized = new MyStruct[10];

For more info, see Structure types (C# reference)

As Aybe specified you cannot do it but it you want you can add a field in the struct like IsInitialized that will default to false and make the code using it to verify the value and throw if false.

I bash against the same issue myself. For now (rather for ever) I found this workaround: define public parameterless constructor and mark it as obsolete:

[Obsolete("Must not be used without parameters", true)]

This will prevent the constructor from being called explicitly. Obsolete is not a suitable word, of course, and it will still appear among the hints on typing but it kinda does the trick

As @aybe responded, this isn't possible. However, I found a workaround for my scenario: We can decorate property-getter with a guard that throws exception if an invalid value is stored and accessed.

So this do not prevent storing invalid value but stopping working with invalid value.

This also means that guard check is executed every time you access the property.