Leden met expressies als body
Schrijf compacte eigenschappen en methoden.
Leden met expressies als body is een gratis C# Academy-les op CoddyKit. Dit is les 3 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.
Een beknoptere syntaxis
De syntaxis met een expressielichaam gebruikt => om een lid als één expressie te definiëren, ter vervanging van een volledige body met { ... }. Hierdoor worden korte leden compact en leesbaar.
using System;
class Greeter
{
public string Hello() => "Hi there!";
}
class Program
{
static void Main()
{
var g = new Greeter();
Console.WriteLine(g.Hello());
}
}Methoden met een expressielichaam
Elke methode waarvan de body uit één expressie bestaat, kan => gebruiken. Het resultaat van de expressie wordt de geretourneerde waarde.
using System;
class MathHelper
{
public int Square(int x) => x * x;
public int Add(int a, int b) => a + b;
}
class Program
{
static void Main()
{
var m = new MathHelper();
Console.WriteLine(m.Square(6));
Console.WriteLine(m.Add(3, 4));
}
}Alleen-lezen-eigenschappen met een expressielichaam
Een berekende, alleen-lezen-eigenschap kan => gebruiken in plaats van get { return ...; }.
using System;
class Rectangle
{
public double Width { get; set; }
public double Height { get; set; }
public double Area => Width * Height;
}
class Program
{
static void Main()
{
var r = new Rectangle { Width = 4, Height = 5 };
Console.WriteLine("Area: " + r.Area);
}
}get en set met een expressielichaam
Je kunt de get- en set-accessors ook elk een eigen expressielichaam geven, wat handig is in combinatie met een ondersteunend veld.
using System;
class Person
{
private string _name;
public string Name
{
get => _name;
set => _name = value.Trim();
}
}
class Program
{
static void Main()
{
var p = new Person();
p.Name = " Niki ";
Console.WriteLine("[" + p.Name + "]");
}
}Berekende tekenreeksen retourneren
Eigenschappen met een expressielichaam zijn bijzonder geschikt voor opgemaakte, afgeleide waarden zoals volledige namen of labels.
using System;
class Customer
{
public string First { get; set; }
public string Last { get; set; }
public string Display => First + " " + Last;
}
class Program
{
static void Main()
{
var c = new Customer { First = "Ada", Last = "Lovelace" };
Console.WriteLine(c.Display);
}
}Een expressielichaam met voorwaarden
De enkele expressie kan een voorwaardelijke operator (ternaire operator) bevatten, zodat vertakkingslogica op één regel blijft.
using System;
class Account
{
public decimal Balance { get; set; }
public string Status => Balance >= 0 ? "OK" : "Overdrawn";
}
class Program
{
static void Main()
{
var a = new Account { Balance = -20m };
Console.WriteLine(a.Status);
}
}Void-methoden met een expressielichaam
Een methode die een actie uitvoert en niets retourneert, kan ook een expressielichaam gebruiken als de actie uit één instructie bestaat.
using System;
class Logger
{
public void Log(string msg) => Console.WriteLine("[LOG] " + msg);
}
class Program
{
static void Main()
{
var log = new Logger();
log.Log("Started");
}
}Constructors met een expressielichaam
Een constructor met één toewijzing kan ook de pijltjessyntaxis gebruiken.
using System;
class Point
{
public int X { get; }
public Point(int x) => X = x;
}
class Program
{
static void Main()
{
var p = new Point(7);
Console.WriteLine("X = " + p.X);
}
}Wanneer je dit NIET gebruikt
Expressielichamen zijn alleen bedoeld voor één expressie. Als je meerdere instructies, lussen of vertakkingen voor validatie nodig hebt, gebruik je in plaats daarvan een normale body met blokhaken.
using System;
class Calculator
{
// Single expression -> arrow is fine
public int Triple(int n) => n * 3;
// Multiple statements -> use a block
public int SumTo(int n)
{
int total = 0;
for (int i = 1; i <= n; i++) total += i;
return total;
}
}
class Program
{
static void Main()
{
var c = new Calculator();
Console.WriteLine(c.Triple(4));
Console.WriteLine(c.SumTo(5));
}
}Meerdere gebruiken in één klasse
Een kleine klasse kan voor bijna elk lid de pijltjessyntaxis gebruiken, waardoor je aanzienlijk minder standaardcode nodig hebt.
using System;
class Temperature
{
public double Celsius { get; set; }
public double Fahrenheit => Celsius * 9 / 5 + 32;
public double Kelvin => Celsius + 273.15;
public override string ToString() => Celsius + "C";
}
class Program
{
static void Main()
{
var t = new Temperature { Celsius = 25 };
Console.WriteLine(t + " = " + t.Fahrenheit + "F = " + t.Kelvin + "K");
}
}Alles samenbrengen
Gebruik leden met een expressielichaam om eenvoudige getters, hulpfuncties en methoden van één regel netjes te houden, en gebruik bodies met blokhaken voor echte logica.
using System;
class Order
{
public int Quantity { get; set; }
public decimal UnitPrice { get; set; }
public decimal Total => Quantity * UnitPrice;
public bool IsLarge => Quantity > 10;
}
class Program
{
static void Main()
{
var o = new Order { Quantity = 12, UnitPrice = 9.99m };
Console.WriteLine("Total: " + o.Total + ", Large: " + o.IsLarge);
}
}Korte controle
Test je begrip van leden met een expressielichaam.
Samenvatting
Leden met een expressielichaam gebruiken => om een lid met één expressie te definiëren. Ze werken voor methoden, alleen-lezen-eigenschappen, afzonderlijke get- en set-accessors en zelfs constructors. Gebruik ze voor beknopte code van één regel; schakel over op een body met blokhaken zodra je meerdere instructies nodig hebt.
using System;
class Demo
{
public int N { get; set; }
public int Doubled => N * 2;
public string Label() => "N is " + N;
}
class Program
{
static void Main()
{
var d = new Demo { N = 9 };
Console.WriteLine(d.Label() + ", doubled = " + d.Doubled);
}
}
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 “Leden met expressies als body” gratis?
Ja — de volledige tekst van “Leden met expressies als body” 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 “Leden met expressies als body”?
Schrijf compacte eigenschappen en methoden. 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 3 van 4.
Hoe lang duurt de les “Leden met expressies als body”?
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