Skip to Content
Semester 7Anwendungsentwicklung in C# (CSH)Grundlagen und Syntax

Grundlagen und Syntax

Instanzmethode vs. Statische Methode

Instanzmethode:

Gehören zu einem konkreten Objekt (Instanz) und verändern nur den Zustand dieses Objekts. Hat Zugriff auf die Instanzvariablen, da es this verwenden kann.

Statische Methode:

Sind in einer Klasse definiert, aber nicht an eine Instanz gebunden. Werden über den Klassennamen aufgerufen Klasse.Methode().

Wo beginnt ein C# Programm

Antwort:

Jedes C#-Programm beginnt standardmäßig in der Main-Methode. Das ist der Einstiegspunkt (Entry Point).

class Program {
    static void Main(string[] args) {
        // Hier startet das Programm
    }
}

Hinweis: Seit C# 9 gibt es auch “Top-Level Statements”, bei denen man die Main-Methode weglassen kann, aber im Hintergrund wird sie trotzdem generiert.

Grundaufbau eines Programm

Namespaces

Namespaces sind logische Gruppen von Klassen. Sie helfen, die Klassenstruktur zu organisieren und Konflikte zu vermeiden. Dadurch können zwei Bibliotheken mit demselben Klassennamen ohne Konflikte funktionieren.

namespace MyNamespace {
    public class MyClass {
        // ...
    }
}

An einem anderen Standort kann man auf die Klassen in einem Namespace zugreifen

using MyNamespace;
 
var myClass = new MyClass();
 
// Ohne using
var myClass = new MyNamespace.MyClass();

Using

using ist ein Schlüsselwort, das verwendet wird, um einen Namespace zu importieren. Dadurch kann man auf die Klassen in einem Namespace zugreifen, ohne den Namespace explizit zu benennen.

using System;
 
Console.WriteLine("Hello, World!");
 
// Ohne using
System.Console.WriteLine("Hello, World!");

using kann auch als Ressource verwendet werden, um eine Datei zu öffnen und zu schließen.

 
using var file = new FileStream("example.txt", FileMode.Open);
// Datei wird gelesen und am Ende automatisch geschlossen
 
using (var file = new FileStream("example.txt", FileMode.Open)) {
    // ...
}

Klassen

Klassen sind Baupläne für Objekte. Sie definieren die Eigenschaften und Verhalten von Objekten.

namespace MyApp;
 
public class MyClass {
 
    // Felder
    private int _age;
 
    // Properties
    public int MyProperty { get; set; }
    public string Name { get;}
    public int Age => _age;
 
    // Konstruktor
    public MyClass(int age) {
        _age = age;
    }
 
    // Methoden
    public void MyMethod(int age) {
        _age++;
    }
 
    // Finalizer
    ~MyClass() {
        // ...
    }
 
    // Destructor
    public void Dispose() {
}

Charakteristiken einer statischen Klasse

Statische Klassen lassen sich nicht instanzieren (kein new möglich) und sind automatisch sealed (nicht vererbbar). Nur statische Member (Felder, Eigenschaften, Methoden) können in einer statischen Klasse definiert werden.

Man verwendet sie für Hilfsklassen wie System.Math.

public static class Rechner {
    public static double Pi = 3.14159;
    public static double Quadrat(double x) {
        return x * x;
    }
}
 
// Fehler:
var rechner = new Rechner();
 
double quadrat = Rechner.Quadrat(2);
double pi = Rechner.Pi;

Wie vereinbart man eine Variable, und was ist der Unterschied zu einem Field?

Variablen werden mit einem Datentyp, Namen und Wert deklariert. var kann verwendet werden, um den Datentyp automatisch zu ermitteln.

Ein Field ist eine Variable innerhalb einer Klasse, das einen Wert enthält.

namespace MyApp;
 
public class MyClass {
    private int _age; // Field
 
    public void SetAge(int age) {
        int localAge = age; // Variable
        _age = localAge;
    }
}

Statische und dynamische Methoden

Statische Methoden:

Gehören zu einer Klasse und können über Klasse.Methode() aufgerufen werden. Sie haben keinen Zugriff auf this.

Dynamische Methoden:

Gehören zu einem Objekt und kann über object.Methode() aufgerufen werden. Sie haben Zugriff aufdie Daten der konkreten Instanz.

Kommentare

Kommentare helfen dabei zu erklären, warum der Code das macht und nicht was er macht.

Einzele Kommentare:

// Einzeiler Kommentar

Mehrzeiler Kommentar:

/*
Mehrzeiler Kommentar
*/

XML Kommentare:

XML Kommentare werden oft verwendet um Dokumentation zu erstellen.

/// <summary>
/// Dies ist ein XML Kommentar
/// </summary>
/// <param name="name">Der Name des Kommentars</param>
/// <returns>Der Rückgabewert des Kommentars</returns>

Wann sind Kommentare sinnvoll?

Kommentare sind sinnvoll, wenn man folgende Dinge beschreiben will:

