00 - Introduktion till C# - Objektorienterad programmering (1DV024)

class: center, middle, lnu-background-yellow

### Objektorienterad programmering (1DV024)
        # Introduktion till C# #

---

class: lnu-background-cc

### Upphovsrätt för detta verk

Detta verk är framtaget av Mats Loock i anslutning till kursen Objektorienterad programmering (1DV024) vid Linnéuniversitetet.

Allt innehåll i detta verk förutom fotografier, ikoner, bild på kurslitteraturen samt Linnéuniversitetets logotyp och symbol,
        är licensierad under en <a rel="license" href="http://creativecommons.org/licenses/by/4.0/">
            <img alt="Creative Commons-licens" style="border-width:0;vertical-align:middle" src="https://i.creativecommons.org/l/by/4.0/80x15.png" />
            Creative Commons Erkännande 4.0 Internationell Licens
        </a>.
        #### Du får använda detta verk så här
        - kopiera hela eller delar av innehållet
        - sprida hela eller delar av innehållet
        - visa hela eller delar av innehållet offentligt och digitalt
        - konvertera innehållet till annat format
        - du får även göra om innehållet

Om du förändrar innehållet så ta inte med fotografier, ikoner, bild på kurslitteraturen samt Linnéuniversitetets logotyp och symbol i din nya version!

Vid all användning måste du ange källan: ”Linnéuniversitetet – Objektorienterad programmering (1DV024)” och
        en länk till https://coursepress.lnu.se/kurs/objektorienterad-programmering och till Creative Common-licensen här ovan.

---

#Om C# #

- Hur uttalas C#?
            - [see sharp]
        - Vad är det för typ av språk?
            - Objektorienterat programspråk.
            - Starkt typat.
            - Baserat på C++, men liknar till stor del Java.
            - Projekt byggs och källkoden komipleras till IL-kod (`dotnet build`), en sorts bytekod, som körs i en virtuell maskin, CoreCLR (Common Language Runtime) (`dotnet run`).
            - Plattformsoberoende (macOS, Windows, Linux x64).
        - Annat värt(?) att veta?
            - Presenterades sommaren 2000.
            - Utvecklat av Microsoft som en del av .NET-plattformen.
                - .NET Core är en implementation av .NET och körs på Windows, macOS och Linux.
            - Standardiserat (ECMA-334)
            - ...

---

##"Hello, World!"

<blockquote>
            <p>“The best way to learn a new programming language is to write code.“</p>
            <footer>
                Essential C# 6.0<br />
                Mark Michaelis
            </footer>
        </blockquote>

Program.cs
        ```
        using System;

namespace Hello
        {
            class Program
            {
                static void Main(string[] args)
                {
                    Console.WriteLine("Hello World!");
                }
            }
        }
        ```
        Skapa, bygg och kör applikationen
        ```sh
        > dotnet new console -o Hello
        > cd Hello
        > dotnet run
        Hello, World!
        ```
        ???

- Känn igen syntaxen från JavaScript.
        - Semikolon, klammerparenteser, känslig för stora och små bokstäver, nyckelord.
        - All kod måste skrivas i klasser och i metoder. 
        - Källkoden måste kompileras, översättas till CIL-kod som sedan kan kompileras och exekveras.
            1. Kompilatorn översätter källkoden till CIL-kod och skapar en assembly, Program.exe.
            2. Vid exekvering av en assembly kompileras koden av en JIT-kompilator som genererar "native"-kod för CPUn.
            3. CPUn exekverar "native"-koden.
        - ILDASM.

---
    
        # Nyckelord och identifierare
    
        - <a href="https://msdn.microsoft.com/en-us/library/x53a06bb.aspx">Nyckelord</a> är fördefinierade, reserverade identifierare som har speciell innebörd för kompilatorn.
            - <span style="font-size:smaller">```abstract```, ```as```, ```base```, ```bool```, ```break```, ```byte```, ```case```, ```catch```, ```char```, ```checked```, ```class```, ```const```, ```continue```, ```decimal```, ```default```, ```delegate```, ```do```, ```double```, ```else```, ```enum```, ```event```, ```explicit```, ```extern```, ```false```, ```finally```, ```fixed```, ```float```, ```for```, ```foreach```, ```goto```, ```if```, ```implicit```, ```in```, ```in``` (generic modifier), ```int```, ```interface```, ```internal```, ```is```, ```lock```, ```long```, ```namespace```, ```new```, ```null```, ```object```, ```operator```, ```out```, ```out``` (generic modifier), ```override```, ```params```, ```private```, ```protected```, ```public```, ```readonly```, ```ref```, ```return```, ```sbyte```, ```sealed```, ```short```, ```sizeof```, ```stackalloc```, ```static```, ```string```, ```struct```, ```switch```, ```this```, ```throw```, ```true```, ```try```, ```typeof```, ```uint```, ```ulong```, ```unchecked```, ```unsafe```, ```ushort```, ```using```, ```virtual```, ```void```, ```volatile```, ```while```</span>
            - <span style="font-size:smaller">```add```, ```alias```, ```ascending```, ```async```, ```await```, ```descending```, ```dynamic```, ```from```, ```get```, ```global```, ```group```, ```into```, ```join```, ```let```, ```orderby```, ```partial``` (type), ```partial``` (method), ```remove```, ```select```, ```set```, ```value```, ```var```, ```where``` (generic type constraint), ```where``` (query clause), ```yield```</span>
        - Du kan inte använda nyckelord som <code>class</code> som identifierare, d.v.s. som namn på t.ex. en variabel eller metod.
            - <del>(Du kan inleda namnet med @. ```@class``` är en giltig identifierare.)</del> <small>Kan dock vara användbart i vissa sammanhang...</small>
        - Två sätt att formatera identifierare:
            - PascalCase - klassnamn, metodnamn
            - camelCase - variabelnamn

