ChatGPT解决这个技术问题 Extra ChatGPT

为 C# 自动属性赋予初始值的最佳方法是什么?

如何为 C# 自动属性赋予初始值?

我要么使用构造函数,要么恢复到旧语法。

使用构造函数:

class Person 
{
    public Person()
    {
        Name = "Initial Name";
    }
    public string Name { get; set; }
}

使用普通属性语法(带有初始值)

private string name = "Initial Name";
public string Name 
{
    get 
    {
        return name;
    }
    set
    {
        name = value;
    }
}

有没有更好的办法?


O
Orace

在 C# 5 及更早版本中,要为自动实现的属性赋予初始值,您必须在构造函数中进行。

从 C# 6.0 开始,您可以在线指定初始值。语法是:

public int X { get; set; } = x; // C# 6 or higher

DefaultValueAttribute 旨在供 VS 设计者(或任何其他使用者)用于指定默认值,而不是初始值。 (即使在设计对象中,初始值也是默认值)。

在编译时,DefaultValueAttribute 不会影响生成的 IL,并且不会读取它来将属性初始化为该值(请参阅 DefaultValue attribute is not working with my Auto Property)。

影响 IL 的属性示例有 ThreadStaticAttributeCallerMemberNameAttribute、...


值得注意的是,这也适用于 getter-only 属性:public int X { get; } = x;
K
Kevin Panko

于 15 年 1 月 2 日编辑

C# 6:

使用 C# 6,您可以直接初始化自动属性(终于!),现在还有其他答案可以描述这一点。

C# 5 及以下:

尽管该属性的预期用途不是实际设置属性的值,但您可以使用反射来始终设置它们......

public class DefaultValuesTest
{    
    public DefaultValuesTest()
    {               
        foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(this))
        {
            DefaultValueAttribute myAttribute = (DefaultValueAttribute)property.Attributes[typeof(DefaultValueAttribute)];

            if (myAttribute != null)
            {
                property.SetValue(this, myAttribute.Value);
            }
        }
    }

    public void DoTest()
    {
        var db = DefaultValueBool;
        var ds = DefaultValueString;
        var di = DefaultValueInt;
    }


    [System.ComponentModel.DefaultValue(true)]
    public bool DefaultValueBool { get; set; }

    [System.ComponentModel.DefaultValue("Good")]
    public string DefaultValueString { get; set; }

    [System.ComponentModel.DefaultValue(27)]
    public int DefaultValueInt { get; set; }
}

投票 -1:充其量,它看起来主观上看起来比在构造函数中初始化更整洁。这样做的代价是让刚接触代码库的开发人员感到困惑,性能更差,语义上改变了内置属性的含义,只允许常量,在多个属性中很难发现默认值,必须记住在每个构造函数重载时运行它,并且有可能在属性和构造函数中定义默认值。
G
Gerhard

当您内联变量的初始值时,无论如何它都会在构造函数中隐式完成。

我认为这种语法是 C# 中的最佳实践,最高可达 5:

class Person 
{
    public Person()
    {
        //do anything before variable assignment

        //assign initial values
        Name = "Default Name";

        //do anything after variable assignment
    }
    public string Name { get; set; }
}

因为这使您可以清楚地控制分配的顺序值。

从 C#6 开始,有一种新方法:

public string Name { get; set; } = "Default Name";

c
crucible

有时我会使用它,如果我不希望它被实际设置并保留在我的数据库中:

class Person
{
    private string _name; 
    public string Name 
    { 
        get 
        {
            return string.IsNullOrEmpty(_name) ? "Default Name" : _name;
        } 

        set { _name = value; } 
    }
}

显然,如果它不是字符串,那么我可以使对象为空(double?, int?)并检查它是否为空,返回一个默认值,或者返回它设置的值。

然后我可以在我的存储库中检查它是否是我的默认值并且不持久,或者在保存之前进行后门检查以查看支持值的真实状态。

希望有帮助!


