# Lathund: koda i konsolen

<details>

<summary>Problem med svenska (eller t.ex. japanska) tecken i konsolen?</summary>

Ibland kan det vara problem med tecken i konsolen; de kanske skrivs ut som ? eller �. Om det är problem skriv följande kod i början av programmet.

```csharp
Console.InputEncoding = System.Text.Encoding.Unicode;
Console.OutputEncoding = System.Text.Encoding.Unicode;
```

</details>

## Kommentarer

Genom att skriva // framför något så gör man så det inte tolkas som kod utan som en kommentar.

```csharp
// Det här är en kommentar.
// Console.WriteLine("Det här är också en kommentar; en kod som inte körs");
```

## Variabler

Variabler lagrar information – allt man vill kunna komma ihåg i programmet lagras i variabler.

Varje variabel har en [**datatyp**](https://csharp.progdocs.se/grundlaggande/datatyper). När man skapar en variabel så anger man vilken sorts information som ska lagras i den.

```csharp
// int är datatypen, hp namnet på variabeln
int hp = 100;          // int = heltal
string name = "Micke"; // string = text
float money = 4.5f     // float = decimaltal
```

Man kan ändra på en variabels värde i efterhand. = funkar alltid, så länge variabeln är på vänster sida och det du vill ändra dess värde till är på höger.

```csharp
name = "Martin"; // Ändra name till 'Martin'
hp = hp + 10; // Öka hp med 10
hp += 5; // Öka hp med 5
hp++ // Öka hp med 1
hp-- // Minska hp med 1
```

## Läsa in data

### Läsa in text med [WriteLine](https://csharp.progdocs.se/grundlaggande/konsollen-console#console.writeline), [ReadLine](https://csharp.progdocs.se/grundlaggande/konsollen-console#console.readline)

Används för att skriva ut saker till användaren eller läsa in saker.

```csharp
Console.Write("Vad heter du? ");
string name = Console.ReadLine();
Console.WriteLine($"Hej {name}! Kul att du också är här :-)");  // Skriver ut 'Hej ...!  Kul att du också är här :-)
```

### Läsa in tal med [TryParse](https://csharp.progdocs.se/grundlaggande/typkonvertering#int.tryparse)

Tryparse gör att man kan göra om en string till en int.

```csharp
string pointsText = Console.ReadLine();
int points = 0;
bool success = int.TryParse(pointsText, out points);
```

## Villkorssatser

### [If-else](https://csharp.progdocs.se/grundlaggande/if-satser)

If gör att man kan ha kod som bara körs om ett villkor stämmer (är *true*).

```csharp
string name = Console.ReadLine();
if (name == "Micke")
{
  Console.WriteLine("Välkommen!");
}
```

I exemplet nedan används också else if och else för att skapa en kedja.

```csharp
string name = Console.ReadLine();

if (name == "Micke") // Först kollas name mot 'Micke'
{
  Console.WriteLine("Välkommen!");
}
else if (name == "Martin")  // Om det inte är 'Micke' kollas namn mot 'Martin'
{
  Console.WriteLine("Hej!");
}
else  // och om det varken är 'Micke' eller 'Martin' körs den här koden
{
  Console.WriteLine("Dig känner jag inte, hejdå!");
}
```

### [Villkor](https://csharp.progdocs.se/grundlaggande/boolska-satser) och [jämförelser](https://csharp.progdocs.se/grundlaggande/operatorer#boolska)

Mellan parenteserna i if-satser och loopar skriver man någon form av jämförelse som blir sann eller falsk. Vanliga jämförelser kan vara:

* `==` "Är exakt lika med"
* `!=` "Är inte lika med"
* `>` "Är större än"
* `<` "Är mindre än"
* `<=` "Är större än eller lika med"
* `>=` "Är mindre än eller lika med

```csharp
int hp = 50;
if (hp < 10)
{
  Console.WriteLine("Skadad!");
}

if (hp > 100)
{
  Console.WriteLine("Overcharge!");
}
```

Man kombinerar ofta jämförelser med varandra, genom att använda && (och), || (eller).

```csharp
if (name == "Mikael" && pass == "password" && attempts < 4)
{
  Console.WriteLine("Välkommen!");
}
```

## [Slump](https://csharp.progdocs.se/grundlaggande/slump)

```csharp
// randomNumber blir ett tal som kan vara minst 0, max 99
int randomNumber = Random.Shared.Next(100);
// Talet kan vara minst 4, max 7
int otherNumber = Random.Shared.Next(4,7);
```

## Upprepa med loopar

### [While-loop](https://csharp.progdocs.se/grundlaggande/loopar#while-loop)

En loop när man inte vet hur många gånger koden skall köras.

```csharp
while (true) // Loop som körs för evigt
{
  string password = Console.ReadLine();
  if (password == "12345")
  {
    break; // Avbryter loopen
  }
}
```

En while-loop funkar exakt som en if-sats, utom att när koden som står under den är klar, så gör den jämförelsen igen – och om den fortfarande är *true* så kör den en gång till.

```csharp
string name = Console.ReadLine();
while (name != "Micke")
{
  name = Console.ReadLine()
}
```

**Observera** att exemplet ovan kan användas för alla möjliga jämförelser – så fort du vill begränsa användarens input, göra så att hen inte får gå vidare förrän hen skrivit in något som är "rätt sorts input", så kan du använda en while.

### [For-loop](https://csharp.progdocs.se/grundlaggande/loopar#for-loop)

En sorts loop som är väldigt bra när man vill köra en loop ett specifikt antal gånger. For-loopar funkar egentligen som while-loopar, men inkluderar en *räknare*.

```csharp
// Räknaren heter i, börjar på 0 och ökar med 1 varje gång loopen körts.
for (int i = 0; i < 10; i++) 
{
  // Det som står här inne kommer köras 10 gånger
  // Första gången loopen körs, har i värde 0
  // Andra gången har i värde 1
  // Tredje gången har i värde 2...
}
```

## [List](https://csharp.progdocs.se/grundlaggande/listor-och-arrayer#list)

Med listor kan man ha flera värden i samma variabel.

```csharp
List<int> numbers = [2, 45, 13, 200];
List<string> names = ["Micke", "Martin"];
```

Man kan läsa av och ändra på vad som finns på platser i en lista genom *indexering*. Varje plats i listan är numrerad från 0 och uppåt.

```csharp
List<string> names = ["Micke", "Martin"];
Console.WriteLine(names[0]); // Skriver ut 'Micke'
Console.WriteLine(names[1]); // Skriver ut 'Martin'
names[0] = "Mohammad"; // Byter ut 'Micke' mot 'Mohammad'
Console.WriteLine(names[0]); // Skriver ut 'Mohammad'
```

Man kan också kolla hur lång en lista är med Count, lägga till saker med Add och ta bort med Remove eller RemoveAt.

```csharp
List<string> names = ["Micke", "Martin"];
Console.WriteLine(names.Count); // Skriver ut '2'

names.Add("Jenny"); // Lägg till Jenny, som får index 2
names.Remove("Martin"); // Ta bort Martin, så att Jenny får index 1
names.RemoveAt(0); // Ta bort namnet med index 0

if (names.Contains("Jenny")) // Kolla om Jenny finns i listan
{
  Console.WriteLine("Jenny är med!");
}
```

Med en [foreach-loop](https://csharp.progdocs.se/grundlaggande/loopar#foreach-loop) kan man gå igenom listan och läsa av varje sak i den i tur och ordning.

```csharp
foreach (string name in names) // Loopa igenom listan
{
  Console.WriteLine(name);
}
```

## [Metoder](https://csharp.progdocs.se/grundlaggande/metoder#enkel-metod)

En metod är en bit återanvändbar kod, som kan anropas från andra delar av koden. Metoder som är statiska är helt separata från resten av koden – de kan inte komma åt variabler som inte är deras egna. Metoder är överlag lite som Las Vegas: Det som händer i metoden stannar i metoden. Om man inte specifikt säger något annat.

```csharp
static void CountDown()
{
  for (int i=10; i>0; i--)
  {
    Console.WriteLine(i + "...");
  }
}
```

### Parametrar

För att få *in* data i en metod används parametrar. Det gör man generellt när man vill att en och samma metod ska kunna göra delvis olika saker beroende på vilken data den ges.

```csharp
static void CountDownFrom(int startValue)
{
  for (int i=startValue; i>0; i--)
  {
    Console.WriteLine(i + "...");
  }
}

CountDownFrom(100); // 100 stoppas in i parametervariabeln startValue
CountDownFrom(10);
```

### Returnering

Om man vill ta med sig något från inifrån en metod så använder man *return*.

```csharp
// 'string' betyder att vi lovar att metoden returnerar en string
//        ↓
static string GetName() 
{
  string name = "";
  while (name.Length == 0)
  {
    Console.WriteLine("Vad heter du?");
    name = Console.ReadLine();
  }
  
  return name; // 'return' avslutar metoden och skickar tillbaka innehållet i 'name'
}

string heroName = GetName();
string enemyName = GetName();
```

## Klasser

Varje klass läggs normalt i en egen fil.

{% code title="Enemy.cs" %}

```csharp
class Enemy
{
  public string Name;
}
```

{% endcode %}