Introduktion til C#

C# (udtales "C sharp") er et moderne programmeringssprog til generelle formål udviklet af Microsoft. Det er meget brugt til at bygge forskellige typer applikationer, herunder desktop-, web-, mobil- og spilapplikationer. I denne guide vil vi dække det grundlæggende i C#-programmering, herunder datatyper, variabler, kontrolflow, funktioner, klasser, navneområder og mere.

Ydermere tilbyder C# et rigt sæt funktioner og værktøjer, hvilket gør det til et alsidigt og kraftfuldt programmeringssprog til forskellige domæner, herunder desktop-applikationer, webudvikling, mobilapps og spiludvikling ved hjælp af teknologier som Unity. Efterhånden som du skrider frem i din C#-rejse, kan du udforske mere avancerede emner såsom arv, polymorfi, grænseflader, generiske stoffer, LINQ (Language Integrated Query) og asynkron programmering ved hjælp af opgaver og async/wait. Forståelse af disse koncepter vil forbedre din evne til at designe robuste og skalerbare applikationer.

Lad os starte med det grundlæggende.

Opsætning af udviklingsmiljøet

For at begynde at kode i C#, skal du konfigurere dit udviklingsmiljø. Her er trinene til at komme i gang:

Installer Visual Studio: Download og installer Visual Studio fra det officielle Microsoft-websted. Visual Studio er et kraftfuldt Integrated Development Environment (IDE), der giver alle de nødvendige værktøjer til C#-udvikling.
Opret et nyt projekt: Start Visual Studio og opret et nyt projekt. Vælg den relevante projektskabelon baseret på den type applikation, du vil bygge.
Skriv kode: Når dit projekt er sat op, kan du begynde at skrive C#-kode i kodeeditoren leveret af Visual Studio.

Nu hvor du har sat dit udviklingsmiljø op, lad os dykke ned i det grundlæggende i C#-programmering.

Hello World Program

Det traditionelle "Hej, verden!" program er ofte det første program, du skriver på et hvilket som helst programmeringssprog. Sådan kan du skrive det i C#:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

I dette kodeeksempel inkluderer vi først 'System' navneområdet, som indeholder en klasse ved navn 'Console', til håndtering af input og output. Derefter definerer vi en klasse ved navn 'Program'. Inde i denne klasse har vi en 'Main' metode, som er indgangspunktet for et C#-program. Til sidst bruger vi metoden 'Console.WriteLine' til at udskrive "Hej, verden!" besked til konsollen.

Variabler og datatyper

I C# skal du erklære variabler, før du kan bruge dem. Variabler indeholder værdier af forskellige datatyper. Her er nogle almindeligt anvendte datatyper i C#:

'int': Repræsenterer hele tal (f.eks. 10, -5, 0).
'double': Repræsenterer tal med flydende komma med decimaler (f.eks. 3,14, -0,5).
'bool': Repræsenterer booleske værdier (sand eller falsk).
'string': Repræsenterer en sekvens af tegn (f.eks. "Hello", "C#").

Her er et eksempel, der demonstrerer variabeldeklaration og grundlæggende handlinger:

int age = 25;
double pi = 3.14;
bool isStudent = true;
string name = "John";

int sum = age + 5;
double circleArea = pi * 2 * 2;
bool isAdult = age >= 18;

Console.WriteLine("Name: " + name);
Console.WriteLine("Age: " + age);
Console.WriteLine("Sum: " + sum);
Console.WriteLine("Circle Area: " + circleArea);
Console.WriteLine("Is Adult? " + isAdult);

I dette eksempel erklærer vi variablene 'age', 'pi', 'isStudent' og 'name' med deres respektive datatyper. Vi udfører nogle grundlæggende operationer som addition, multiplikation og sammenligning. Metoden 'Console.WriteLine' bruges til at vise værdierne på konsollen.

Arrays og samlinger

Arrays og samlinger er grundlæggende datastrukturer i C#, der giver dig mulighed for at gemme og manipulere flere værdier effektivt. De spiller en afgørende rolle i forskellige programmeringsscenarier og bruges i vid udstrækning i C#-udvikling.

Arrays

Et array i C# er en samling af elementer af samme type i fast størrelse. Her er et eksempel:

int[] numbers = new int[5] { 1, 2, 3, 4, 5 };

I dette eksempel erklærer vi et heltalsarray ved navn 'numbers' med en størrelse på '5'. Vi initialiserer arrayet med de angivne værdier ved hjælp af de krøllede klammeparenteser '{}'. Du kan få adgang til individuelle elementer i arrayet ved hjælp af indeksnotation, startende fra 0. For eksempel giver 'numbers[0]' dig det første element.

Samlinger

Samlinger i C# giver mere fleksibilitet end arrays, da de kan vokse eller formindskes dynamisk. C# tilbyder forskellige samlingstyper, såsom 'List<T>', 'Dictionary<TKey, TValue>' og 'HashSet<T>'.