return _name ?? "Default Name"; 可能更清楚的是,您的
@abatishchev:虽然那不一样。如果字符串为“”或为空,坩埚代码将返回“默认名称”,但使用您的方法将仅在它为空的情况下返回“默认名称”。此外,是否“??”也可以讨论。或“IsNullOrEmpty”更清楚。
该点是默认值,因此可以为空的检查会破坏该点。基思的回答通过在 Tor 中初始化它来证明这一点。如果是针对分贝,我并没有真正看到与拥有默认列值并使其成为非空列的区别,无论类字段的数量如何,这都会更有效。我不会投反对票,但敦促开发人员考虑这一点,而不是在您的财产程序中使用空/空支票。
为了澄清每次调用类属性时,它都会进行空/空检查,因为 dB 只会在通常占 dB 工作 20% 的 INSERT 或 UPDATE 上执行此操作。相反,可能每个字符串属性都有一个额外的调用,这是对 CPU 周期的浪费,恕我直言,这是一个糟糕的设计选择。另外,现在有 Null Ref Type,因此处理 nullable 更为常见。
G
Graham

在 C# 6.0 中,这是轻而易举的事!

您可以在 Class 声明本身的属性声明语句中执行此操作。

public class Coordinate
{ 
    public int X { get; set; } = 34; // get or set auto-property with initializer

    public int Y { get; } = 89;      // read-only auto-property with initializer

    public int Z { get; }            // read-only auto-property with no initializer
                                     // so it has to be initialized from constructor    

    public Coordinate()              // .ctor()
    {
        Z = 42;
    }
}

我还没有 C#6.0,并且正在检查我需要哪个版本来获取自动属性的默认值。 C# 6.0 是否也不需要使用 { get; set; }{ get; private set; } 否则设置值会被编译器阻止?
H
Habib

从 C# 6.0 开始,我们可以为自动实现的属性分配默认值。

public string Name { get; set; } = "Some Name";

我们还可以创建只读的自动实现属性,例如:

public string Name { get; } = "Some Name";

请参阅:C# 6: First reactions , Initializers for automatically implemented properties - By Jon Skeet


A
ANewGuyInTown

在 C# (6.0) 及更高版本中,您可以执行以下操作:

对于只读属性

public int ReadOnlyProp => 2;

对于可写和可读属性

public string PropTest { get; set; } = "test";

在当前版本的 C# (7.0) 中,您可以执行以下操作:(该片段显示了如何使用表达式主体的 get/set 访问器来使与支持字段一起使用时更紧凑)

private string label = "Default Value";

// Expression-bodied get / set accessors.
public string Label
{
   get => label;
   set => this.label = value; 
 }

此外,请考虑示例 class C { public DateTime P { get; } = DateTime.Now; public DateTime Q => DateTime.Now; },其中属性 PQ 都只有一个 getter,但 PQ 的行为非常不同!
c
codez0mb1e

C# 9.0 中是 init 关键字的 added support - 非常有用且极其复杂的方式用于声明只读自动属性

宣布:

class Person 
{ 
    public string Name { get; init; } = "Anonymous user";
}

〜享受〜使用:

// 1. Person with default name
var anonymous = new Person();
Console.WriteLine($"Hello, {anonymous.Name}!");
// > Hello, Anonymous user!


// 2. Person with assigned value
var me = new Person { Name = "@codez0mb1e"};
Console.WriteLine($"Hello, {me.Name}!");
// > Hello, @codez0mb1e!


// 3. Attempt to re-assignment Name
me.Name = "My fake"; 
// > Compilation error: Init-only property can only be assigned in an object initializer

以前我们可以只使用 public string Name { get; } = "Anonymous user";,版本 9 实现对于增加您仍然可以设置值的范围更有用。这个答案表明我们必须等待 C# 9,这对于 OP 的预期行为是不正确的。
b
brakeroo

除了已经接受的答案之外,对于想要将默认属性定义为其他属性的函数的场景,您可以在 C#6.0(及更高版本)上使用表达式主体表示法以获得更优雅和简洁的构造,例如:

public class Person{

    public string FullName  => $"{First} {Last}"; // expression body notation

    public string First { get; set; } = "First";
    public string Last { get; set; } = "Last";
}

您可以通过以下方式使用上述内容

    var p = new Person();

    p.FullName; // First Last

    p.First = "Jon";
    p.Last = "Snow";

    p.FullName; // Jon Snow

为了能够使用上述“=>”表示法,该属性必须是只读的,并且您不要使用 get 访问器关键字。

MSDN 的详细信息


L
Lex

在 C# 6 及更高版本中,您可以简单地使用以下语法:

public object Foo { get; set; } = bar;

