覆盖结构中的默认值 (c#)

Question

是否可以设置或覆盖结构的默认状态？

作为示例，我有一个

enum something{a,b,c,d,e};

和 一个结构，该结构链接该枚举的 2 个值

struct SomethingData
{
    something type;
    int Value;
    double Multipler;

    SomethingData(something enumVal, int intVal, double DblVal) {...}
}

但是我可以指定默认状态是

SomethingData(something.c,0,1);

Answer 1

结构体构造函数类似于
类构造函数，除了
以下差异：

结构体不能包含显式的
无参数构造函数。结构体
成员自动初始化
为其默认值。一个结构体
中不能有初始化程序
形式：基础（参数列表）。

http://msdn.microsoft.com/en- us/library/aa288208(v=vs.71).aspx

所以，简短的回答，不，你不能重写默认构造函数（每个结构都有一个无参数构造函数，你不能隐藏它或重写它） ...

Answer 2

你不能。结构体始终有一个默认构造函数，用于将每个成员设置为其默认值（引用类型为 null，数字类型为 0，布尔值为 false，等）此行为无法更改。

Answer 3

您无法覆盖结构的默认（无参数）构造函数。您只能添加带有参数的新构造函数。

http://csharp.2000things。 com/2010/10/03/108-defining-a-structor-for-a-struct/

Answer 4

创建类对象将导致所有实例字段在任何事物（甚至类构造函数）可以访问它之前就已存在，而分配数组将导致其所有元素在任何事物可以访问该数组之前就已存在。这两个操作都会导致分配给这些字段或元素的所有内存都被清零，而不考虑其中存储的数据类型。

当类类型存储位置出现时，它最初将保存一个空引用。当结构类型存储位置存在时，其所有字段（以及其中结构的任何字段）将同时存在。与只能通过使用构造函数来存在的类对象实例不同，结构类型存储位置的存在无需使用任何结构自身的代码。因此，结构的定义不会决定当“实例”[即结构类型存储位置]出现时会发生什么。

从根本上来说，结构是用胶带粘合在一起的字段的集合。如果一个结构应该表现得像其他东西，它通常应该将其字段设为私有并假装是不可变的[即使结构赋值实际上通过使用源中的相应值覆盖其所有字段来改变目标结构，并且结构定义在这件事上没有发言权]。然而，如果一个结构体应该封装一组固定的相关但独立的值（例如点的坐标），它可以独立地容纳对其各自类型合法的值的任何组合，结构应该简单地公开其字段。有些人可能会抱怨“可变结构是邪恶的”，但这种邪恶仅在结构体上调用自变异方法时才适用。将其状态公开为字段的结构的行为就像用胶带粘在一起的变量集合。如果需要的是一组用胶带粘在一起的变量，那么试图让一个结构假装不可变只会让编程变得更加困难。

Answer 5

有一种解决方法可以通过使用自定义属性 getter 来实现此目的。注意：

public struct Foostruct
{
    private int? _x;
    private int? _y;

    public int X
    {
        get { return _x ?? 20; } // replace 20 with desired default value
        set { _x = value; }
    }

    public int Y
    {
        get { return _y ?? 10; } // replace 10 with desired default value
        set { _y = value; }
    }
}

这仅适用于值类型（可以用 nullable 包装），但您可以通过将引用类型包装在泛型类中来对引用类型执行类似的操作，如下所示：

public class Wrapper<TValue>
{
    public TValue Value { get; set; }
}

public struct Foostruct
{
    private Wrapper<Tick> _tick;

    public Tick Tick
    {
        get { return _tick == null ? new Tick(20) : _tick.Value; }
        set { _tick = new Wrapper<Tick> { Value = value }; }
    }
}

Answer 6

有些相关：我经常想将新的对象初始值设定项语法与不可变值类型一起使用。但是，考虑到典型的不可变值类型实现的性质，无法利用该语法，因为属性是只读的。

我想出了这个方法；在我看来，这仍然满足值类型的不变性，但允许负责实例化值类型的代码更好地控制内部数据的初始化。

struct ImmutableValueType
{
    private int _ID;
    private string _Name;

    public int ID
    {
        get { return _ID; }
    }

    public string Name
    {
        get { return _Name; }
    }

    // Infuser struct defined within the ImmutableValueType struct so that it has access to private fields
    public struct Infuser
    {
        private ImmutableValueType _Item;

        // write-only properties provide the complement to the read-only properties of the immutable value type
        public int ID
        {
            set { _Item._ID = value; }
        }

        public string Name
        {
            set { _Item._Name = value; }
        }

        public ImmutableValueType Produce()
        {
            return this._Item;
        }

        public void Reset(ImmutableValueType item)
        {
            this._Item = item;
        }

        public void Reset()
        {
            this._Item = new ImmutableValueType();
        }

        public static implicit operator ImmutableValueType(Infuser infuser)
        {
            return infuser.Produce();
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // use of object initializer syntax made possible by the Infuser type
        var item = new ImmutableValueType.Infuser
        {
            ID = 123,
            Name = "ABC",
        }.Produce();

        Console.WriteLine("ID={0}, Name={1}", item.ID, item.Name);
    }
}

Answer 7

每次获取/设置属性时，您都需要调用 InitDefaultValues() 方法设置默认值

private string _numberDecimalSeparator;
public string NumberDecimalSeparator
{
    get
    {
        InitDefaultValues();
        return _numberDecimalSeparator;
    }
    set
    {
        InitDefaultValues(); 
        _numberDecimalSeparator = value;
    }
}

...

private void InitDefaultValues()
{
    if (!_inited)
    {
        _inited = false;
        var ci = CultureInfo.CurrentCulture;
         _numberDecimalSeparator = ci.With(x => x.NumberFormat).Return(x => x.NumberDecimalSeparator, ".");

        ...
    }
}

Answer 8

我的解决方案。它也有效。

public struct DisplayOptions
{
    public bool isUpon;
    public bool screenFade;

    public static DisplayOptions Build()
    {
        // Return default value
        return new DisplayOptions(true, true);
    }

    DisplayOptions(bool isUpon, bool screenFade)
    {
        this.isUpon = isUpon;
        this.screenFade = screenFade;
    }

    public DisplayOptions SetUpon(bool upon)
    {
        this.isUpon = upon;
        return this;
    }

    public DisplayOptions SetScreenFade(bool screenFade)
    {
        this.screenFade = screenFade;
        return this;
    }
}

使用默认值

        // Use default
        UIMaster.Instance.StartScreen("Screen 2", DisplayOptions.Build());
        // Use custome
        UIMaster.Instance.StartScreen("Screen 2", DisplayOptions.Build().SetScreenFade(false));
        UIMaster.Instance.StartScreen("Screen 2", DisplayOptions.Build().SetUpon(false));

Answer 9

这应该有效

public struct MyStruct 
{
    private string myName;
    private int? myNumber;
    private bool? myBoolean;
    private MyRefType myType;

    public string MyName
    {
        get { return myName ?? "Default name"; }
        set { myName= value; }
    }
    public int MyNumber
    {
        get { return myNumber ?? 42; }
        set { myNumber = value; }
    }
    public bool MyBoolean
    {
        get { return myBoolean ?? true; }
        set { myBoolean = value; }
    }
    public MyRefType MyType 
    {
        get { return myType ?? new MyRefType(); }
        set { myType = value; }
    }

    //optional
    public MyStruct(string myName = "Default name", int myNumber = 42, bool myBoolean = true)
    {
        this.myType = new MyRefType();
        this.myName = myName;
        this.myNumber = myNumber;
        this.myBoolean = myBoolean;
    }
}

---

[TestClass]
public class MyStructTest
{
    [TestMethod]
    public void TestMyStruct()
    {
        var myStruct = default(MyStruct);
        Assert.AreEqual("Default name", myStruct.MyName);
        Assert.AreEqual(42, myStruct.MyNumber);
        Assert.AreEqual(true, myStruct.MyBoolean);
        Assert.IsNotNull(myStruct.MyType);
    }
}

Answer 10

有点愚蠢，但有效

public readonly static float default_value = 1;
public struct YourStruct{

    public float yourValue{
        get {
            return _yourValue + default_value;
        }
        set {
            _yourValue= value - default_value;
        }
    }
    public float _yourValue;
}

Answer 11

这可能有效...

    public struct MyStruct
    {
        private bool _name;
        public string myName
        {
            get { return (_name ? myName : "Default name"); }
            set { _name = true; myName = value; }
        }
        private bool _num;
        public int myNumber 
        {
            get { return (_num ? myNumber : 42); }
            set { _num = true; myNumber = value; }
        }
        private bool _bool;
        public bool myBoolean
        {
            get { return (_bool ? myBoolean : true); }
            set { _bool = true; myBoolean = value; }
        }
        private bool _type;
        public MyRefType myType
        {
            get { return _type ? myType : new MyRefType(); }
            set { _type = true; myType = value; }
        }
    }

没关系 StackOverflowException

Answer 12

有一个解决方法

public struct MyStruct
{
    public MyStruct(int h = 1, int l = 1)
    {
        high = h;
        low = l;
    }
    public int high;
    public int low;
}