Du kan oprette en generisk samling ved at bruge en af klasserne i 'System.Collections.Generic' navnerummet. En generisk samling er nyttig, når hvert element i samlingen har den samme datatype. En generisk samling fremtvinger stærk indtastning ved kun at tillade, at den ønskede datatype tilføjes.

using System.Collections.Generic;

Her er et eksempel, der bruger 'List<T>'-samlingen:

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
names.Add("Charlie");

I dette eksempel opretter vi en liste over strenge med navnet 'names' ved hjælp af initialiseringsklassen 'List<T>'. Vi bruger metoden 'Add()' til at tilføje elementer til listen.

'List<T>' giver mange nyttige metoder og egenskaber til at arbejde med samlinger, såsom 'Count' for at få antallet af elementer, 'Remove()' for at fjerne et element, og 'Contains()' for at kontrollere, om et element eksisterer.

Iteration over arrays og samlinger

Du kan iterere over arrays og samlinger ved hjælp af loops, såsom 'for' eller 'foreach', for at få adgang til og manipulere deres elementer. Her er et eksempel på iteration over et array og en liste:

int[] numbers = new int[] { 1, 2, 3, 4, 5 };

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

List<string> names = new List<string>() { "Alice", "Bob", "Charlie" };

foreach (string name in names)
{
    Console.WriteLine(name);
}

I dette eksempel bruger vi 'foreach'-løkken til at iterere over hvert element i arrayet 'numbers' og listen 'names' og udskrive dem til konsollen.

Styr flow

Kontrolflow giver dig mulighed for at træffe beslutninger og udføre forskellige kodeblokke baseret på betingelser. C# giver flere kontrolflowstrukturer, herunder 'if'-sætninger, 'switch'-sætninger og loops.

'If'

En 'if'-sætning tillader dig kun at udføre en kodeblok, hvis en specificeret betingelse er sand. Her er et eksempel:

int number = 10;

if (number > 0)
{
    Console.WriteLine("The number is positive.");
}
else if (number < 0)
{
    Console.WriteLine("The number is negative.");
}
else
{
    Console.WriteLine("The number is zero.");
}

I dette eksempel kontrollerer vi værdien af 'number'-variablen ved hjælp af 'if', 'else if' og 'else'-sætningerne. Afhængigt af tilstanden vil den relevante meddelelse blive udskrevet.

'Switch'

En 'switch'-sætning giver dig mulighed for at vælge en af mange kodeblokke, der skal udføres baseret på værdien af et udtryk. Her er et eksempel:

int dayOfWeek = 2;
string dayName;

switch (dayOfWeek)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    // ...
    default:
        dayName = "Invalid day";
        break;
}

Console.WriteLine("Today is " + dayName + ".");

I dette eksempel tildeler vi dagens navn baseret på værdien af 'dayOfWeek' ved hjælp af udsagnet 'switch'. 'case'-sætningerne angiver de mulige værdier, og 'default'-tilfældet udføres, hvis ingen af tilfældene matcher.

Løkkeerklæringer

Loops giver dig mulighed for gentagne gange at udføre en blok kode, indtil en bestemt betingelse er opfyldt. C# giver 'for', 'while' og 'do-while' loops.

'For'

En 'for' loop bruges, når du kender antallet af iterationer på forhånd. Her er et eksempel:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Iteration: " + i);
}

I dette eksempel kører løkken fem gange og udskriver iterationsnummeret hver gang.

'While'

En 'while' loop bruges, når du ikke kender antallet af iterationer på forhånd, men du har en betingelse at tjekke. Her er et eksempel:

int count = 0;

while (count < 5)
{
    Console.WriteLine("Count: " + count);
    count++;
}

I dette eksempel kører løkken, indtil variablen 'count' når 5.

'Do-While'

En 'do-while'-løkke ligner en while-løkke, men betingelsen kontrolleres i slutningen, så løkken udføres mindst én gang. Her er et eksempel:

int num = 1;

do
{
    Console.WriteLine("Number: " + num);
    num++;
} while (num <= 5);

I dette eksempel kører løkken, indtil variablen 'num' ikke længere er mindre end eller lig med 5.

Funktioner

Funktioner giver dig mulighed for at indkapsle genanvendelige kodeblokke. C# understøtter definition af funktioner ved hjælp af 'void' nøgleordet for metoder, der ikke returnerer en værdi, og andre datatyper for metoder, der returnerer en værdi. Her er et eksempel:

int Add(int a, int b)
{
    return a + b;
}

void Greet(string name)
{
    Console.WriteLine("Hello, " + name + "!");
}

int result = Add(5, 3);
Greet("Alice");

