Wiki/Code/CSharp/Interface.md

# C# basics

## Dokumentation

```
/// <summary>
/// Was Macht diese Klasse / Methode / constante
///
/// Unten kommt immer der Name des Developers welcher diese class programmiert hat
/// </summary>
/// <param name="NameDesParameters"></param>
/// <returns>Was wird mit return zurückgegeben</returns>

```

if (Expression) Genau so auch bei While und for etc. { }

## Namespaceaufbau

```
    1           2
namespace NameDesNamespaces
{
    1: Das ist immer gleich. einfach namespace
    2: das ist der name des namespace dieser wird eigentlich durch die ordnerstrucktur erstellt
}

```

## Classaufbau

```
    1               2           3       4
public/privat partial/nichts class NameDerKlasse
{
        1: Ist die class nur für diesen Namespace gedacht oder auch für auserhalb
        2: Wenn partial geschrieben wird kann innerhalb des selben Namespace mehr zu der classe geaddet werden
        wird eigentlich nur in grossen projeckten verwendet.
        3: das keyword class ist immer gleich.
        4: Der Klassen name dieser wird gross geschrieben wenn es eine public class sein soll.
}

```

## variablen einer class

```
    1               2           3           4
public/privat string/int VariablenName { get; set; }
    1: Ist die variable nur für diesen Namespace gedacht oder auch für auserhalb
    2: Type der variable.
    3: Name der variable wenn gross dann public sonst klein für privat.

```

## Constructor einer class

```
public class Person
{
private string last;
private string first;
    1       2                   3
public Person(string lastName, string firstName)
{
    last = lastName;Interface
=========

Ein Interface kann man sich vorstellen, wie ein Bauplan. Dieser wird meistens einer Mutterklasse vererbt.\
Es gibt diverse Gründe warum man ein Interface benutzt.

-   Man kann ein Interface als Parameter Type einbauen.
-   Man hat eine Verpflichtung alle Eigenschaften einzubauen in eine Klasse.

Schauen wir uns doch einmal an wie ein Interface aussehen kann.\
In diesem Beispiel gehen wir von einem Zoo mit Tieren aus und die Tiere haben dann Tochter Klassen welche die Gattung darstellen.

Interface erstellen
-------------------

Ein Interface wird mit dem Keyword interface erstellt und hat immer ein grosses I vor dem Namen. 

```

namespace Zoo.Interfaces
{
interface IAnimal
{

    }

}

```

Das Interface wurde innerhalb des Interfaces Unterverzeichnis erstellt.

Wir bauen jetzt quasi einen Bauplan für die Animal Klasse.

Properties einbauen
-------------------

Im nächsten Schritt fügen wir die angeforderten Properties hinzu.

Beachte, dadurch das nicht jedes Prop ein set hat, kann dies später nicht geändert werden.

```

namespace Zoo.Interfaces
{
interface IAnimal
{
string name { get; set; }
string foodType { get; }
string habitat { get; }
}
}

```

Wie du sehen kannst ist es nicht notwendig, das Keyword virtual zu verwenden. Es handelt sich ja auch nicht um eine Klasse sondern um ein Interface.

Methoden einbauen
-----------------

Fügen wir doch jetzt noch einige Methoden ein.

```

namespace Zoo.Interfaces
{
interface IAnimal
{
string name { get; set; }
string foodType { get; }
string habitat { get; }
void MakeNoise();
void Eat();
void Move();
Image GetImage();
string GetARandomName();
}
}

```

Wie du sehen kannst, haben die Methoden keine Funktionalität eingebaut. Wir geben lediglich an welchen Rückgabe Wert und welche Parameter verwendet werden müssen.

Klasse mit Interface
--------------------

Jetzt können wir eine neue Klasse hinzufügen welche das Interface beinhaltet. Es wird gleich eingebunden wie eine Vererbung. Animal : IAnimal

Ignoriere erstmal das Keyword abstract. [Du findest hier mehr dazu.](/Code/CSharp/Keyword/abstract)

```

namespace Zoo.Animals
{
public abstract class Animal : IAnimal
{

    }

}

```

Der Code wird so nicht kompilierbar sein. Das Interface zwingt dich dazu die Properties und Methoden einzubauen.

Fangen wir mit den Properties an.

```

namespace Zoo.Animals
{
public abstract class Animal : IAnimal
{
public virtual string name { get; set; } = "animal";
public virtual string foodType { get; } = "Animalfood";
public virtual string habitat { get; } = "Cage";
}
}

```

Zu beachten ist, dass die Props genau so eingebunden werden, wie im Bauplan beschrieben. Achte dabei auf die get und set Keywords.

Jetzt fügen wir alle Methoden ein.

```

namespace Zoo.Animals
{
public abstract class Animal : IAnimal
{
public virtual string name { get; set; } = "animal";
public virtual string foodType { get; } = "Animalfood";
public virtual string habitat { get; } = "Cage";

        public virtual void MakeNoise()
        {
            Debug.Write($"{this.name} makes a Noise:");
        }

        public void Eat()
        {
            Debug.WriteLine($"The {this.GetType().Name} Named {this.name} Eats: {this.foodType}.");
        }

        public virtual void Move()
        {
            Debug.WriteLine($"The {this.GetType().Name} Moves around.");
        }

        public virtual Image GetImage()
        {
            return AnimalsRes.Lion;
        }

        public string GetARandomName()
        {
    		// Code für einen random Namen.
    		return "randomName"
        }
    }

}

```

Jetzt sollte der Code Kompilierbar sein.
    first = firstName;
}
1: public/privat um es öffentlich zu machen
2: Name der class ist immer gleich wie vom costructor
3: alle parameter welche von anfang an initalisiert werden sollen.
}

```

## Funktionsaufbau

```
    1               2               3         4         5
public/privat static/nichts void/string/int Name(string/int Args)
{
    1: Ist die funktion nur für diesen Namespace gedacht oder auch für auserhalb
    2: muss diese funktion mit new initialisiert werden oder nicht
    3: was wird aus der funktion returnt
    4: Der Name der funktion klein bei privaten gross bei public
    5: Die Args weilche Mitgegeben werden. immer mit dem type im vorfeld.
}

```