Skapa terminalprogram

Skapa app

Vi börjar med att skapa vårt första terminalprogram eller konsol-app (console app) som det kallas i C#. Det är en default-app från dotnet, som skriver ut “Hello, World!” i terminalen.

I terminalen

Vi ställer oss i katalogen kmom01/practice och med dotnet skapar vi vårt första terminalprogram som vi kallar FirstApp. Det tar en liten stund. Katalogen FirstApp kallas C#-projekt eller applikation.

dotnet new console -n FirstApp

När vi kör appen så kompileras koden och appen byggs. Det tar en stund att kompilera koden. För att köra appen:

cd FirstApp
dotnet run
# Ger utskriften: Hello, World!

I VS Code

Vi öppnar vårt terminalprogram i VS Code för att titta på koden. Det är här vi uppdaterar vår kod.

När projektet öppnas första gången i VS Code så kan detta dyka upp i nedre högra hörnet: “Required assets to build and debug are missing. Add them?” Välj i så fall: Yes.

Filstruktur i vår app

Så här ser filstrukturen ut i vår app.

Image description — Bild: Filstruktur för FirstApp.

Program.cs vårt huvudprogram (main) som innehåller vår kod. I det här fallet motsvarar koden bara en utskrift. När du startar ditt terminalprogram med “dotnet run” så körs denna kod.
FirstApp.csproj, håller reda på ditt projekt. Den innehåller information om projektets struktur samt vilka filer som ska inkluderas och vilka beroenden projektet har. Filen har samma namn som vårt projekt med “.csproj” på slutet.
obj, är en katalog med temporära filer som innehåller filer som skapas under kompileringen
bin, innehåller binärfiler, det vill säga den slutgiltiga programkoden som gör att ditt terminalprogram kan köras.

Lägg till kod

Titta gärna i dokumentationen för mer detaljer om C#. Här är en C# snabbreferens. Du kan gärna titta i snabbreferensen om kodtips men fortsätt skapa appar i terminalen som vi gjorde ovan.

Övning 1 - skriv ut slumptal mellan 1 och 100

Vi öppnar vårt huvudprogram, “Program.cs”, i VS Code och byter i koden där till följande kod i slutet:

// Övning 1
// Create random class
Random random = new Random();

// Get random value from 1 (1 included) up to 101 (101 not included)
int number1 = random.Next(1, 101);
int number2 = random.Next(1, 101);

// Present the two random values
Console.WriteLine("\nFirst random value: " + number1);
Console.WriteLine("Second random value: " + number2);

Testkör koden med dotnet run.

Övning 2 - lägg till en if-sats

Vi lägger till en if-sats som skriver ut om personen är myndig eller inte utifrån ålder. För att inte vi ska störas av tidigare kod så rensar vi terminalen och ger den en titel “Min första C# app”. Eftersom inmatning via ReadLine() från användaren kan vara tom, så lägger vi till ett defaultvärde som i det här fallet är “1”.

Vi lägger till följande kod i slutet vårt huvudprogram, “Program.cs”:

// Övning 2
// Clean console och sätt titel
Console.Clear();
Console.Title = "Min första C# app";

// Input
Console.WriteLine("\nVilken är din ålder?");
string input = Console.ReadLine() ?? "1"; // input får defaultvärdet "1" om inget matas in
int age = int.Parse(input);

// Check age
string message;
if (age < 18)
{
    message = "Du är inte myndig";
}
else
{
    message = "Grattis - du är myndig";
}

// Present the result
Console.WriteLine("\n" + message);

Testkör koden med dotnet run.

Nu har vi rensat terminalen, så “Hello, world!” och slumptalen syns inte längre. Vi har lagt till en titel på vårt terminalfönster. Så här ser det ut från en Mac:

Testkör programmet igen och ange då en ålder under 18 för att verifiera den delen av if-satsen.

Övning 3 - gör en metod och använd den

Nu ska vi göra en funktion som innehåller vår if-sats för att kunna använda den kodsnutten flera gånger. Metoden ska returnera en sträng. Inmatningen är samma som innan men vi flyttar vår if-sats till en metod. Vi gör också en metod av kommandona till terminalen.

OBS Om du vill ha kvar koden för övning 2 i “Program.cs” så går det bra men eftersom input och age redan är deklarerade då så får du ta bort datatypen framför.

// Övning 3
// Methods
static void GetTerminalReady(string title)
{
    Console.Clear();
    Console.Title = title;
}

static string CheckIfAdult(int age)
{
    if (age < 18)
    {
        return "Du är inte myndig";
    }
    else
    {
        return "Grattis - du är myndig";
    }
}

// Input
GetTerminalReady("Min första C# app");
Console.WriteLine("\nVilken är din ålder?");
string input = Console.ReadLine() ?? "1"; // ta bort string om input redan är deklarerad
int age = int.Parse(input); // ta bort int om age redan är deklarerad

// Call method
string message = CheckIfAdult(age); // ta bort string om message redan är deklarerad

// Present the result
Console.WriteLine("\n" + message);

Resultatet ska bli detsamma som i föregående övning men nu med metoder.

Övning 4 - Interpolerande strängar

Nu fortsätter vi att utforska C# med interpolerande strängar. Vi deklarerar en variabel för namn och en variabel för ålder vilka vi initierar och skriver ut. Därefter anropar vi metoden vi skrev ovan, CheckIfAdult, och skriver ut det i en interpolerande sträng.