请注意,要具有 readonly 属性,只需省略该集合,如下所示:

public object Foo { get; } = bar;

您还可以从构造函数分配 readonly 自动属性。

在此之前,我的回答如下。

我会避免向构造函数添加默认值;将其留给动态分配,并避免有两个分配变量的点(即类型默认值和构造函数中)。通常,在这种情况下,我会简单地编写一个普通属性。

另一种选择是做 ASP.Net 所做的事情并通过属性定义默认值:

http://msdn.microsoft.com/en-us/library/system.componentmodel.defaultvalueattribute.aspx


哇,这是过去的爆炸。我似乎记得这是基于对规范的阅读(这里的部分摘录:msdn.microsoft.com/en-us/library/aa645756(v=vs.71).aspx)。考虑到版本(和 Roslyn)的时间和数量,这很可能不再是这种情况。虽然反击将不胜感激。
无论您是使用初始值还是在构造函数中赋值,默认赋值都会自动发生。存在细微的语义差异 - 字段分配发生在构造函数调用之前 - 但 null 分配仍然会发生。请参阅 10.4.5“所有实例字段...首先初始化为其默认值,然后执行实例字段初始化程序”msdn.microsoft.com/en-us/library/aa645757(VS.71).aspx
i
introspected

我的解决方案是使用自定义属性,通过常量或使用属性类型初始化程序提供默认值属性初始化。

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
public class InstanceAttribute : Attribute
{
    public bool IsConstructorCall { get; private set; }
    public object[] Values { get; private set; }
    public InstanceAttribute() : this(true) { }
    public InstanceAttribute(object value) : this(false, value) { }
    public InstanceAttribute(bool isConstructorCall, params object[] values)
    {
        IsConstructorCall = isConstructorCall;
        Values = values ?? new object[0];
    }
}

要使用此属性,必须从特殊的基类初始化器继承一个类或使用静态辅助方法:

public abstract class DefaultValueInitializer
{
    protected DefaultValueInitializer()
    {
        InitializeDefaultValues(this);
    }

    public static void InitializeDefaultValues(object obj)
    {
        var props = from prop in obj.GetType().GetProperties()
                    let attrs = prop.GetCustomAttributes(typeof(InstanceAttribute), false)
                    where attrs.Any()
                    select new { Property = prop, Attr = ((InstanceAttribute)attrs.First()) };
        foreach (var pair in props)
        {
            object value = !pair.Attr.IsConstructorCall && pair.Attr.Values.Length > 0
                            ? pair.Attr.Values[0]
                            : Activator.CreateInstance(pair.Property.PropertyType, pair.Attr.Values);
            pair.Property.SetValue(obj, value, null);
        }
    }
}

使用示例:

public class Simple : DefaultValueInitializer
{
    [Instance("StringValue")]
    public string StringValue { get; set; }
    [Instance]
    public List<string> Items { get; set; }
    [Instance(true, 3,4)]
    public Point Point { get; set; }
}

public static void Main(string[] args)
{
    var obj = new Simple
        {
            Items = {"Item1"}
        };
    Console.WriteLine(obj.Items[0]);
    Console.WriteLine(obj.Point);
    Console.WriteLine(obj.StringValue);
}

输出:

Item1
(X=3,Y=4)
StringValue

如上所述,使用反射来初始化默认值既慢又过分。在构造函数上初始化,使用非自动属性或在 c# 6 及更高版本上,使用已接受答案中显示的简化符号
什么时候使用它比此处所述的其他选项更好?
M
Mikko Viitala

小完整样本:

using System.ComponentModel;

private bool bShowGroup ;
[Description("Show the group table"), Category("Sea"),DefaultValue(true)]
public bool ShowGroup
{
    get { return bShowGroup; }
    set { bShowGroup = value; }
}

那是行不通的。 DefaultValueAttribute 只是一个序列化提示,它不会将 ShowGroup 设置为 true,因为任何布尔值的默认值为 false
S
SUNIL DHAPPADHULE

你可以像这样简单地放

public sealed  class Employee
{
    public int Id { get; set; } = 101;
}

R
RayLoveless

在构造函数中。构造函数的目的是初始化它的数据成员。


C
ComeIn
private string name;
public string Name 
{
    get 
    {
        if(name == null)
        {
            name = "Default Name";
        }
        return name;
    }
    set
    {
        name = value;
    }
}

