C# Academy · Lektion

Fuldstændige properties med backing fields

Tilføj logik til getters og setters.

Lektion 2 af 413 trin

Fuldstændige properties med backing fields er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i C# Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C# Academy-kurset indeholder 4 lektioner i alt.

Ud over automatiske egenskaber

Når du har brug for logik i get eller set, skriver du en fuld egenskab med et eksplicit underliggende felt. Feltet gemmer dataene, mens adgangsmetoderne styrer adgangen.

using System;

class Temperature
{
    private double _celsius;

    public double Celsius
    {
        get { return _celsius; }
        set { _celsius = value; }
    }
}

class Program
{
    static void Main()
    {
        var t = new Temperature();
        t.Celsius = 21.5;
        Console.WriteLine(t.Celsius);
    }
}

Konventionen for underliggende felter

Efter konventionen er et underliggende felt private og navngives med en indledende understregning, f.eks. _name. Den offentlige egenskab stiller feltet til rådighed.

using System;

class Person
{
    private string _name;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
}

class Program
{
    static void Main()
    {
        var p = new Person();
        p.Name = "Grace";
        Console.WriteLine(p.Name);
    }
}

Nøgleordet value

I en set-adgangsmetode indeholder den implicitte parameter value den værdi, der tildeles. Du bestemmer selv, hvad der skal ske med den.

using System;

class Box
{
    private int _size;

    public int Size
    {
        get { return _size; }
        set { _size = value * 2; }
    }
}

class Program
{
    static void Main()
    {
        var box = new Box();
        box.Size = 10;
        Console.WriteLine("Stored size: " + box.Size);
    }
}

Validering i setteren

En almindelig anvendelse af en fuld egenskab er at validere inddata, før de gemmes, og kaste en undtagelse, hvis værdien er ugyldig.

using System;

class Account
{
    private decimal _balance;

    public decimal Balance
    {
        get { return _balance; }
        set
        {
            if (value < 0)
                throw new ArgumentException("Balance cannot be negative");
            _balance = value;
        }
    }
}

class Program
{
    static void Main()
    {
        var a = new Account();
        a.Balance = 500m;
        Console.WriteLine("Balance: " + a.Balance);
    }
}

Beregnede skrivebeskyttede egenskaber

En egenskab, der kun har en get, kan beregne sin værdi ud fra andre felter. Der er ikke noget underliggende felt, fordi intet gemmes.

using System;

class Rectangle
{
    private double _width;
    private double _height;

    public Rectangle(double w, double h)
    {
        _width = w;
        _height = h;
    }

    public double Area
    {
        get { return _width * _height; }
    }
}

class Program
{
    static void Main()
    {
        var r = new Rectangle(4, 5);
        Console.WriteLine("Area: " + r.Area);
    }
}

Bivirkninger i settere

En setter kan gøre mere end at gemme en værdi: Den kan normalisere inddata, opdatere relateret tilstand eller logge ændringer.

using System;

class User
{
    private string _email;

    public string Email
    {
        get { return _email; }
        set { _email = value.Trim().ToLower(); }
    }
}

class Program
{
    static void Main()
    {
        var u = new User();
        u.Email = "  Hello@Example.COM  ";
        Console.WriteLine("Normalized: " + u.Email);
    }
}

Udskudt beregning i en getter

En getter kan gemme et beregningskrævende resultat i et underliggende felt, første gang resultatet efterspørges.

using System;

class Report
{
    private string _cached;

    public string Content
    {
        get
        {
            if (_cached == null)
                _cached = "Generated at runtime";
            return _cached;
        }
    }
}

class Program
{
    static void Main()
    {
        var r = new Report();
        Console.WriteLine(r.Content);
        Console.WriteLine(r.Content);
    }
}

Beskyttelse mod ugyldig tilstand

Kombinér et underliggende felt med logik for altid at holde et objekt gyldigt. Her begrænser setteren værdien til et interval.

using System;

class Volume
{
    private int _level;

    public int Level
    {
        get { return _level; }
        set
        {
            if (value < 0) _level = 0;
            else if (value > 100) _level = 100;
            else _level = value;
        }
    }
}

class Program
{
    static void Main()
    {
        var v = new Volume();
        v.Level = 150;
        Console.WriteLine("Clamped: " + v.Level);
    }
}

Kombination af lagrede og beregnede egenskaber

En klasse blander ofte lagrede egenskaber med underliggende felter og beregnede, skrivebeskyttede egenskaber, der er afledt af dem.

using System;

class Employee
{
    private string _first;
    private string _last;

    public string First { get { return _first; } set { _first = value; } }
    public string Last { get { return _last; } set { _last = value; } }
    public string FullName { get { return _first + " " + _last; } }
}

class Program
{
    static void Main()
    {
        var e = new Employee { First = "Marie", Last = "Curie" };
        Console.WriteLine(e.FullName);
    }
}

Udsendelse af ændringsnotifikationer

Settere er det naturlige sted at give besked, når data ændres, og dette mønster bruges i stor udstrækning i UI-rammeværker.

using System;

class Model
{
    private int _count;

    public int Count
    {
        get { return _count; }
        set
        {
            if (_count != value)
            {
                _count = value;
                Console.WriteLine("Count changed to " + _count);
            }
        }
    }
}

class Program
{
    static void Main()
    {
        var m = new Model();
        m.Count = 1;
        m.Count = 1;
        m.Count = 2;
    }
}

Samling af det hele

Fulde egenskaber lader en klasse håndhæve invariansregler og stille afledte data til rådighed, alt sammen bag en ren, feltlignende grænseflade.

using System;

class Thermostat
{
    private double _target;

    public double Target
    {
        get { return _target; }
        set { _target = value < 10 ? 10 : value; }
    }

    public string Status { get { return _target >= 22 ? "Warm" : "Cool"; } }
}

class Program
{
    static void Main()
    {
        var th = new Thermostat();
        th.Target = 5;
        Console.WriteLine(th.Target + " -> " + th.Status);
        th.Target = 24;
        Console.WriteLine(th.Target + " -> " + th.Status);
    }
}

Hurtig kontrol

Test din forståelse af fulde egenskaber.

Besvar den i den interaktive lektion

Opsummering

En fuld egenskab kombinerer et privat underliggende felt med eksplicitte get/set-adgangsmetoder, så du kan tilføje validering, normalisering, caching eller ændringsnotifikationer. Beregnede, skrivebeskyttede egenskaber har kun en getter og intet underliggende felt. Nøgleordet value indeholder den værdi, der tildeles, i en setter.

using System;

class Demo
{
    private int _n;
    public int N
    {
        get { return _n; }
        set { _n = value < 0 ? 0 : value; }
    }
    public int Doubled { get { return _n * 2; } }
}

class Program
{
    static void Main()
    {
        var d = new Demo();
        d.N = -5;
        Console.WriteLine(d.N + ", " + d.Doubled);
    }
}

Gratis at komme i gang

Lær C# med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 93
Lektioner: 346

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Fuldstændige properties med backing fields” gratis?

Ja — hele teksten til “Fuldstændige properties med backing fields” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af C# Academy-kurset, skal du opgradere til CoddyKit PRO. C# Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Fuldstændige properties med backing fields”?

Tilføj logik til getters og setters. Du øver dig i C# Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C# Academy?

Der kræves ingen tidligere erfaring. C# Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Fuldstændige properties med backing fields”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C# Academy-lektion?

Ja. Alle C# Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Automatisk implementerede properties
Fuldstændige properties med backing fields
Udtryksbaserede medlemmer
Indexere

← Tilbage til C# Academy