Automatisch geïmplementeerde eigenschappen
Declareer eigenschappen met beknopte autosyntaxis.
Automatisch geïmplementeerde eigenschappen is een gratis C# Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C# Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C# Academy bevat in totaal 4 lessen.
Wat is een eigenschap?
Een eigenschap ziet er van buiten uit als een veld, maar wordt ondersteund door accessormethoden (get en set). Met eigenschappen kun je gegevens beschikbaar maken en tegelijk controle houden over hoe ze worden gelezen en geschreven.
using System;
class Program
{
public string Name { get; set; }
static void Main()
{
var p = new Program();
p.Name = "Coddy";
Console.WriteLine(p.Name);
}
}Syntax voor automatisch geïmplementeerde eigenschappen
Een automatisch geïmplementeerde eigenschap gebruikt { get; set; }. De compiler genereert een verborgen ondersteunend veld voor je, zodat je dat niet handmatig hoeft te schrijven.
using System;
class Person
{
public string FirstName { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main()
{
var person = new Person { FirstName = "Ada", Age = 36 };
Console.WriteLine(person.FirstName + " is " + person.Age);
}
}Waarom eigenschappen gebruiken in plaats van velden?
Openbare eigenschappen geven je een stabiele API. Je kunt later validatie toevoegen of de opslag wijzigen zonder aanroepende code te breken. Met openbare velden kan dat niet.
using System;
class Account
{
public decimal Balance { get; set; }
}
class Program
{
static void Main()
{
var a = new Account();
a.Balance = 100.50m;
Console.WriteLine("Balance: " + a.Balance);
}
}Automatische eigenschappen die alleen kunnen worden gelezen
Laat set weg om een eigenschap alleen-lezen te maken. Je kunt de eigenschap alleen toewijzen in de constructor of via een initialisatie, waardoor de waarde standaard onveranderlijk is.
using System;
class Circle
{
public double Radius { get; }
public Circle(double radius)
{
Radius = radius;
}
}
class Program
{
static void Main()
{
var c = new Circle(5.0);
Console.WriteLine("Radius: " + c.Radius);
}
}Standaardwaarden voor eigenschappen
Je kunt een automatische eigenschap een beginwaarde geven met = value;. Dit wordt uitgevoerd wanneer het object wordt gemaakt, vóór de constructorbody.
using System;
class Settings
{
public bool DarkMode { get; set; } = true;
public int Volume { get; set; } = 50;
}
class Program
{
static void Main()
{
var s = new Settings();
Console.WriteLine("DarkMode: " + s.DarkMode + ", Volume: " + s.Volume);
}
}Private setters
Met een private set kan de klasse de waarde intern wijzigen, terwijl externe code de waarde niet kan aanpassen. Dit is een veelgebruikt patroon voor inkapseling.
using System;
class Counter
{
public int Count { get; private set; }
public void Increment()
{
Count++;
}
}
class Program
{
static void Main()
{
var counter = new Counter();
counter.Increment();
counter.Increment();
Console.WriteLine("Count: " + counter.Count);
}
}Init-only setters
De init-accessor (C# 9+) staat toewijzing alleen toe tijdens het initialiseren van een object. Na het maken van het object is de waarde vergrendeld.
using System;
class Product
{
public string Name { get; init; }
public decimal Price { get; init; }
}
class Program
{
static void Main()
{
var p = new Product { Name = "Book", Price = 12.99m };
Console.WriteLine(p.Name + ": " + p.Price);
}
}Eigenschappen met verschillende toegangsniveaus
Eigenschappen volgen de normale toegangsmodificatoren. Je kunt niveaus combineren: een openbare getter met een private setter, of een volledig interne eigenschap.
using System;
class User
{
public string Id { get; private set; }
public User(string id)
{
Id = id;
}
}
class Program
{
static void Main()
{
var u = new User("u-001");
Console.WriteLine("User Id: " + u.Id);
}
}Automatische eigenschappen die berekend lijken
Automatische eigenschappen slaan gegevens op; ze voeren geen berekeningen uit. Als je een berekende waarde nodig hebt, gebruik je een volledige eigenschap, die later aan bod komt. Behandel automatische eigenschappen voorlopig als eenvoudige opslag.
using System;
class Rectangle
{
public double Width { get; set; }
public double Height { get; set; }
}
class Program
{
static void Main()
{
var r = new Rectangle { Width = 4, Height = 3 };
double area = r.Width * r.Height;
Console.WriteLine("Area: " + area);
}
}Automatische eigenschappen bijwerken
Je kunt een automatische eigenschap met een setter zo vaak lezen en opnieuw toewijzen als je wilt, net als een variabele.
using System;
class Player
{
public int Score { get; set; }
}
class Program
{
static void Main()
{
var player = new Player();
player.Score = 10;
player.Score += 5;
player.Score *= 2;
Console.WriteLine("Score: " + player.Score);
}
}Alles samenbrengen
Een typische modelklasse bestaat grotendeels uit automatische eigenschappen: sommige met een setter, sommige met alleen init en sommige met private setters. Zo blijft de klasse beknopt en duidelijk.
using System;
class BankAccount
{
public string Owner { get; init; }
public decimal Balance { get; private set; }
public void Deposit(decimal amount)
{
Balance += amount;
}
}
class Program
{
static void Main()
{
var acct = new BankAccount { Owner = "Lin" };
acct.Deposit(250m);
Console.WriteLine(acct.Owner + ": " + acct.Balance);
}
}Korte controle
Test je begrip van automatisch geïmplementeerde eigenschappen.
Samenvatting
Je hebt geleerd dat automatisch geïmplementeerde eigenschappen { get; set; } gebruiken met een door de compiler gegenereerd ondersteunend veld. Varianten zijn onder andere alleen-lezen-eigenschappen met { get; }, private set voor gecontroleerde wijzigingen en init voor waarden die je één keer instelt. Dit is de standaardmanier om gegevens in een klasse beschikbaar te maken.
using System;
class Demo
{
public string A { get; set; } = "settable";
public string B { get; } = "read-only";
public string C { get; init; } = "init-only";
}
class Program
{
static void Main()
{
var d = new Demo { C = "changed-at-init" };
Console.WriteLine(d.A + ", " + d.B + ", " + d.C);
}
}
Leer C# met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 93
- Lessen
- 346
Veelgestelde vragen
Is de les “Automatisch geïmplementeerde eigenschappen” gratis?
Ja — de volledige tekst van “Automatisch geïmplementeerde eigenschappen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C# Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C# Academy bevat in totaal 4 lessen.
Wat leer ik in “Automatisch geïmplementeerde eigenschappen”?
Declareer eigenschappen met beknopte autosyntaxis. Je oefent met C# Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met C# Academy te beginnen?
Ervaring vooraf is niet nodig. C# Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Automatisch geïmplementeerde eigenschappen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over C# Academy?
Ja. Elke les over C# Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Automatisch geïmplementeerde eigenschappen
- Volledige eigenschappen met backingvelden
- Leden met expressies als body
- Indexers