255 lines
5.8 KiB
Markdown
255 lines
5.8 KiB
Markdown
# 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.
|
||
}
|
||
|
||
```
|