01 - Objektorienterad programmering (1DV024)

class: center, middle, lnu-background-yellow

### Objektorienterad programmering (1DV024)
        # Operatorer, styrstrukturer, undantag, filer

---

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 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.

---

# Aritmetiska operatorer

- +, -, *, /, %
            - Se upp med heltalsdivision!
                - Om operanderna är heltal trunkeras resultatet.
            - %, modulus operatorn
                - Om q = x / y och r = x % y då är x = q * y + r.
                - Om 5 = 17 / 3 och 2 = 17 % 3 då är 17 = 5 * 3 + 2.
            - Värden med enbart siffror tolkas som heltal av typen int.
            - Värden innehållande decimalpunkt tolkas som flyttal av typen double.
            - Värden som avslutas med d (eller D) tolkas som flyttal av typen double.
            - Värden kan omvandlas explicit.

```
        int result = 42 + 3 * 9753 / 136721;  // 42!

double celsius = (42 - 32) * 5 / 9d; // 42°F ≈ 5,6°C

int celsiusTruncated = (int)celsius; // 5
        int celsiusRounded = (int)Math.Round(celsius, 0, MidpointRounding.AwayFromZero); // 6
        ```

- +=, -=, *=, /=, %=
            - Sammansatta tilldelningsoperatorer.
        - ++, --
            - [Öknings-](https://msdn.microsoft.com/en-us/library/36x43w8w.aspx) och [minskningsoperatorer](https://msdn.microsoft.com/en-us/library/wc3z3k8c.aspx).

---

# Booleska uttryck

- Booleska uttryck har alltid ett resultat som är <code class="remark-inline-code">true</code> eller <code class="remark-inline-code">false</code>.

- <code class="remark-inline-code"><</code>, <code class="remark-inline-code">></code>, <code class="remark-inline-code"><=</code>, <code class="remark-inline-code">>=</code>, <code class="remark-inline-code">==</code>, <code class="remark-inline-code">!=</code>
            - Jämförelse operatorer.

- <code class="remark-inline-code">||</code>, <code class="remark-inline-code">&&</code>, <code class="remark-inline-code">!</code>
            - Logiska operatorer.

- <code class="remark-inline-code">?:</code>
            - [Villkorsoperatorn](https://msdn.microsoft.com/en-us/library/ty67wk28.aspx) (ersätter <code class="remark-inline-code">if-else</code>-sats).

```
        int number = int.Parse(Console.ReadLine());
        string result = "Heltalet är ";

result += number < 0 ? "negativt." : "positivt.";
        ```

- <code class="remark-inline-code">??</code>
            - ["_null-coalescing_"-operatorn](https://msdn.microsoft.com/en-us/library/ms173224.aspx) (returnerar vänstra operanden om skilld från null; annars den högra).

- <code class="remark-inline-code">?.</code>
            - ["_null-conditional_"-operatorn](https://msdn.microsoft.com/en-us/library/dn986595.aspx) (undersöker om null innan åtkomst av medlem).

```
        int? secretNumber = GetSecretNumber();  // returnerar null om okänt!

Console.WriteLine($"Det hemliga talet är {secretNumber?.ToString() ?? "okänt"}.");
        ```

---

# Styrstrukturer

- Villkorsuttryck måste __alltid__ vara ett booleskt uttryck.

- Selektioner
            - <code class="remark-inline-code">if</code>-satsen
            - [<code class="remark-inline-code">switch</code>](https://msdn.microsoft.com/en-us/library/06tc147t.aspx)-satsen

```
        int number;

if (int.TryParse(Console.ReadLine(), out number) && number % 2 == 1)
        {
            Console.WriteLine($"Heltalet {number} är udda.");
        }
        ```

- Iterationer
            - <code class="remark-inline-code">while</code>-satsen
            - <code class="remark-inline-code">do while</code>-satsen
            - <code class="remark-inline-code">for</code>-satsen
            - [<code class="remark-inline-code">foreach</code>](https://msdn.microsoft.com/en-us/library/ttw7t8t6.aspx)-satsen

```
        int[] numbers = Enumerable.Range(1, 1000).ToArray();

foreach (int element in numbers)
        {
            Console.WriteLine(element);
        }
        Console.WriteLine(element); // Error CS0103 The name 'element' does not exist in the current context
        ```

???

- break
        - continue
        - switch
            - fall through
            - goto

---

# Felhantering

- En metod kan skicka information om ett fel genom att kasta ett undantag.

```
        static int ReadOddInt()
        {
            int number;

if (!int.TryParse(Console.ReadLine(), out number) || number % 2 != 1)
            {
                throw new InvalidOperationException("Inte ett udda heltal.");
            }

return number;
        }
        ```

- Ett undantag kan fångas och hanteras.

```
        double number;

try
        {
            Console.Write("Ange ett flyttal: ");
            number = double.Parse(Console.ReadLine());
            Console.WriteLine($"Du matade in {number}.");
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        finally
        {
            Console.WriteLine("Ett finally-block exekveras alltid!");
        }
        ```

???
        - short circuit evaluation
        - out
        - finally

---

# Olika hantering beroende av fel

- Det är möjligt att ha flera <code class="remark-inline-code">catch</code>-block i en och samma <code class="remark-inline-code">try-catch</code>-sats.
        - Ordningen är viktig!
        - (Klassen <code class="remark-inline-code">Exception</code> är basklass för alla övriga typer av undantag.)

```
        byte number;

try
        {
            Console.Write("Ange ett tal i det slutna intervallet mellan 0 och 255: "); // IOExeption
            number = byte.Parse(Console.ReadLine());  // ArgumentNullExecption, FormatException, OverflowException
                                                      // IOExeption, OutOfMemoryException, ArgumentOutOfRangeException
            Console.WriteLine($"Du matade in talet {number}."); // IOExeption
        }
        catch (OverflowException)
        {
            Console.WriteLine("Talet är antingen för stort eller för litet.");
        }
        catch (FormatException)
        {
            Console.WriteLine("Det inmatade är inte i ett korrekt format.");
        }
        catch (Exception ex) // Måste vara sist!
        {
            Console.WriteLine(ex.Message);
        }
        ```

---

# Filhantering

- Klassen <code class="remark-inline-code">StreamWriter</code> använder du för att skriva text till en fil.

```
        using (var writer = new StreamWriter(@"MyTextFile.txt"))
        {
            writer.WriteLine("Mats är");
            writer.WriteLine("snäll.");
        }        
        ```

- Klassen <code class="remark-inline-code">StreamReader</code> använder du för att läsa en fil med text.

```
        using (var reader = new StreamReader(@"MyTextFile.txt"))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine(line);
            }
        }
        ```

- <code class="remark-inline-code">using</code> expanderas till en <code class="remark-inline-code">try-finally</code>-sats, där <code class="remark-inline-code">finally</code>-blocket säkerställer att filen stängs.

```ildasm
        .method private hidebysig static void  Main(string[] args) cil managed
        { // >>> Code left out for brevity! <<<
          .try
          {
          }  // end .try
          finally
          {
            IL_002e:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
          }  // end handler
        } // end of method Program::Main
        ```

---

# Läsa JSON från fil

movies.json
        ```
        [
          "The Shawshank Redemption",
          "The Godfather",
          "The Godfather: Part II",
          "The Dark Knight",
          "Pulp Fiction"
        ]
        ```

- Läser fil till sträng och deserialiserar till en array med strängar.

```
        string json;

using (var reader = new StreamReader("movies.json"))
        {
            json = reader.ReadToEnd();
        }

var movies = JsonConvert.DeserializeObject<string[]>(json);

Console.WriteLine(string.Join(", ", movies));
        ```

- Läser fil till sträng och deserialiserar till ett List-objekt med strängar.

```
        var json = File.ReadAllText("movies.json");
        var movies = JsonConvert.DeserializeObject<List<string>>(json);
        Console.WriteLine(string.Join(", ", movies));
        ```

???
        install-package newtonsoft.json

---

# Deserialisera JSON direkt från fil

- Läser fil och deserialiserar till en array med strängar.

```
        string[] movies;

using (var reader = File.OpenText("movies.json"))
        {
            var serilazier = new JsonSerializer();
            movies = (string[])serilazier.Deserialize(reader, typeof(string[]));
        }

Console.WriteLine(string.Join(", ", movies));
        ```