// Övning 4
// String interpolation
string firstName = "Murphy";
int noOfPets = 2;
string info = $"Du heter {firstName} och har {noOfPets} husdjur.";
Console.WriteLine("\n" + info);
noOfPets = 4;
Console.WriteLine(info);
Console.WriteLine($"Antalet djur är nu: {noOfPets}");

Om noOfPets ändras efter interpolationen i tilldelningen av info, så påverkas inte innehållet i info utan info har samma innehåll som vid initieringen.

Testkör koden med dotnet run.

Så här ser det ut från en Mac:

Övning 5 - Tuples

I nyare versioner av C# finns tuples. Vi deklarerar en ny variabel infoTuple som är en tuple med en sträng och ett heltal. Vi använder firstName och noOfPets från förra övningen och kopierar deras värden till tupeln och skriver sedan ut tupeln. Om vi vill komma åt första värdet i en tuple så använder vi Item1, för andra värdet Item2 och så vidare. OBS indexeringen börjar på 1 i tuples, till skillnad från index 0 i till exempel strängar, arrayer och listor.

// Övning 5
// Tuples
(string, int) infoTuple = (firstName, noOfPets);
Console.WriteLine($"\n{infoTuple}");
Console.WriteLine($"{infoTuple.Item2}");

Testkör koden med dotnet run.

Så här ser det ut från en Mac:

Övning 6 - Olika typer

I den här övningen ska vi träna på att omvandla mellan olika typer. Försök utföra följande typomvandlingar:

omvandla 123 (int) till en float med implicit casting
omvandla 123.123 (double) till en int med explicit casting
omvandla double 123.123 till en sträng med klassen Convert
omvandla “Hej” till en int med klassen Convert. Testa utan try-catch först.
omvandla “Hej” till ett tal med int.TryParse
omvandla “123” till ett tal med int.TryParse

// Övning 6
// Cast and convert
int intNo = 123;
float floatNo = intNo;
Console.WriteLine($"\n{floatNo}");
Console.WriteLine($"{floatNo:F1}"); // skriv ut med en decimal

double doubleNo = 123.123;
int intNo2 = (int)doubleNo;
Console.WriteLine($"\n{intNo2}");

Console.WriteLine($"\n{Convert.ToString(doubleNo)}");

string hi = "Hej";
try
{
    Console.WriteLine($"\n{Convert.ToInt32(hi)}");
} catch (Exception error)
{
    Console.WriteLine($"\nDet gick inte att konvertera {hi} med klassen Convert och ToInt32.");
    Console.WriteLine(error.Message);
}

int number;
bool success = int.TryParse(hi, out number);
Console.WriteLine($"\n{success} och numret blev {number}");

string strNo = "123";
bool success2 = int.TryParse(strNo, out number);
Console.WriteLine($"\n{success2} och numret blev {number}");

Testkör koden med dotnet run. Testkör gärna efter varje omvandling.

Så här ser det ut när allt är klart:

Formatera koden

Vi kan formatera koden med verktyget dotnet format som formaterar enligt en standarduppsättning. Verktyget hjälper till att standardisera kodstilen och göra den konsekvent. Stå i rotkatalogen till ett C#-projektet och kör kommandot i terminalen:

dotnet format
dotnet format -v d // ger mer info om formateringen

Läs mer om dotnet format.

Debugging

Efter som “C# Dev Kit extension” är installerad, så förenklar det debuggning.

Starta debugger på Mac och Linux

På Mac och Linux fungerar det enligt bilden nedan. Klicka först (1) på “SOLUTION EXPLORER” och därefter (2) så markerar du “FirstApp”. Högerklicka på “FirstApp” och följande meny dyker upp med (3) debug som alternativ längst ner. Starta (4) debuggern genom att välja “Start New Instance”.

Se bild nedan:

Starta debugger på WSL2 (Windows)

Markera (1) “Program.cs” och klicka på “F5”. Funkar inte det så väljer du (2) “Run” i menyn följt av “Start Debugging”.

Kör debuggern

Efter en liten stund så ser det ut så som bilden nedan. För att mata in värden (1) så gör du det längst ner och trycker ENTER när du är klar, precis som i terminalen. Längst upp (2) kan du styra debuggningen.

Så här ser verktygsfältet med debugkommandona ut i VS Code.

Debugkommandona:

Kör/Fortsätt (Continue/Pause); Startar eller fortsätter exekveringen tills nästa breakpoint.
Stega över (Step Over); Kör nästa rad utan att gå in i metod/funktion.
Stega in (Step Into); Går in i nästa metod/funktion.
Stega ut (Step Out); Kör klart aktuell metod och återgår till anropande kod.
Starta om (Restart); Stoppar och startar om debug-sessionen.
Stoppa (Stop); Avslutar debug-sessionen.

Sätt brytpunkter genom att markerar till vänster om radnumret och då blir det en röd punkt där. Jag har markerat rad 97 här och debuggern har stoppat på den raden.

Om du vill läsa mer, se manualen till VS Code Debugging.

Sammanfattning

Toppen, nu har vi lärt oss:

skapa och köra vårt första C#-projekt (applikation, terminalprogram)
lärt oss lite om filstrukturen i projektet
koda in- och utmatning
koda slumptal
koda if-satser
koda metoder
hur vi enkelt kan formatera koden med kommandot “dotnet format”
debugga vår kod