Touch metoden øvelse: Programmering på C# språk

C# startet opprinnelig som et språk for Windows-skrivebordsapplikasjoner, men har utviklet seg til et allsidig multiparadigmespråk i kjernen av .NET-plattformen. Det brukes til webapplikasjoner, API-er, skrivebordsprogrammer, mobilapper, spillutvikling (særlig Unity) og skybaserte mikrotjenester. Språket legger vekt på lesbarhet, produktivitet og tett integrasjon med utviklingsverktøy. Samtidig er syntaksen i C# rik på nøkkelord og symboler, og krever nøyaktig inntasting. Derfor er ti-fingerskriving i C# (touch-metoden) ikke bare en praktisk ferdighet, men et fundament for å redusere små, men alvorlige feil i generics Eng.: generics - typeparametre, attributter, nullbarhetssystemet, lambda-uttrykk og LINQ-spørringer. Utviklere som behersker hurtigskriving i C# opplever færre kompileringsfeil, raskere refaktorering og høyere presisjon selv i symboltett kode.

Konvensjoner og idiomatisk C#

Stilen i C# bygger på klare konvensjoner. Klasser, structs og enums bruker PascalCase. Metoder og egenskaper bruker også PascalCase, mens lokale variabler og parametre følger camelCase. Private felt begynner ofte med en understrek, som _value. Konstanter skrives gjerne i PascalCase, men noen team foretrekker UPPER_SNAKE_CASE. Grensesnitt begynner med "I", for eksempel IEnumerable eller IDisposable. Disse mønstrene fremmer lesbarhet, men skaper ofte lange identifikatorer. Ti-fingerskriving i C# gjør det naturlig å skrive navn som GetCustomerInvoicesAsync, mens hurtigskriving i C# lar deg opprettholde tempoet.

using-direktiv, namespaces og struktur

Et typisk C#-dokument starter med using-direktiv etterfulgt av en namespace. Moderne versjoner av språket støtter file-scoped namespaces, som reduserer innrykk. Likevel forblir lange navn som System.Collections.Generic feilutsatte. Ti-fingerskriving i C# gjør slike sekvenser intuitive, mens hurtigskriving i C# gjør det lettere å rydde og reorganisere imports.

namespace Demo.Utilities;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

Klasser, structs og records

C# støtter klasser (referansesemantikk), structs (verdisemantikk) og records Eng.: record - kompakte datatyper med verdibasert likhet. Records gir konsis syntaks, men krever nøyaktig plassering av parenteser og kommaer. Structs kan ha modifikatorer som readonly og ref. Et enkelt feilplassert symbol kan stoppe en kompilering. Ti-fingerskriving i C# gir konsistens, og hurtigskriving i C# gjør utvidelser fra record til kompleks klasse enklere.

public record Invoice(Guid Id, string Customer, decimal Total);

public readonly struct Point
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}

Egenskaper og expression-bodied members

Egenskaper er et sentralt element i idiomatisk C#. Auto-implemented properties kombineres ofte med init-only egenskaper og expression-bodied members (=>). Kortfattet syntaks betyr høyere krav til nøyaktighet. Ti-fingerskriving i C# gjør => til en vane, mens hurtigskriving i C# hjelper med å lage mange lignende egenskaper på kort tid.

public class Account
{
    public decimal Balance { get; private set; }
    public void Deposit(decimal amount) => Balance += amount;
}

Generics og where-betingelser

Generics gir type-sikkerhet og gjenbruk. Eksempler er List<T> og Dictionary<TKey,TValue>, ofte med where-betingelser. Innfløkte typer som Dictionary<string, List<int>> er lette å skrive feil. Ti-fingerskriving i C# gir trygghet i bruk av vinkelklammer, mens hurtigskriving i C# gjør det raskt å utvide eller endre constraints.

public class Repository<T> where T : class, new()
{
    private readonly List<T> _items = new();
    public void Add(T item) => _items.Add(item);
    public IEnumerable<T> All() => _items;
}

Overloading, operatorer og indexere

Overloading Eng.: overloading - metoder med samme navn men ulike parametre brukes mye i C#. Operator-overloading og indexere Eng.: indexer - egenskaper som gir array-lignende tilgang er også mulig. Syntaksen krever nøyaktighet med operator og parenteser. Ti-fingerskriving i C# fremmer konsistens, mens hurtigskriving i C# gir hastighet i gjentatte overloader.

public readonly record struct Point(int X, int Y)
{
    public static Point operator +(Point a, Point b) => new(a.X + b.X, a.Y + b.Y);
}

Lambdaer, delegater og events

Delegater Eng.: delegates - typede funksjonssignaturer og events er grunnleggende i C# sitt hendelsesdrevne mønster. Lambdaer lar deg skrive anonyme funksjoner på en kompakt måte. Symboler som =>, parenteser og null-operatorer er små, men viktige. Ti-fingerskriving i C# gjør dette mønsteret intuitivt, hurtigskriving i C# lar deg lage event-håndtering og små funksjoner raskt.

public event Action? Updated;
public void Raise() => Updated?.Invoke();
var square = (int x) => x * x;

LINQ og spørringssyntaks

LINQ (Language Integrated Query) er et kjennetegn ved C#. Det kombinerer metodekjeder og SQL-lignende syntaks. Punktum, parenteser og piler må plasseres nøyaktig. Ti-fingerskriving i C# gjør lange kjeder flytende, hurtigskriving i C# gjør det enkelt å eksperimentere med transformasjoner og filtre.