---

# Typdeklaration

- All exekveringsbar kod måste vara inuti en typdeklaration, där den vanligaste är en klassdeklaration.
            - En typdeklaration per källkodsfil, som namnges som typen (ex. ```Program.cs```).
            - ```class``` innebär att typdeklarationen är en klassdeklaration.
            - ```Program``` är typens namn.
            - ```{}``` mellan klammerparenteserna skrivs klassens medlemmar, t.ex. metoder.

```
        class Program
        {
            // ...
        }
        ```

- En klassdeklaration innehåller typiskt <a href="https://msdn.microsoft.com/en-us/library/ms173114.aspx">metoder</a>.
            - ```static``` innebär att metoden är <a href="https://msdn.microsoft.com/en-us/library/98f28cdx.aspx">statisk</a> och måste anropas via klassens namn, och inte via en referens till ett objekt.
            - ```void``` innebär att metoden inte returnerar något värde.
            - ```Main``` är metodens namn (speciell innebörd då det är applikationens startpunkt).
            - ```()``` tom parameterlista.
            - ```{}``` mellan klammerparenteserna skrivs metodens kropp.

```
        class Program
        {
            static void Main(string[] args)
            {
                // ...
            }
        }
        ```

???

```
        class Program
        {
            static void Main(string[] args)
            {
                SayHello();
                SayHi();
            }

static void SayHello()
            {
                Console.WriteLine("Hello!");
            }

// Expression Body Definition
            static void SayHi() => Console.WriteLine("Hi!");
        }
        ```

---

# Lokala variabler och  datatyper

- En variabel håller ett värde av en specifik typ.
            - heltal, flyttal, sträng, ...
        - Du måste deklarera en variabel innan den används.
            - Specifiera dess typ.
            - Ge den ett namn (camelCase).
            - (Initiera den med ett värde.)
        - En variabels räckvidd (eng. "_scope_") bestäms av blocket den är deklarerad i.

```
        class Program
        {
            static void Main()
            {
                int meaningOfLife = 42;

System.Console.WriteLine($"Meningen med livet är {meaningOfLife}.")
            }
        }
        ```
        - Inbyggda <a href="https://msdn.microsoft.com/en-us/library/ya5y69ds.aspx">datatyper</a>
            - ```bool```, ```byte```, ```sbyte```, ```char```, ```decimal```, ```double```, ```float```, ```int```, ```uint```, ```long```, ```ulong```, ```object```, ```short```, ```ushort```, ```string```
            - ```int``` är standardtypen för heltal.
            - ```double``` är standardtypen för flyttal.
    
        ---
    
        # Typomvandling
    
        - Implicit (automatisk)

```
        int foo = 42;
        double bar = foo; //  42.0
    
        int qux = "Hej!"; // Error CS0029 Cannot implicitly convert type 'string' to 'int'
    
        bar = 3.14;
        foo = bar; // Error CS0266 Cannot implicitly convert type 'double' to 'int'. An explicit conversion exists (are you missing a cast?)
        ```
        - Explicit (uttrycklig)

```
        double bar = 2.72;
        int foo = (int)bar; // 2
    
        int qux = (int)"273.15"; // Error CS0030 Cannot convert type 'string' to 'int'

```
    
        - Tolka ett värde till ett annat

```
        int foo;
        if (int.TryParse("42", out foo))
        {
            Console.WriteLine(foo);
        }
    
        double bar;
        bar = double.Parse("273.15");
        bar = Convert.ToDouble("273.15");
        ```
        
        ???
    
        Eftersom C# är starkt typat kan inte en variabel deklareras om eller användas till att lagra värden av annan typ
        om inte värdet kan omvandlas till vairabelns typ.
        
        ---
    
        # Arrayer
    
        - Iterera en array

```
        int[] values = { 1, 2, 3, 4, 5 };

for (int i = 0; i < values.Length; i++)
        {
            values[i] += 3;
            Console.WriteLine(values[i]);
        }

foreach (int value in values)
        {
            value += 3; // Error CS1656 Cannot assign to 'value' because it is a 'foreach iteration variable'
            Console.WriteLine(value);
        }
        ```
        
        - Filtrera en array med metodbaserad fråga

```
        int[] values = { 1, 2, 3, 4, 5 };

int[] filtered = values
            .Where(x => x % 2 != 0)
            .ToArray();
        
        Console.WriteLine(string.Join(", ", filtered)); // 1, 3, 5
        ```

---
    
        # Anonyma typer
        
        - Anonyma typer kan användas för att kapsla in "read-only" egenskaper utan att du behöver definiera en typ först.
    
        ```
        var person = new { Name = "Ellen Nu", Age = 6 };

Console.WriteLine($"{person.Name} är {person.Age} år.");

person.Age = 42;  // Error CS0200 Property or indexer '<anonymous type string Name, int Age>.Age' cannot be assigned to --it is read only
    
        person = "Nisse"; // Error CS0029 Cannot implicitly convert type 'string' to '<anonymous type string Name, int Age>'

```
        
        - Typen ```dynamic``` används som returtyp då en metod returnerar ett objekt av anonym typ.

```
        static void Main(string[] args)
        {
            var person = GetPerson();

Console.WriteLine($"{person.Name} är {person.Age} år.");
        }

static dynamic GetPerson()
        {
            return new { Name = "Ellen Nu", Age = 6 };
        }
        ```