我找到了一个简单的解决方法:

struct Data
    {
        public int Point { get; set; }
        public HazardMap Map { get; set; }
        public Data Initialize()
        {
            Point = 1; //set anything you want as default
            Map = new HazardMap();
            return this;
        }
    }

在代码中只需执行:

Data input = new Data().Initialize();

struct是一种值类型，值类型在声明后必须具有默认值。

MyClass m;
MyStruct m2;

如果您像上面那样声明了两个字段而没有实例化它们，那么就会中断调试器，m将为null，而m2则不是。鉴于此，无参数构造函数将没有意义，事实上，结构上的所有构造函数都是赋值，只是声明了它本身就已经存在了。实际上，m2可以在上面的例子中非常愉快地使用，并调用它的方法(如果有的话)，并操纵它的字段和属性!

你可以创建一个静态属性，初始化并返回一个默认的“有理数”:

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

像这样使用它:

var rat = Rational.One;

下面是我对没有默认构造函数困境的解决方案。我知道这是一个很晚的解决方案，但我认为值得注意的是，这是一个解决方案。

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;
    }
}

注意:下面的答案是在c# 6之前很长时间写的，c# 6计划引入在结构中声明无参数构造函数的能力——但它们仍然不会在所有情况下被调用(例如用于数组创建)(最后这个特性没有添加到c# 6中)。

编辑:鉴于Grauenwolf对CLR的深刻见解，我编辑了下面的答案。

CLR允许值类型具有无参数的构造函数，但c#不允许。我相信这是因为它会引入一种期望，即在构造函数没有调用时调用它。例如，考虑这个:

MyStruct[] foo = new MyStruct[1000];

CLR能够通过分配适当的内存并将其全部归零来非常有效地做到这一点。如果它必须运行MyStruct构造函数1000次，那么效率将大大降低。(事实上，它不会——如果你有一个无参数的构造函数，当你创建一个数组，或当你有一个未初始化的实例变量时，它不会运行。)

c#的基本规则是“任何类型的默认值都不能依赖于任何初始化”。现在他们可以允许定义无参数的构造函数，但不要求在所有情况下都执行该构造函数——但这将导致更多的混乱。(至少我是这么认为的。)

编辑:用你的例子来说，如果有人这样做了，你希望发生什么:

Rational[] fractions = new Rational[1000];

它应该遍历构造函数1000次吗?

否则，我们就会得到1000个无效理性 如果是这样，那么如果我们要用实值填充数组，我们就可能浪费了大量的工作。

EDIT:(回答了更多的问题)无参数构造函数不是由编译器创建的。就CLR而言，值类型不必有构造函数——尽管如果你用IL写它，结果是可以的。当你用c#写“new Guid()”时，如果你调用一个普通的构造函数，它会发出不同的IL。关于这方面，请参阅这个SO问题。

我怀疑框架中没有任何具有无参数构造函数的值类型。毫无疑问，如果我问得够好，NDepend会告诉我的。c#禁止它的事实是一个足够大的提示，让我认为这可能是一个坏主意。

从c# 10.0开始，你可以:

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct#parameterless-constructors-and-field-initializers