I dette eksempel definerer vi to funktioner: 'Add' og 'Greet'. Funktionen 'Add' tager to heltalsparametre og returnerer deres sum. Funktionen 'Greet' tager en strengparameter og udskriver en hilsen. Vi kalder derefter disse funktioner med de relevante argumenter.

Klasser og objekter

C# er et objektorienteret programmeringssprog, hvilket betyder, at det understøtter oprettelsen af klasser og objekter. Klasser definerer planen for oprettelse af objekter, som er forekomster af disse klasser. Her er et eksempel:

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void SayHello()
    {
        Console.WriteLine("Hello, my name is " + Name + " and I'm " + Age + " years old.");
    }
}

Person person = new Person();
person.Name = "John";
person.Age = 30;
person.SayHello();

I dette eksempel definerer vi en 'Person' klasse med 'Name' og 'Age' egenskaber og en 'SayHello' metode. Vi opretter derefter en forekomst af 'Person'-klassen ved hjælp af 'new' nøgleordet og indstiller dens egenskaber. Til sidst kalder vi 'SayHello'-metoden på 'person'-objektet.

Objektorienteret programmering (OOP) koncepter

C# er et objektorienteret programmeringssprog, og det giver forskellige funktioner til at understøtte OOP-koncepter såsom arv, indkapsling og polymorfi.

Arv

Arv giver dig mulighed for at oprette nye klasser baseret på eksisterende klasser, og arver deres egenskaber og adfærd. Her er et eksempel:

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape.");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

I dette eksempel arver 'Circle'-klassen fra 'Shape'-klassen ved at bruge ':'-symbolet. 'Circle'-klassen tilsidesætter 'Draw'-metoden fra basisklassen for at give sin egen implementering.

Indkapsling

Encapsulation er praksis med at samle data og metoder sammen i en klasse og kontrollere deres adgang. Du kan bruge adgangsmodifikatorer ('public', 'private', 'protected' osv.) til at angive medlemmernes synlighed. Her er et eksempel:

class Person
{
    private string name;

    public string GetName()
    {
        return name;
    }

    public void SetName(string newName)
    {
        name = newName;
    }
}

I dette eksempel er 'name'-feltet indkapslet i 'Person'-klassen og kan kun tilgås gennem 'GetName' og 'SetName' metoder.

Polymorfi

Polymorfi tillader genstande af forskellige klasser at blive behandlet som genstande af en fælles basisklasse. Dette gør det muligt at skrive kode, der arbejder med forskellige typer objekter på en ensartet måde. Her er et eksempel:

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound.");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks.");
    }
}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Cat meows.");
    }
}

I dette eksempel har 'Animal'-klassen en virtuel 'MakeSound'-metode, som er tilsidesat af 'Dog' og 'Cat' klasser. Polymorfi giver os mulighed for at behandle tilfælde af 'Dog' og 'Cat' som tilfælde af 'Animal' og kalde 'MakeSound' metode på dem.

Undtagelseshåndtering

Undtagelseshåndtering giver dig mulighed for at håndtere runtime fejl elegant. I C# kan du bruge 'try-catch' blokke til at fange og håndtere undtagelser. Her er et eksempel:

try
{
    int result = 10 / 0;
    Console.WriteLine("Result: " + result);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Divide by zero error: " + ex.Message);
}
finally
{
    Console.WriteLine("Cleanup code goes here.");
}

I dette eksempel forsøger vi at udføre en division med nul, hvilket kaster en 'DivideByZeroException'. Koden inde i 'try' blokken udføres, og hvis der opstår en undtagelse, fanges den af blokken 'catch'.

'finally'-blokken udføres, uanset om der forekommer en undtagelse eller ej, og den bruges typisk til oprydningsoperationer.

Undtagelseshåndtering hjælper med at forhindre programnedbrud og giver mulighed for kontrolleret fejlhåndtering og gendannelse.

Konklusion

Denne omfattende guide gav en detaljeret introduktion til C#-programmering, der dækkede sprogets grundlæggende og væsentlige begreber. Starter med at sætte udviklingsmiljøet op og skrive et "Hej, verden!" programmet udforskede vi datatyper, variabler, kontrolflowstrukturer som if-sætninger og sløjfer og oprettelsen af funktioner. Vi dykkede ned i mere avancerede emner såsom klasser, objekter, arv, indkapsling, polymorfi samt undtagelseshåndtering. Derudover diskuterede vi brugen af arrays og samlinger til at administrere flere værdier. Med denne viden har du nu et solidt fundament i C#-programmering, hvilket giver dig mulighed for at udvikle en bred vifte af applikationer, fra konsolapplikationer til web- og mobilapplikationer. Husk at fortsætte med at øve og udforske det enorme C#-økosystem for at forbedre dine færdigheder og låse op for uendelige muligheder.

programmering csharp oop udvikling variabler kontrolflow klasser objekter arv indkapsling undtagelseshåndtering arrays samlinger funktioner