Hur fungerar klasser, konstruktörer och egenskaper?

Question

Accepted Answer

**Klasser** är grunden för C#:s objektorienterade modell — ritningar för objekt, med **konstruktörer** (initierar objekt) och **egenskaper** (kontrollerad åtkomst till data). C#:s egenskapssyntax är en distinktiv, elegant funktion.

## En klass med konstruktör och egenskaper

```csharp
public class Person
{
    // auto-implemented PROPERTY — encapsulated access with get/set
    public string Name { get; set; }
    public int Age { get; private set; }      // settable only within the class
    public string Email { get; init; }          // set only during initialization (C# 9)

// CONSTRUCTOR
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

public string Greet() => $"Hi, I'm {Name}";   // a method
}

var person = new Person("Ann", 30);    // create an instance
person.Name = "Bob";                     // set a property
Console.WriteLine(person.Greet());
```

## Egenskaper — inkapsling gjord elegant

```csharp
// auto-property (the common case) — compiler generates the backing field
public string Name { get; set; }

// property with custom logic
private decimal _balance;
public decimal Balance
{
    get => _balance;
    set => _balance = value >= 0 ? value : throw new ArgumentException();   // validation
}

// expression-bodied / computed property
public string FullName => $"{First} {Last}";   // read-only, computed
```

**Egenskaper** ser ut som fält men är faktiskt metoder (`get`/`set`) — som tillhandahåller inkapsling (kontrollerad åtkomst, validering, beräknade värden) med ren syntax. Autoeigenskaper (`{ get; set; }`) hanterar det vanliga fallet utan någon boilerplate.

## Objektinitierare och moderna funktioner

```csharp
var p = new Person("Ann", 30) { Email = "a@x.com" };   // object initializer

// primary constructor (C# 12) — concise constructor parameters
public class Point(int x, int y)
{
    public int X { get; } = x;
}
```

## Varför det spelar roll

Klasser, konstruktörer och egenskaper är grunden för objektorienterad C# — nästan all C#-kod är organiserad i klasser, så att förstå dem är essentiellt för all C#-utveckling.

Att veta hur man definierar klasser med konstruktörer (initierar objekt) och metoder är grundläggande, men C#:s **egenskaper** är en särskilt viktig och distinktiv funktion som är värd att förstå väl.

Egenskaper tillhandahåller **inkapsling** elegant — de ser ut som fält men är faktiskt `get`/`set`-metoder, vilket möjliggör kontrollerad åtkomst, validering, beräknade värden och åtkomstmodifierare (som `private set` eller `init`-only) samtidigt som rensyntax behålls. **Autoeigenskaper** (`{ get; set; }`) hanterar det vanliga fallet utan någon boilerplate, vilket gör inkapsling ansträngningsfri (till skillnad från språk där du skriver explicita getter/setter-metoder).

Att förstå egenskaper (autoeigenskaper, anpassad logik, beräknade/skrivskyddade, `init`-only för oföränderlighet), konstruktörer, objektinitierare och moderna bekvämligheter (primära konstruktörer) är kärn-, vardaglig kunskap för att skriva väl-inkapslade C#-klasser.

Eftersom klasser är hur du modellerar data och beteende genom C#-applikationer, och eftersom egenskaper är det idiomatiska, eleganta sättet C# hanterar inkapsling (en distinktiv språkfunktion som används konstant), är att bemästra dessa — särskilt egenskapssystemet — grundläggande, måste-kunna-material för effektiv objektorienterad C#-utveckling.