ZennDev1337/Wiki
1
0
Fork 0
Code Issues Pull requests Projects 1 Releases Packages Wiki Activity

first commit

Browse source
This commit is contained in:
ZennDev1337 2023-12-20 16:30:40 +01:00
commit d47f1dc602
9 changed files with 1247 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

89
Code/CSharp/Basics.md Normal file
View file

@ -0,0 +1,89 @@
# 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;
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.
}
```

255
Code/CSharp/Interface.md Normal file
View file

@ -0,0 +1,255 @@
# 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.
}
```

89
Code/CSharp/Vererbung-Heredity.md Normal file
View file

@ -0,0 +1,89 @@
# Heredity
Die Vererbung ist wohl das mächtigste Tool für C#.\
Es bedeutet, dass man von Mutter klassen zu Tochter klassen alle Eigenschaften weitergeben kann.
In meinem Beispiel, werde ich dass aufzeigen anhand eines Zoo's mit Tieren und den Kategorien welche es da gibt.
## Mutter Klasse
Wir haben ein Tier, dieses kann ein Geräusch machen mit der Methode `MakeNoise()`.\
Wenn ich nun ein Säugetier erstellen will, macht dieses ja ein anderes Geräusch als ein Vogel.
Wichtig ist: Bei einer Mutter klasse schreiben wir immer da das Keyword `virtual` hin, wo wir die Möglichkeit haben wollen, in der Tochter klasse dies zu bearbeiten oder ganz zu verändern.
```
namespace Zoo.Animals
{
public abstract class Animal
{
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: ");
}
}
}
```
Wir lassen jetzt das Säugetier von Animal erben.\
Dies geht, indem wir nach dem Klassennamen die zu erbende Klasse nach einem : einfügen. Hier mit: `Mammal : Animal`
```
namespace Zoo.Animals
{
public abstract class Mammal : Animal
{
}
}
```
Nun können wir einige der Properties und Methoden verändern bzw. überschreiben.\
Wir ändern `foodType` & `habitat` so wie die Methode `MakeNoise()`.\
Mit dem Keyword `override`.
```
namespace Zoo.Animals
{
public abstract class Mammal : Animal
{
public override string foodType => "Mammalfood";
public override string habitat => "Cage";
public override void MakeNoise()
{
Debug.WriteLine($"{this.name} makes a Noise: Mammal Noise");
}
}
}
```
Wenn wir uns den Code der Methode `MakeNoise()` von Animal anschauen sehen wir, dass wir ein `Debug.Write` verwenden dies könnten wir weiterverwenden, mit `this.base()`
```
namespace Zoo.Animals
{
public abstract class Mammal : Animal
{
public override string foodType => "Mammalfood";
public override string habitat => "Cage";
public override void MakeNoise()
{
this.MakeNoise();
Debug.WriteLine("Mammal Noise");
}
}
}
```
Mit diesem Code wird erst die Methode `MakeNoise()` von Animal aufgerufen. Was dazu führt, dass in die Konsole `{this.name} makes a Noise: ` geschriben wird.\
Im nächsten Schritt wird mit `Debug.WriteLine("Mamal Noise")` Mamal Noise auf der gleichen Zeile ausgegeben und eine neue Zeile begonnen.
Die Ausgabe wird `{this.name} makes a Noise: Mamal Noise` sein.
Es sind 2 Wege zum gleichen Ziel.