Wie geben Sie einer C # -Auto-Eigenschaft einen Standardwert?

Wie geben Sie eine C# - Auto-Eigenschaft einen Standardwert? Entweder nutze ich den Konstruktor, oder wieder die alte syntax.

Mit dem Konstruktor:

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

Mit der normalen syntax der Eigenschaft (mit einem default-Wert)

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

Gibt es eine bessere Möglichkeit?

InformationsquelleAutor der Frage bentford | 2008-09-02

automatic-properties c#

In C# 5 und früher zu geben, die automatisch implementierten Eigenschaften einen Standardwert, den Sie haben, es zu tun in einem Konstruktor.

Die Fähigkeit zu haben, die Eigenschaft auto-Initialisierungen enthalten ist, da C# 6.0. Die syntax ist:
```
public int X { get; set; } = x; //C# 6 or higher
```
InformationsquelleAutor der Antwort Darren Kopp

242

Bearbeiten 1/2/15

Mit C# 6 können Sie eine Initialisierung von auto-properties direkt (endlich!), es gibt jetzt die anderen Antworten in dem thread, beschreiben.

C# 5 und unten:

Obwohl die beabsichtigte Verwendung des Attributs ist nicht eigentlich die Werte der Eigenschaften, die Sie verwenden können, Reflexion, immer legen Sie Sie sowieso...

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

InformationsquelleAutor der Antwort Chuck Rostance

128

Beim inline ein initialer Wert für eine variable wird implizit im Konstruktor sowieso.

Ich würde behaupten, dass diese syntax wurde beste Praxis in C# - bis zu 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; }
}

Wie dieses gibt Ihnen eine klare Kontrolle der auftragswerte zugewiesen werden.

Als von C#6 gibt es einen neuen Weg:

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

InformationsquelleAutor der Antwort Keith

73

DefaultValueAttribute NUR die Arbeit in der vs-designer. Es wird nicht initialisiert die Eigenschaft, Wert.

Sehen DefaultValue-Attribut nicht funktioniert mit meiner Auto-Eigenschaft

InformationsquelleAutor der Antwort Darren Kopp
48

Manchmal benutze ich diese, wenn ich nicht wollen, es zu sein wirklich festlegen und beibehalten, in meiner db:
```
class Person
{
    private string _name; 
    public string Name 
    { 
        get 
        {
            return string.IsNullOrEmpty(_name) ? "Default Name" : _name;
        } 

        set { _name = value; } 
    }
}
```
Natürlich, wenn es nicht einen string, dann könnte ich das Objekt nullable ( Doppel -?, int? ) und überprüfen, ob es null zurückgeben und den Standardwert, oder geben den Wert zurück gesetzt.

Dann kann ich schauen Sie in meinem repository, um zu sehen, ob es mein Standard-und nicht bleiben, oder machen Sie einen backdoor-check-in, um zu sehen, der wahre status der backing-Wert vor dem speichern.

Hoffe, das hilft!

InformationsquelleAutor der Antwort crucible
22

Beginnend mit C# 6.0die Wir zuordnen können, Standardwert, der automatisch implementierten Eigenschaften.
```
public string Name { get; set; } = "Some Name";
```
Wir können auch Lesen-nur automatisch implementierte Eigenschaft wie:
```
public string Name { get; } = "Some Name";
```
Finden Sie unter: C# 6: Erste Reaktionen , Initialisierungen, die für die automatisch implementierten Eigenschaften - Von Jon Skeet

InformationsquelleAutor der Antwort Habib

In C# 6.0 ist dies ein Kinderspiel!

Können Sie tun es in der Class Erklärung selbst, in der Eigenschaft Erklärung Erklärungen.

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

InformationsquelleAutor der Antwort Shiva

kleines vollständiges Beispiel:

using System.ComponentModel;

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

InformationsquelleAutor der Antwort ghiboz

10

In der Version von C# (6.0) & mehrdie Sie tun können :

Für Readonly-Eigenschaften
```
public int ReadOnlyProp => 2;
```
Für beide Beschreibbar & Lesbare Eigenschaften
```
public string PropTest { get; set; } = "test";
```
In der aktuellen Version von C# (7.0)die Sie tun können : (Das snippet eher zeigt, wie Sie mit expression-bodied get/set-Accessoren zu machen ist kompakter als bei der Verwendung von backing-Felder)
```
private string label = "Default Value";

//Expression-bodied get /set accessors.
public string Label
{
   get => label;
   set => this.label = value; 
 }
```
InformationsquelleAutor der Antwort ANewGuyInTown

Meine Lösung ist ein benutzerdefiniertes Attribut, das bietet die Standard-Eigenschaft value Initialisierung von Konstanten oder mithilfe von property-typeninitialisierer.

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

Verwenden Sie dieses Attribut, es ist notwendig, um eine Klasse Erben von der speziellen Basis-Klassen-Initialisierer oder verwenden Sie eine statische Hilfsmethode:

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

Beispiel:

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

Ausgabe:

Item1
(X=3,Y=4)
StringValue

InformationsquelleAutor der Antwort introspected

8