var results = orders.Where(o => o.Total > 100)
                    .Select(o => o.Customer)
                    .OrderBy(n => n)
                    .ToList();

async/await og asynkron programmering

Asynkronitet er en styrke i C#. Med async og await blir koden lesbar, men en glemt await endrer programflyten dramatisk. Task<T>-signaturer kombinerer generics og parenteser, og krever presisjon. Ti-fingerskriving i C# øker sikkerheten, mens hurtigskriving i C# gjør endringer og tillegg raskt å utføre.

static async Task<string> FetchAsync(HttpClient http, string url)
{
    using var resp = await http.GetAsync(url);
    return await resp.Content.ReadAsStringAsync();
}

Pattern matching og switch-uttrykk

Pattern matching reduserer boilerplate-kode. Switch-uttrykk bruker piler, understrek og må være presise. Ti-fingerskriving i C# reduserer feil, hurtigskriving i C# gjør det enkelt å teste varianter.

static string Describe(object? x) => x switch
{
    null => "null",
    int n and >= 0 => "non-negative",
    string s and { Length: > 3 } => "string",
    _ => "other"
};

nullbarhet og defensiv stil

Nullbarhetssystemet gjør null eksplisitt. Operatorer som ?, ?? og ?. er allestedsnærværende. Ti-fingerskriving i C# minimerer feil, hurtigskriving i C# gjør annotasjoner og defensiv kode raskere å legge til.

public string Normalize(string? input)
{
    return (input?.Trim() ?? string.Empty).ToUpperInvariant();
}

Attributter og metadata

Attributter legger til metadata i koden og skrives i hakeparenteser. Et feilplassert tegn kan stoppe en build. Ti-fingerskriving i C# sikrer korrekt plassering, hurtigskriving i C# gjør massebruk enklere.

[Obsolete("Use NewApi")]
public void OldMethod() { }

Strenger og formatering

C# støtter interpolerte strenger $"", verbatim strenger @"" og rå strenglitteraler """. Spesielt i interpolerte strenger må klammeparenteser brukes korrekt. Ti-fingerskriving i C# gjør dette instinktivt, hurtigskriving i C# forenkler arbeid med lange tekster eller JSON.

var msg = $"Hello {name}, today is {DateTime.Now:yyyy-MM-dd}";
var path = @"C:\logs\app.log";
var json = """
{ "status": "ok", "active": true }
""";

Ranges, indexere og Span

.. og ^ gjør slicing mulig, mens Span<T> gir effektiv minnehåndtering. Små tegn med stor betydning. Ti-fingerskriving i C# gjør dem naturlige, hurtigskriving i C# gjør repetisjon enkelt.

var middle = numbers[1..^1];

Dokumentasjon og analyzers

XML-dokumentasjon starter med /// og inkluderer tagger som <summary>. Analyzers Eng.: analyzers - statiske analyseringsregler sikrer stil og kvalitet. Ti-fingerskriving i C# gjør kommentarskriving flytende, hurtigskriving i C# letter byrden ved API-dokumentasjon.

/// <summary>Representerer en bruker i systemet.</summary>
public class User { }

Vanlige feil

Typiske feil er feil med generics-klammer, manglende await, forveksling av => og =, misbruk av null-operatorer og glemte semikolon. Ti-fingerskriving i C# reduserer slike feil, hurtigskriving i C# gjør korrigering raskt.

Sammenligning med C++ og Java

C# hentet inspirasjon fra C++ og Java, men tok andre valg. Sammenlignet med C++ fjernet det pekersyntaks, manuell minnehåndtering og header-filer. Dermed ser man færre *- og &-symboler, men flere vinkelklammer og spørsmålstegn. Ti-fingerskriving i C# gir jevnt tastemønster, hurtigskriving i C# holder effektiviteten også i LINQ og async/await.

Sammenlignet med Java tilbyr C# mer syntaktisk sukker: expression-bodied members, lambdas, pattern matching, attributter, nullbarhet og strenginterpolasjon. Det gir flere symboler å skrive, men ti-fingerskriving i C# holder presisjonen høy, hurtigskriving i C# bevarer produktiviteten.

Hvorfor skriveferdigheter betyr noe

Syntaksen i C# er full av symboler: vinkelklammer for generics, hakeparenteser for attributter og indexere, piler for lambdaer og switch, spørsmålstegn for nullbarhet, punktum for kjeding av metoder og XML-tagger for dokumentasjon. De dukker stadig opp og krever presisjon. Ti-fingerskriving i C# reduserer feil, hurtigskriving i C# lar deg fortsette uavbrutt med dokumentasjon, LINQ eller refaktorering.

Oppsummering

C# er et uttrykksfullt, strukturert og funksjonsrikt språk. Elegansen ligger ikke i å unngå symboler, men i å gi dem mening: piler i lambdas og switch, spørsmålstegn for nullbarhet, hakeparenteser for attributter og vinkelklammer for generics. Ti-fingerskriving i C# gjør dette til refleks, hurtigskriving i C# gjør rutineoppgaver som overloading, LINQ og dokumentasjon jevne og effektive. I et språk der symboler og konvensjoner er en del av uttrykket, er skriveferdigheter et praktisk fundament for korrekt, vedlikeholdbar og produktiv kode.