  • Lizenzen / Rechtlichte Hinweise: Aus rechtlichen Gründen können bestimmte Kommentare erforderlich sein.
  • Erklärung von Entscheidungen: Kommentare können dabei erklären, warum eine bestimmte Entscheidung getroffen wurde.
  • Warnungen vor schwer erkennbaren Konsequenzen: Kommentare können dabei warnen, was passiert wenn eine bestimmte Aktion ausgeführt wird.
  • TODOs: Kommentare können dabei markieren, was noch zu tun ist.

Dreifachoperator: Wann verwendet man den und wofür ist der sinnvoll?

Dreifachoperatoren werden verwendet um kurz eine Bedingung zu prüfen und einen Wert zurückzugeben. Sie ersetzen einen kurzen if-else Block mit einer Expression.

var role = isAdmin ? "Admin" : "User";

Was sind gute Variablenamen?

Variablennamen sollten klar, präzise und erklären was sie beinhalten. Sie sollten beschreibend sein und nicht abkürzend besonderFunktion anstatt bf. Lokale Variablen nutzen camelCase, während Klassenmember PascalCase verwenden.

Konvertierungsregeln

  • Wenn nichts verloren geht, kann es implizit erfolgen.
  • Sonst Casten explizit

TryParse kennen

TryParse wird verwendet um Text sicher in einen Datentyp zu konvertieren. Der Rückgabewert ist ein Bool Wert, der angibt ob die Konvertierung erfolgreich war. Der Ausgabeparameter ist der konvertierte Wert.

if(int.TryParse(text, out int number)) {
    Console.WriteLine(number);
} else {
    Console.WriteLine("Invalid input");
}

Neben int.TryParse gibt es auch double.TryParse, float.TryParse, bool.TryParse und DateTime.TryParse.

out wird verwendet um einen Wert aus einer Methode zurückzugeben. TryParse gibt hier nur ein true/false zurück, der Wert wird über den out Parameter zurückgegeben. Wenn das Ergebnis true ist, wird der Wert in der Variable gespeichert.

Nullable Types

Nullable Types sind Typen, die zusätzlich zu ihrem eigenen Wert auch den Wert null enthalten können. Von int kann man beispielsweise int? machen, um auch den Wert null zu erlauben. Aber von int? kann man nicht int machen, sondern nur mit einem expliziten Cast.

int? number = null;
int number2 = (int)number;

TryCatch

try {
    // Code der geprüft werden soll
} catch (Exception e) {
    // Code der ausgeführt wird, wenn ein Fehler auftritt
} finally {
    // Code der ausgeführt wird, unabhängig von ob ein Fehler auftritt oder nicht
}

Exception ist die Basisklasse für alle Fehler.

Andere Exceptions:

  • ArgumentNullException - Wenn ein Argument null ist
  • ArgumentOutOfRangeException - Wenn ein Argument außerhalb des gültigen Bereichs ist
  • InvalidOperationException - Wenn eine Operation ungültig ist
  • IOException - Wenn ein Eingabe/Ausgabe Fehler auftritt
  • FormatException - Wenn ein Format Fehler auftritt
  • OverflowException - Wenn ein Überlauf auftritt
  • StackOverflowException - Wenn ein Stack Überlauf auftritt

Fehlertypen

Logische Fehler

Der Code ist kompilierbar, aber führt zu einem Fehler bei der Ausführung. Das kann von falschen Berechnungen bis zu falschen Bedingungen (if(age > 18) statt if(age >= 18)) führen.

Laufzeitfehler

Der Fehler beendet das Programm. Diese können ausgelöst werden durch falsche Eingaben, fehlende Dateien, es wird durch 0 geteilt, etc.

Syntaktische Fehler

Der Code lässt sich nicht kompilieren, da er gegen die Grammatik von C# verstößt.

Mögliche Fehler:

  • Fehlende Klammern (if (x > 0 { ... })
  • Fehlende Semikolons (int x = 3)
  • Falsches Schlüsselwort (pubik class ...)
Last updated on
ÜbersichtObjektorientierung