static void Main(string[] args)
{
// In eine Datei Schreiben
// Beschreibung Schiff
Schiff schiff = new Schiff("Dampfer", 1000000, 86478229, 30500);
PKW pkw = new PKW("Alfa Romeo", 200, 600000, 4);
schiff.Belade(pkw);
// eine Json String erstellen
string jsonString = JsonConvert.SerializeObject(schiff);
// in Datei schreiben
StreamWriter streamWriter = new StreamWriter("Transportmittel.json");
// Datei wird in Json String gewandelt
streamWriter.Write(jsonString);
//schliessen
streamWriter.Close();
// In Datei lesen
// Wird in Jason Datei gelesen
StreamReader streamReader = new StreamReader("Transportmittel.json");
// Lesen aus einer Datei
var objekt = JsonConvert.DeserializeObject <Transport>(streamReader.ReadToEnd());
// schliessen
streamReader.Close();
//
Console.WriteLine($"object is Transport: {objekt is Transport}");
Console.WriteLine($"object: {objekt.BeschreibeMich()}");
objekt.Beschleunige(5, Transport.GeschwEinheit.Kilometer);
// Aufruf für static void Schreiben<T>(T o)
Schreibe <Transport>(objekt);
Console.ReadKey();
}
static void Main(string[] args)
{
Fahrzeug myBMW = new Fahrzeug("BMW", 200, 500000, 100, Fahrzeug.Zustand.Stehend);
Console.WriteLine($"{myBMW.Name}");
int geschw = myBMW.Beschleunige(50);
Console.WriteLine($"{geschw}");
myBMW.Startemotor();
Console.WriteLine($"myBMW.Beschreibemich(): {myBMW.Beschreibemich()}");
myBMW.Stoppemotor();
Console.WriteLine($"myBMW.Beschreibemich(): {myBMW.Beschreibemich()}");
Flugzeug myBoeing = new Flugzeug("Boeing", 1000, 50000, 500, Fahrzeug.Zustand.Fahrend, "USA");
Console.WriteLine($"myBoeing.Beschreibemich(): {myBoeing.Beschreibemich()}");
Schiff Titanik = new Schiff("Titanik", 5000, 100000, 500, Fahrzeug.Zustand.Fahrend, "USA");
Console.WriteLine($"Titanik.Beschreibemich(): {Titanik.Beschreibemich()}");
PKW Opel = new PKW("Opel", 200, 10000, 500, Fahrzeug.Zustand.Fahrend, "Germany");
Console.WriteLine($"Opel.Beschreibemich(): {Opel.Beschreibemich()}");
Flugzeug flieger1 = new Flugzeug("Boeing", 800, 3000000, 500, Fahrzeug.Zustand.Stehend, "USA", 9000, 800);
foreach (var item in flieger1)
{
Console.WriteLine($"item:{item}");
}
string testeArrayÄhnlichkeit = flieger1[2];
Console.WriteLine($"testeArrayÄhnlichkeit:{testeArrayÄhnlichkeit}");
Console.ReadKey();
}
static void Main(string[] args)
{
Transportmittel transportmittel = new Transportmittel("Kutsche", 450.23, 200);
Console.OutputEncoding = Encoding.Unicode;
Console.WriteLine(transportmittel.BeschreibeMich());
PKW pkw = new PKW("Audi", 45.45, 189, 3, 45);
Console.WriteLine(pkw.BeschreibeMich());
Schiff schiff = new Schiff("Titanic", 2000000.00, 150, Schiff.SchiffsTreibstoff.Diesel);
Console.WriteLine(schiff.BeschreibeMich());
Flugzeug flugzeug = new Flugzeug("Boeing", 356433222.22, 500, 7, 20000);
Console.WriteLine(flugzeug.BeschreibeMich());
Console.ReadKey();
}
static void Main(string[] args)
{
MyFahrzeugClass myFahrzeug = new MyFahrzeugClass("Fahrzeug", 100, 1000, 0, "stehend");
myFahrzeug.StarteMotor();
myFahrzeug.Beschleunige(150);
myFahrzeug.Beschleunige(70);
string Satz = myFahrzeug.BeschreibeMich();
Console.WriteLine(Satz);
PKW pkw = new PKW("BMW", 200, 1000000, 0, "stehend", 3);
Console.WriteLine(pkw.BeschreibeMich());
Schiff schiff = new Schiff("Titanic", 30, 1000000000, 0, "stehend", 100);
Console.WriteLine(schiff.BeschreibeMich());
Flugzeug flieger1 = new Flugzeug("Boeing", 1000, 10000000, 0, "stehend", 10000);
// Console.WriteLine(flugzeug.BeschreibeMich());
// Verwendung von IEnumerable
foreach (var item in flieger1)
{
Console.WriteLine($"item: {item}");
}
string testeArrayÄhnlichkeit = flieger1[2];
Console.WriteLine($"testeArrayÄhnlichkeit: {testeArrayÄhnlichkeit}");
Console.ReadKey();
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
//Console.Write("Bitte Fahrzeugname eingeben: ");
//string FName = Console.ReadLine();
//Console.Write("Bitte MaxGeschwindigkeit eingeben: ");
//int FMaxGeschw = int.Parse(Console.ReadLine());
//Console.Write("Bitte Preis eingeben: ");
//int FPreis = int.Parse(Console.ReadLine());
//Console.Write("Bitte aktuelle Geschwindigkeit eingeben: ");
//int FAktuellV = int.Parse(Console.ReadLine());
//Console.Write("Bitte Anfangs-Zustand eingeben (\"Stehend=0, Fahrend=1\"): ");
//int FZustand = int.Parse(Console.ReadLine());
//Fahrzeug fahrzeug = new Fahrzeug(FName, FMaxGeschw, FPreis, FAktuellV, FZustand);
FahrzeugLib fahrzeug = new FahrzeugLib("BMW", 200, 20000);
Flugzeug flugzeug = new Flugzeug("Boeing", 900, 9500000, 3);
PKW pkw = new PKW("Audi", 250, 35000, 5);
Schiff schiff = new Schiff("Titanic", 60, 2500000, true);
foreach (var item in flugzeug)
{
Console.WriteLine($"Eintrag: {item}");
}
Console.WriteLine("\n###########################");
//Console.WriteLine($"Name: {fahrzeug.Name}");
//Console.WriteLine($"Max Geschw: {fahrzeug.MaxGeschwindigkeit}");
//Console.WriteLine($"Preis: {fahrzeug.Preis}");
//Console.WriteLine($"Aktuelle Geschw: {fahrzeug.AktuelleGeschwindigkeit}");
//Console.WriteLine($"Zustand: {fahrzeug.Zustand}");
Console.WriteLine(fahrzeug.BeschreibeMich());
Console.WriteLine("\n###########################");
Console.WriteLine(flugzeug.BeschreibeMich());
Console.WriteLine("\n###########################");
Console.WriteLine(pkw.BeschreibeMich());
Console.WriteLine("\n###########################");
Console.WriteLine(schiff.BeschreibeMich());
Console.WriteLine();
Console.WriteLine("\n###########################");
bool beenden = true;
do
{
Console.WriteLine();
Console.WriteLine("Was soll mit dem Fahrzeug passieren?");
Console.WriteLine("1 = Motor stoppen");
Console.WriteLine("2 = Motor starten");
Console.WriteLine("3 = Beschleunigen");
Console.WriteLine("4 = Habe fertig");
int Antwort = int.Parse(Console.ReadLine());
Console.Clear();
switch (Antwort)
{
case 1:
fahrzeug.StoppeMotor();
Console.WriteLine($"Aktueller Zustand: {fahrzeug.Zustand}");
break;
case 2:
fahrzeug.StarteMotor();
Console.WriteLine($"Aktueller Zustand: {fahrzeug.Zustand}");
break;
case 3:
fahrzeug.Beschleunigen();
Console.WriteLine($"Aktuelle Geschw: {fahrzeug.AktuelleGeschwindigkeit} km/h");
break;
case 4:
beenden = false;
break;
}
} while (beenden);
}
public IActionResult SchiffeInput(Schiff schiff)
{
SchiffRepo.saveSchiff(schiff);
return(RedirectToAction("Index", "Pirat"));
}
static void Main(string[] args)
{
Fahrzeug fahrzeug = new Fahrzeug();
//Beispiel -> Param. Konstruktor
Fahrzeug einFahrzeug = new Fahrzeug("BMW", 2019, 220);
Fahrzeug weiteresFahrzeug = new Fahrzeug("Audi", 2020, 250);
Console.WriteLine($"Marke: {einFahrzeug.Marke} \t mit Baujahr: {einFahrzeug.Baujahr} \t besitzt eine maximale Geschwindigkeit von: {einFahrzeug.MaxGeschwindigkeit}");
Console.WriteLine($"Marke: {weiteresFahrzeug.Marke} \t mit Baujahr: {weiteresFahrzeug.Baujahr} \t besitzt eine maximale Geschwindigkeit von: {weiteresFahrzeug.MaxGeschwindigkeit}");
einFahrzeug.Beschleunige(100);
double mphGeschwindigkeit = Fahrzeug.KmhToMph(einFahrzeug.AktGeschwindigkeit);
Console.WriteLine($"{einFahrzeug.Marke} fährt {einFahrzeug.AktGeschwindigkeit} kmh und umgerechnet {mphGeschwindigkeit} mph");
weiteresFahrzeug.Beschleunige(120);
Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge());
#region Vererbung
PKW pkw = new PKW("BMW", 2019, 220, 4, 4);
PKW pkw1 = new PKW("Ford", 2018, 180, 5, 4);
pkw.Beschleunige(50);
Console.WriteLine($"{pkw.Marke} \t {pkw.Baujahr} \t {pkw.MaxGeschwindigkeit} / {pkw.AktGeschwindigkeit} \t - Anzahl Türen: {pkw.AnzahlTueren} \t Anzahl Räder: {pkw.AnzahlRaeder}");
Yacht yacht = new Yacht("Kühne", 1955, 12, Schiff.Schifftreibstoff.Diesel, 2, 2000000);
Schiff schiff = new Schiff("BlubbBlubbWerft", 1954, 13, Schiff.Schifftreibstoff.Diesel, 2);
#endregion
Yacht yacht1 = new Yacht(schiff, 2000000, true);
Console.ReadKey();
Console.WriteLine("Garagen Beispiel - Polymorphie");
Garage garage = new Garage();
garage.Einparken(pkw);
garage.Einparken(pkw1);
garage.Einparken(schiff);
garage.Einparken(yacht);
foreach (Fahrzeug currentFahrzeug in garage.FahrzeugListe)
{
if (currentFahrzeug is ITuev)
{
ITuev tuev = (ITuev)currentFahrzeug;
if (tuev.MussFahrzeugZumTüv())
{
Console.WriteLine("Muss zum Tuev");
}
}
}
//List<PKW> resultList = garage.ZeigeAllePKWSInGarageAn();
//foreach (PKW currentPKW in resultList)
//{
// Console.WriteLine($"{currentPKW.Marke} \t {currentPKW.Baujahr} \t {currentPKW.MaxGeschwindigkeit} / {currentPKW.AktGeschwindigkeit} \t - Anzahl Türen: {currentPKW.AnzahlTueren} \t Anzahl Räder: {currentPKW.AnzahlRaeder}");
// if (currentPKW is ITuev)
// {
// Console.WriteLine("Hier kann man nach dem Tuevjahr prüfen)");
// if (currentPKW.MussFahrzeugZumTüv())
// Console.WriteLine("Muss zum Tüv");
// }
// }
//Dictionaries arbeitet mit der Klasse KeyValue
Dictionary <string, PKW> autoRegister = new Dictionary <string, PKW>();
Dictionary <Guid, PKW> register2 = new Dictionary <Guid, PKW>();
register2.Add(Guid.NewGuid(), pkw);
register2.Add(Guid.NewGuid(), pkw1);
Guid id = Guid.NewGuid();
autoRegister.Add(id.ToString(), pkw);
autoRegister.Add(Guid.NewGuid().ToString(), pkw1);
//Contain Key
if (autoRegister.ContainsKey(id.ToString()))
{
PKW pkw2 = (PKW)autoRegister[id.ToString()];
}
if (autoRegister.ContainsValue(pkw))
{
}
//KeyValuePair ist für das Lesen von Dictionaries
foreach (KeyValuePair <string, PKW> kvp in autoRegister)
{
Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
Console.ReadKey();
}
static void Main(string[] args)
{
#region Klassen & static
Console.WriteLine("\n ### Klassen & statische Methoden ###");
Class1 class1 = new Class1();
class1.Void();
Class1.StaticVoid();
#endregion
#region Polymorphismus
Console.WriteLine("\n ### Fahrrad & Polymorphismus ###");
Transportmittel fahrrad1 = new Fahrrad("Nextbike", 400.00, 50, 2, 0);
Fahrrad fahrrad2 = new Fahrrad("Lidlbike", 300.00, 45, 2, 0);
Console.WriteLine("\n # Overrides #");
Console.WriteLine(fahrrad1.BeschreibeMich());
Console.WriteLine(fahrrad2.BeschreibeMich());
Console.WriteLine("\n # Overloads #");
fahrrad1.Beschleunigen(5);
fahrrad2.Beschleunigen(5);
#endregion
#region Interfaces
Console.WriteLine("\n # Interfaces & Klassenverschachtelung #");
bool kannBeladenWerden;
kannBeladenWerden = FahrzeugBeladen(new Schiff("Marina", 200000.00, 300, Schiff.SchiffsTreibstoff.Diesel), new PKW("BMW", 20000.00, 250, 5, 4, 2000));
Console.WriteLine($"Können Schiffe PKWs transportieren?: {kannBeladenWerden}");
kannBeladenWerden = FahrzeugBeladen(new Fahrrad("Fordbike", 5000.00, 60, 2, 4444), new PKW("BMW", 20000.00, 250, 5, 4, 2000));
Console.WriteLine($"Können Fahrräder PKWs transportieren?: {kannBeladenWerden}");
#endregion
#region Generics
Console.WriteLine("\n ### Generische Datenstrukturen ###");
Queue <Transportmittel> FahrzeugSchlange = new Queue <Transportmittel>();
Stack <Transportmittel> FahrzeugStack = new Stack <Transportmittel>();
Dictionary <Transportmittel, Transportmittel> FahrzeugDictionary = new Dictionary <Transportmittel, Transportmittel>();
Random random = new Random();
//FahrzeugSchlange und Stack mit 10 zufällig erzeugten Fahrzeugtypen befüllen
for (int i = 0; i < 10; i++)
{
Transportmittel neuesFahrzeug = null;
switch ((Fahrzeugtypen)random.Next(3))
{
case Fahrzeugtypen.Flugzeug: neuesFahrzeug = new Flugzeug("Boing 474", 10000000, 800, 200, 6, 0); break;
case Fahrzeugtypen.PKW: neuesFahrzeug = new PKW("Opel Astra", 20000, 190, 4, 4, 0); break;
case Fahrzeugtypen.Schiff: neuesFahrzeug = new Schiff("Titanik", 100000000, 200, Schiff.SchiffsTreibstoff.Dampf); break;
default: Console.WriteLine("Ungültiger Flugzeugtyp!"); break;
}
if (neuesFahrzeug != null)
{
FahrzeugSchlange.Enqueue(neuesFahrzeug);
FahrzeugStack.Push(neuesFahrzeug);
}
}
//Namen der FahrzeugSchlangen-Elemente ausgeben
foreach (var item in FahrzeugSchlange)
{
Console.WriteLine(item);
}
Console.WriteLine("----------------");
//Namen der FahrzeugStack-Elemente ausgeben
foreach (var item in FahrzeugStack)
{
Console.WriteLine(item);
}
Console.WriteLine("----------------");
for (int i = 0; i < 10; i++)
{
Transportmittel newElementFromQueue = FahrzeugSchlange.Dequeue();
Transportmittel newElementFromStack = FahrzeugStack.Pop();
if (FahrzeugBeladen(newElementFromQueue, newElementFromStack))
{
FahrzeugDictionary.Add(newElementFromQueue, newElementFromStack);
}
}
Console.WriteLine("----------------");
foreach (var item in FahrzeugDictionary)
{
Console.WriteLine($"Beladbares Objekt {item.Key} hat {item.Value} beladen.");
}
#endregion
Console.ReadKey();
}
static void Main(string[] args)
{
#region Polymorphie Beispiel
Flugzeug flugzeug = new Flugzeug("Lufthansa", 2001, 500, "blau", 22, 11000);
Flugzeug flugzeug1 = new Flugzeug("Fogger Doppedecker", 1912, 50, "Rot", 10, 2000);
PKW pkw1 = new PKW("Ferrarie", 1955, 220, "Rot", 2, 4);
PKW pkw2 = new PKW("Trappi", 1955, 80, "Mausegrau", 4, 4);
PKW pkw3 = new PKW("Mercedez", 2020, 260, "Schwarz", 4, 4);
Schiff schiff = new Schiff("Gorck Fork", 1867, 15, Schiff.SchiffsTreibstoff.Wind, 5);
Yacht yacht = new Yacht("Jeanneau", 1999, 18, Schiff.SchiffsTreibstoff.Diesel, 2, true);
Yacht yacht1 = new Yacht("Black Pearl", 1788, 25, Schiff.SchiffsTreibstoff.Wind, 2, false);
Garage dagobertsGarage = new Garage();
dagobertsGarage.ParkeFahrzeugInGarage(flugzeug);
dagobertsGarage.ParkeFahrzeugInGarage(flugzeug1);
dagobertsGarage.ParkeFahrzeugInGarage(pkw1);
dagobertsGarage.ParkeFahrzeugInGarage(pkw2);
dagobertsGarage.ParkeFahrzeugInGarage(pkw3);
dagobertsGarage.ParkeFahrzeugInGarage(schiff);
dagobertsGarage.ParkeFahrzeugInGarage(yacht);
dagobertsGarage.ParkeFahrzeugInGarage(yacht1);
//Zeige mir mein Inventar der Garage an
dagobertsGarage.WelcheFahrzeugeSindInDerGarage();
dagobertsGarage.DoppeleAlleFahrzeugeDieEsKoennen();
dagobertsGarage.WelcheFahrzeugeSindInDerGarage();
Console.ReadKey();
#endregion
#region Hallo Lambda
List <PKW> pkwListe = new List <PKW>();
pkwListe.Add(pkw1);
pkwListe.Add(pkw2);
pkwListe.Add(pkw3);
pkwListe.Add(new PKW("BMW", 2001, 180, "grau", 3, 3));
pkwListe.Add(new PKW("BMW", 2002, 222, "rot", 4, 4));
pkwListe.Add(new PKW("Mercedez", 2019, 300, "blau", 4, 4));
List <PKW> filterdList = pkwListe.Where(n => n.AnzahlTueren == 4).ToList();
//Labda benutzt das Fluent-Pattern: .LambdaMethode(n=>n.IrgendEineProperty==true).LambdaMethode(n=>n.IrgendEineProperty==true);
List <PKW> filterdList1 = pkwListe.Where(n => n.Marke == "Mercedez" && n.MaxGeschwindigkeit > 100).OrderBy(n => n.Baujahr).ToList();
//PKW resultPKW = pkwListe.Single(n => n.ID == "IregendeineGuid");
//if (resultPKW != null)
//{
// if (resultPKW.ID != Guid.Empty)
// {
// }
//}
#endregion
#region Exception Benutzen
//https://docs.microsoft.com/de-de/dotnet/standard/exceptions/best-practices-for-exceptions
try
{
Console.Write("Eingabe>");
string eingabe = Console.ReadLine();
int a = int.Parse(eingabe);
throw new MeineException();
}
catch (FormatException ex)
{
Console.WriteLine("Du musst eine Zahl eingeben.\n" + ex.Message);
throw;
}
catch (OverflowException ex)
{
Console.WriteLine("Deine Zahl ist zu groß/klein.");
}
catch (MeineException ex)
{
throw;
}
catch (Exception ex)
{
Console.WriteLine("Ein unbekannter Fehler ist aufgetreten");
}
finally
{
Console.WriteLine("Wird immer ausgeführt");
}
StreamWriter sw = null;
try
{
sw = new StreamWriter("zahlen.txt");
for (int i = 0; i < 100; i++)
{
sw.WriteLine(i);
if (i < 50)
{
continue;
}
Console.WriteLine(i);
}
}
catch (Exception ex)
{
//Logdatei beschreiben
throw;
}
finally
{
sw.Close();
}
#endregion
}
static void Main(string[] args)
{
#region Modul04 - OOP
////vgl. Fahrzeugpark.Fahrzeug
////Deklaration und Initialisierung von Fahrzeugvariablen.
////Mittels des NEW-Stichworts wird der Konstruktor der Klasse aufgerufen und neue
////Fahrzeugobjekte instanziert.
//Fahrzeug fz1 = new Fahrzeug("Audi", 200);
//Fahrzeug fz2 = new Fahrzeug("BMW", 230);
////Zugriff auf den Getter der Name-Eigenschaft des Fahrzuegs in der Variable fz1
//Console.WriteLine(fz1.Name);
////Zugriff auf den Setter der Name-Eigenschaft des Fahrzuegs in der Variable fz1
//fz1.Name = "VW";
//Console.WriteLine(fz1.Name);
//Console.WriteLine(fz2.Name);
////Zugriff auf die BeschreibeMich()-Methode des Fahrzeugs in der Variable fz1
//Console.WriteLine(fz1.BeschreibeMich());
#endregion
#region Lab04 - Fahrzeug-Klasse
////vgl. Fahrzeugpark.Fahrzeug
////Deklaration einer Fahrzeug-Variablen und Initialisierung über der Fahrzeug-Konstruktor
//Fahrzeug fz1 = new Fahrzeug("BMW", 230, 26999.0);
////Aufruf der BeschreibeMich()-Methode des Fahrzeugs
//Console.WriteLine(fz1.BeschreibeMich());
////Testen verschiedener Member-Methoden des Fahrzeugs
//fz1.Beschleunige(15);
//fz1.StarteMotor();
//fz1.Beschleunige(300);
//fz1.Beschleunige(-45);
//Console.WriteLine(fz1.BeschreibeMich());
#endregion
#region Modul05 - Vererbung
////Erzeugung von PKW-Objekten als vom Fahrzeug erbende Objekte
//PKW pkw1 = new PKW("BMW", 250, 24000.0, 5);
//PKW pkw2 = new PKW("BMW", 250, 24000.0, 5);
//PKW pkw3 = new PKW("BMW", 250, 24000.0, 5);
////Ausgabe der PKW-eigenen (weil mit virtual/override markierten) BeschreibeMich()-Funktion
//Console.WriteLine(pkw1.BeschreibeMich());
////Ausgabe einer statischen Eigenschaft der Fahrzeug-Klasse
//Console.WriteLine(Fahrzeug.AnzahlFahrzeuge);
#endregion
#region Lab05 - Vererbung(2)
////Erzeugung von spezifischen Fahrzeugobjekten
//PKW pkw1 = new PKW("BMW", 250, 26999.99, 5);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000.00, Schiff.Treibstoffart.Dampf);
//Flugzeug flugzeug1 = new Flugzeug("Boing 747", 990, 3000000.00, 9990);
////Aufruf der spezifischen BeschreibeMich()-Funktionen
//Console.WriteLine(pkw1.BeschreibeMich());
//Console.WriteLine(schiff1.BeschreibeMich());
//Console.WriteLine(flugzeug1.BeschreibeMich());
////Ausgabe der statischen Variablen der Fahrzeugklasse
//Console.WriteLine("Es wurden " + Fahrzeug.AnzahlFahrzeuge + " Fahrzeuge erzeugt.");
#endregion
#region Modul06 - Polymorphismus
////Betrachtung eines PKW durch verschiedene Variablen
////In einer PKW-Variablen kann auf alle Eigenschaften/Funktionen der PKW-Klasse,
////darin implementierter Interfaces sowie der vererbenden Klassen zugrgriffen werden.
//PKW pkw1 = new PKW("Audi", 250, 20000.0, 5);
//Console.WriteLine(pkw1.AnzahlTüren);
////In einer Fahrzeug-Variablen kann auf alle Eigenschaften/Funktionen der Fahrzeug-Klasse
////zugegriffen werden, auch, wenn wir immer noch ein PKW-Objekt betrachten (da nicht zwangsläufig
////ein PKW-Objekt in der Variablen steckt.
//Fahrzeug fz1 = pkw1;
//fz1.StarteMotor();
////In einer IBewegbar-Variablen kann auf alle Eigenschaften/Funktionen zugegriffen werden,
////welche durch das Interface definiert werden
//IBewegbar bewegbaresObjekt = pkw1;
//bewegbaresObjekt.Bewegen();
////Einer Methode, welche ein Interfaceobjekt erwartet, kann ein Objekt übergeben werde, welches
////dieses Interface implementiert hat (gilt auch für vererbende Klassen)
//RadAb(bewegbaresObjekt);
#endregion
#region Lab06 - IBeladbar
////Deklarierung und Initialisierung von Variablen
//PKW pkw1 = new PKW("BMW", 230, 23000.0, 5);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 890, 3500000.0, 9980);
//Schiff schiff1 = new Schiff("Titanic", 40, 3000000.0, Schiff.Treibstoffart.Dampf);
////Aufrufe der statischen Funktion zur Beladung zweier Fahrzeuge
//BeladeFahrzeuge(pkw1, flugzeug1);
//BeladeFahrzeuge(flugzeug1, schiff1);
//BeladeFahrzeuge(schiff1, pkw1);
////Ausgabe der BeschreibeMich()-Funktion des Schiffs
//Console.WriteLine(schiff1.BeschreibeMich());
#endregion
#region Modul07 - Generische Listen
////Die List-Klasse ist ein generischer Datentyp (ein Datentyp, welchem bei Initialisierung ein
////anderer Datentyp zugeordnet werden muss), mit dem gleichtypige Objekte in einer Liste dynamisch
////zusammengefasst werden können
//List<Fahrzeug> fzListe = new List<Fahrzeug>();
////Mittels der Count-Eigenschaft der Liste kann die Anzahl der Elemente in der Liste aus
//Console.WriteLine(fzListe.Count);
////Über die Add
//fzListe.Add(new PKW("BMW", 230, 23000.0, 5));
//fzListe.Add(new Flugzeug("Boing", 990, 3000000, 9980));
//Console.WriteLine(fzListe.Count);
//Console.WriteLine(fzListe[1].Name);
//fzListe.RemoveAt(0);
//Console.WriteLine(fzListe.Count);
//Console.WriteLine(fzListe[0].Name);
//PKW pkw1 = new PKW("BMW", 230, 23000.0, 5);
//PKW pkw2 = new PKW("BMW", 230, 23000.0, 5);
//Dictionary<Fahrzeug, string> fzDict = new Dictionary<Fahrzeug, string>();
//fzDict.Add(pkw1, "Hallo");
//fzDict.Add(pkw2, "Ciao");
//if (!fzDict.ContainsKey(pkw1))
// fzDict.Add(pkw1, "Moin");
//Console.WriteLine(fzDict[pkw2]);
#endregion
#region Lab07 - Zufällige Fahrzeuglisten
////Deklaration der benötigten Variablen und und Initialisierung mit Instanzen der benötigten Objekte
//Random generator = new Random();
//Queue<Fahrzeug> fzQueue = new Queue<Fahrzeug>();
//Stack<Fahrzeug> fzStack = new Stack<Fahrzeug>();
//Dictionary<Fahrzeug, Fahrzeug> fzDict = new Dictionary<Fahrzeug, Fahrzeug>();
////Deklaration und Initialisierung einer Variablen zur Bestimmung der Anzahl der Durchläufe
//int AnzahlFZs = 10000;
////Schleife zur zufälligen Befüllung von Queue und Stack
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Würfeln einer zufälligen Zahl im Switch
// switch (generator.Next(1, 4))
// {
// //Erzeugung von Objekten je nach zufälliger Zahl
// case 1:
// fzQueue.Enqueue(new Flugzeug($"Boing_Q{i}", 800, 3600000, 9999));
// fzStack.Push(new Flugzeug($"Boing_S{i}", 800, 3600000, 9999));
// break;
// case 2:
// fzQueue.Enqueue(new Schiff($"Titanic_Q{i}", 40, 3500000, Schiff.Treibstoffart.Dampf));
// fzStack.Push(new Schiff($"Titanic_S{i}", 40, 3500000, Schiff.Treibstoffart.Dampf));
// break;
// case 3:
// fzQueue.Enqueue(PKW.ErzeugeZufälligenPKW($"_Q{i}"));
// fzStack.Push(PKW.ErzeugeZufälligenPKW($"_S{i}"));
// break;
// }
//}
////Schleife zur Prüfung auf das Interface und Befüllung des Dictionaries
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Prüfung, ob das Interface vorhanden ist (mittels Peek(), da die Objekte noch benötigt werden)...
// if (fzQueue.Peek() is IBeladbar)
// {
// //...wenn ja, dann Cast in das Interface und Ausführung der Belade()-Methode (mittels Peek())...
// ((IBeladbar)fzQueue.Peek()).Belade(fzStack.Peek());
// //...sowie Hinzufügen zum Dictionary (mittels Pop()/Dequeue(), um beim nächsten Durchlauf andere Objekte an den Spitzen zu haben)
// fzDict.Add(fzQueue.Dequeue(), fzStack.Pop());
// }
// else
// {
// //... wenn nein, dann Löschung der obersten Objekte (mittels Pop()/Dequeue())
// fzQueue.Dequeue();
// fzStack.Pop();
// }
//}
////Programmpause
//Console.ReadKey();
//Console.WriteLine("\n----------LADELISTE----------");
////Schleife zur Ausgabe des Dictionaries
//foreach (var fz in fzDict)
//{
// Console.WriteLine($"'{fz.Key.Name}' hat '{fz.Value.Name}' geladen.");
//}
#endregion
#region Weitere Themen
//Erstellung von Bsp-Objekten
PKW pkw1 = new PKW("BMW", 230, 3000, 4);
PKW pkw2 = new PKW("BMW", 230, 3000, 4);
PKW pkw3 = new PKW("VW", 230, 3000, 4);
//Benutzung der in der Fahrzeug-Klasse definierten Vergleichsoperatoren
Console.WriteLine(pkw1 == pkw2);
Console.WriteLine(pkw1 == pkw3);
//Verwendung der unten stehenden Erweiterungsmethode der Random-Klasse
Random generator = new Random();
Console.WriteLine(generator.NextInclusive(1, 4));
//Verwendung des in der Schiff-Klasse definierten IEnumerable
Schiff schiff = new Schiff("ww", 2, 2, Schiff.Treibstoffart.Dampf);
schiff.Ladungsliste.Add(new Schiff("ww", 2, 2, Schiff.Treibstoffart.Dampf));
schiff.Ladungsliste.Add(new Schiff("ww", 2, 2, Schiff.Treibstoffart.Dampf));
schiff.Ladungsliste.Add(new Schiff("ww", 2, 2, Schiff.Treibstoffart.Dampf));
schiff.Ladungsliste.Add(new Schiff("ww", 2, 2, Schiff.Treibstoffart.Dampf));
foreach (var item in schiff)
{
Console.WriteLine(item);
}
#endregion
//Programmpause
Console.ReadKey();
}
public void saveSchiff(Schiff schiff)
{
context.Schiffe.Add(schiff);
context.SaveChanges();
}