我认为提问者想要一个自动属性,即类或结构中的非抽象属性,您只使用带有分号(通常与 set; 组合)的 get; 来指示编译器应该生成get 自动访问器。
O
OwenP

您是否尝试过将 DefaultValueAttributeShouldSerialize and Reset methods 与构造函数结合使用?如果您要创建一个可能显示在设计器表面或属性网格中的类,我觉得这两种方法中的一种是必要的。


P
Preet Singh

使用构造函数,因为“当构造函数完成时,构造应该完成”。属性就像你的类所持有的状态,如果你必须初始化一个默认状态,你会在你的构造函数中这样做。


J
Johnie Karr

为了澄清,是的,您需要在构造函数中为类派生对象设置默认值。您将需要确保构造函数存在,并带有适当的访问修饰符,以便在使用时进行构造。如果对象没有被实例化,例如它没有构造函数(例如静态方法),那么默认值可以由字段设置。这里的原因是对象本身只会被创建一次,并且您不会实例化它。

@Darren Kopp - 好答案,干净,正确。重申一下,您可以为抽象方法编写构造函数。您只需要在编写构造函数时从基类访问它们:

基类的构造函数:

public BaseClassAbstract()
{
    this.PropertyName = "Default Name";
}

派生/具体/子类的构造函数:

public SubClass() : base() { }

这里的重点是,从基类中提取的实例变量可能会掩埋你的基字段名称。使用“this”设置当前实例化的对象值。将允许您根据当前实例和实例化它的所需权限级别(访问修饰符)正确地形成您的对象。


F
FloodMoo
public Class ClassName{
    public int PropName{get;set;}
    public ClassName{
        PropName=0;  //Default Value
    }
}

J
Joel Coehoorn

现在已经老了,我的立场已经改变了。我只为后代留下原始答案。

就个人而言,如果您不打算在自动属性之外做任何事情,我根本看不出将其作为属性的意义。只需将其保留为字段即可。这些项目的封装好处只是红鲱鱼,因为它们背后没有什么可以封装的。如果您需要更改底层实现,您仍然可以自由地将它们重构为属性,而不会破坏任何相关代码。

嗯......也许这将是稍后它自己的问题的主题


@Joel:数据绑定和其他基于反射的工具通常需要属性而不是字段。
您不能在不破坏调用代码的情况下将字段重构为自动属性。它可能看起来相同,但生成的代码不同。使用自动属性,调用代码在幕后调用 get_propname 和 set_propname,而如果它是一个字段,它只是直接访问该字段。
您也不能跨 AppDomain 边界访问字段——只能访问属性或方法。
B
Bridge
class Person 
{    
    /// Gets/sets a value indicating whether auto 
    /// save of review layer is enabled or not
    [System.ComponentModel.DefaultValue(true)] 
    public bool AutoSaveReviewLayer { get; set; }
}

欢迎来到堆栈溢出!就像您知道的那样,除非您有一些好的新信息,否则通常会不赞成提出这样的老问题。但是,在这种情况下,其他几个人已经发布了有关 DefaultValue 属性的信息。如果其他人已经发布了您要说的内容,则通过单击其答案旁边数字上方的向上箭头来支持他们更合适。
@fire:评论需要 50 声望。投票也需要声誉,IIRC。
J
Jesse Adam

我知道这是一个老问题,但是当我在寻找如何拥有一个可以通过覆盖选项继承的默认值时出现了,我想出了

//base class
public class Car
{
    public virtual string FuelUnits
    {
        get { return "gasoline in gallons"; }
        protected set { }
    }
}
//derived
public class Tesla : Car
{
    public override string FuelUnits => "ampere hour";
}

注意:这不会设置初始值,它会创建一个返回常量字符串的 get 访问器。如果 FuelUnits 的值设置为另一个字符串,FuelUnits 将忽略该值并继续返回 get 中定义的文字字符串。
u
user3076134

我认为这会为你提供一些默认值为 false 的 SomeFlag。

private bool _SomeFlagSet = false;
public bool SomeFlag
{
    get
    {
        if (!_SomeFlagSet)
            SomeFlag = false;        

        return SomeFlag;
    }
    set
    {
        if (!_SomeFlagSet)
            _SomeFlagSet = true;

        SomeFlag = value;        
    }
}