Zusätzlich zu der Antwort schon akzeptiert, für das Szenario, wenn Sie wollen, definieren Sie eine Standard-Eigenschaft als Funktion von anderen Eigenschaften, die Sie verwenden können, Ausdruck Körper notation auf C#6.0 (und höher) für noch mehr elegante und präzise Konstrukte wie:
```
public class Person{

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

    public string First { get; set; } = "First";
    public string Last { get; set; } = "Last";
}
```
Können Sie verwenden die oben in der folgenden Weise
```
    var p = new Person();

    p.FullName; //First Last

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

    p.FullName; //Jon Snow
```
Um der Lage sein, um das "=>" - notation, die Eigenschaft muss nur gelesen werden, und Sie nicht mit der get-accessor Stichwort.

Details auf MSDN

InformationsquelleAutor der Antwort brakeroo
6

In C# 6 und höher können Sie einfach die syntax:
```
public object Foo { get; set; } = bar;
```
Beachten Sie, dass eine readonly Eigenschaft einfach weglassen, also:
```
public object Foo { get; } = bar;
```
Können Sie auch zuweisen readonly auto-Eigenschaften aus dem Konstruktor.

Vor diesem habe ich geantwortet, als unten.

Ich möchte vermeiden, das hinzufügen einer Voreinstellung an den Konstruktor; verlassen Sie, dass für dynamische Zuweisungen und vermeiden, dass zwei Punkte, an denen die variable zugeordnet ist (dh den Typ Standard und im Konstruktor). Normalerweise würde ich schreiben einfach eine normale Eigenschaft, in solchen Fällen.

Eine andere Möglichkeit ist, das zu tun, was ASP.Net macht und definieren Sie Standardwerte über ein Attribut:

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

InformationsquelleAutor der Antwort Lex
4

In den Konstruktor. Der Konstruktor hat den Zweck, initialisiert es die Daten der Mitglieder.

InformationsquelleAutor der Antwort RayLoveless
2

Haben Sie versucht, mit dem DefaultValueAttribute oder ShouldSerialize-und Reset-Methoden in Verbindung mit dem Konstruktor? Ich fühle mich wie einer dieser beiden Methoden ist notwendig, wenn Sie eine Klasse, die könnte zeigen, bis auf der Oberfläche des Designers oder in einer property-grid.

InformationsquelleAutor der Antwort OwenP

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

InformationsquelleAutor der Antwort FloodMoo

1

Persönlich, ich sehe nicht den Punkt, an dem es eine Eigenschaft überhaupt, wenn du nicht gehst, zu tun, überhaupt nichts über die auto-Eigenschaft. Lassen Sie es als ein Feld. Die Kapselung nutzen für diese Artikel sind nur Ablenkungsmanöver, denn es gibt nichts hinter Ihnen zu fassen. Wenn Sie jemals brauchen werden, um die zugrundeliegende Implementierung sind Sie noch frei umgestalten, Sie als Eigenschaften, ohne zu brechen alle abhängigen code.

Hmm... vielleicht wird dies das Thema der eigenen Frage später

InformationsquelleAutor der Antwort Joel Coehoorn
1

Zu klären, ja, müssen Sie default-Werte in den Konstruktor der Klasse abgeleitete Objekte. Sie müssen sicherstellen, dass die Konstruktor vorhanden ist, mit der richtigen access-modifier für den Bau verwendet. Wenn das Objekt nicht instanziiert, z.B. es hat keinen Konstruktor (z.B. statische Methoden), dann wird der default-Wert kann eingestellt werden, indem das Feld. Die Argumentation ist hier, dass das Objekt selbst wird nur einmal erstellt werden und Sie nicht instanziert.

@Darren Kopp - gute Antwort, sauber und korrekt. Und um zu wiederholen, KÖNNEN Sie schreiben Konstruktoren für Abstrakte Methoden. Sie brauchen nur Zugang zu Ihnen von der Basis-Klasse beim schreiben der Konstruktor:

Konstruktor an der Basis-Klasse:
```
public BaseClassAbstract()
{
    this.PropertyName = "Default Name";
}
```
Konstruktor bei Abgeleiteten /Beton /Sub-Klasse:
```
public SubClass() : base() { }
```
Der Punkt hier ist, dass die Instanz-variable gezeichnet von der Basisklasse kann, begraben Sie Ihre Basis-Feld-Namen. Einstellung der aktuellen instanziierte Objekt Wert mit "." wird Ihnen zulassen, korrekt bilden, Ihren Gegenstand mit Bezug auf die aktuelle Instanz und die erforderlichen Berechtigungsstufen (access-modifiers), wo Sie instanziieren.

InformationsquelleAutor der Antwort Zack Jannsen
1

Verwenden Sie den Konstruktor, weil "Wenn der Konstruktor fertig ist, sollten Bau fertig sein". Eigenschaften sind wie Staaten Ihre Klassen halten, wenn Sie hatte zu initialisieren einer default-Zustand ist, Sie würde tun, die in Ihrem Konstruktor.

InformationsquelleAutor der Antwort Preet Singh

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

InformationsquelleAutor der Antwort Nag

-2

Ich denke, das würde es für ya givng SomeFlag den Standardwert false.

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

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

        SomeFlag = value;        
    }
}

InformationsquelleAutor der Antwort user3076134

-3

initialisieren in der Linie mit Konstruktoren zu initialisieren, ist eine schlechte Gewohnheit und führt zu mehr wichtige änderungen später.

InformationsquelleAutor der Antwort dbobrowski

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.