Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 15 von 16

Thema: Anleitung: C# lernen

  1. #1
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Anleitung: C# lernen

    Guten Tag^^


    Ich habe mir mal gedacht, dass ich mein Wissen über die Programmiersprache C# in Form von einzelnen Themen-Beiträgen auf schreibe und anderen Neulingen in der Programmierung mit C# zur Verfügung stelle.

    Da ich selber erst seit einer verhältnismäßig kurzen Zeit programmiere, kann ich mich noch sehr gut an die "dunkle Zeit" erinnern, in der ich das Internet durchforstet habe um Antworten auf meine zahlreichen Fragen zu finden. Es gibt zwar Tutorial, aber keines davon behandelt alles.

    Ich werde im Laufe meines Tutorials meine Kenntnisse aufschreiben und so einfach erklären, wie möglich, damit es jeder versteht.
    Lasst euch also nicht vom Umfang abschrecken, denn der Entsteht hauptsächlich durch die detaillierte Erklärung eines Themas.

    Dass das .net-Framework einen riesen Umfang hat und ich mich hüte, zu behaupten, dass ich halbwegs viel davon kenne, kann ich nur einen roten Faden bieten. Ich zeige Dinge und was dabei wichtig sein kann. Eigenstudium ist daher auch bei mir notwendig, sonst wird das nichts mit dem Programmieren. Sucht einfach in Google, setzt C# davor und es wird sich sehr weit oben die Website von msdn (Mikrosoft) zeigen. Dort findet ihr ein ausführliches Nachschlagewerk für .Net-Framework-Elemente.


    Ich werde hier nicht in regelmäßigen Abständen etwas posten, sondern immer dann, wenn ich Zeit und die Muße dazu habe.
    Das heißt, es können am Tag mal drei oder vier Themen behandelt werden, oder ich lasse mal einen Tag aus.



    Damit euch der Anfang leicht fällt, eine einfache Ideen für kleines Projekt, das schon früh zu realisieren ist:

    Einen kleinen Rechner in der Konsole. Je nachdem, wie weit ihr seid, kann er umfangreicher, sicherer, etc. sein. Bis so ein Konsolen-Rechner perfekt ist, reichen einfache Rechenoperatoren und ein simples Text-Menü nicht aus.
    Geändert von Palladin007 (18.05.12 um 22:03 Uhr)

  2.   Anzeige

     
  3. #2
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Visual Studio downloaden und installieren

    Und gleich zu Beginn, der Compiler, mit dem ich programmiere und mit dem besonders Anfänger einige Mittel in die Hand gelegt bekommen, die das Programmieren enorm erleichtern:

    Visual Studio

    VS enthält kompakt alle Entwicklungstools von Microsoft. Wer also nicht nur bei C# bleiben will, sondern zum Beispiel auch mit Webanwendungen arbeiten will, sollte sich diesen Compiler downloaden.

    Hier sind die Download-Links: Download der Visual Studio 2010 Express Produkte

    Wählt euch entweder Visual C# 2010 Express (unterstützt nur C#) oder Alle Express-Produkte als ISO-Datei (unterstützt alle Produkte, die im Express-Paket enthalten sind. Überlegt euch allerdings auch, wie lange ihr auf den Download warten wollt, denn die komplette VS-Version ist deutlich größer als die C#-Version.


    Es gibt auch noch andere Compiler, so z.B. #Develop, das Visual Studio recht ähnlich ist.



    Also downloadet eine dieser VS-Versionen und installiert sie.
    Das kann einige Zeit beanspruchen, also richtet euch darauf ein.

    Wenn es dann installiert ist, könnte ihr nun auch das Programm starten und fröhlich los programmieren. ^^
    Geändert von Palladin007 (07.06.14 um 00:09 Uhr)

  4. #3
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Erstellen eines neuen Projektes

    Als erstes öffnet ihr erst einmal Visual Studio (oder Visual C#) und startet ein neues Projekt:

    Klicke auf die Grafik für eine größere Ansicht

Name:	1.jpg
Hits:	530
Größe:	101,4 KB
ID:	66362
    (Dieses Bild und auch die Folgenden wurde mit Visual Studio erstellt. Bei Visual C# sind deutlich weniger Start-Projekte möglich)

    Dann kommt ihr zu einer Übersucht, welches Projekt ihr erstellen wollt. Dort wählt ihr unter C# - Windows eine Konsolen-Anwendung, gebt unten euren Namen ein und bestätigt mit OK.

    Klicke auf die Grafik für eine größere Ansicht

Name:	2.jpg
Hits:	670
Größe:	148,4 KB
ID:	66363

    Nun seid ihr in der Programmier-Umgebung:

    Klicke auf die Grafik für eine größere Ansicht

Name:	3.jpg
Hits:	693
Größe:	168,8 KB
ID:	66364

    In der Mitter seht ihr den Editor. Dort programmiert ihr euer Programm.


    Rechts seht ihr zwei Fenster.

    Das obere Fenster ist der Projektmappen-Explorer. Dort sind die Projekte und deren Bestandteile gezeigt.
    Von oben nach unten:
    • Die Projektmappe. Hier heißt sie "Hallo Welt"
    • Die Projekt-Datei, auch mit dem Namen "Hallo Welt". Sie verwaltet die Bestandteile des Projektes
    • Properties sind die Eigenschaften des Projektes.
    • "Verweise" enthält die Verweise zu den einzelnen Klassenbibliotheken aus dem Framework.
    • "Program.cs" ist unsere erste Programm-Datei. In solchen Dateien wird programmiert.

    Uns soll erst einmal nur die Datei "Program.cs" interessieren, denn auch ihr Inhalt wird euch im Editor angezeigt.

    Das untere Fenster zeigt einzelne Eigenschaften des aktuell ausgewählten Elementes. Damit können die Eigenschaften einzelner Dateien, aber auch die Eigenschaften einzelner Elemente bei z.B. bei der grafischen Programmierung eingesehen und bearbeitet werden.


    In der unteren Leiste findet ihr zwei Dinge. Interessant ist dabei die "Fehlerliste". Fahrt mit der Maus darüber und ihr findet alle, vom Compiler gefundenen, Fehler und könnt mittels Doppelklick auch Diesen anzeigen lassen.


    Was ihr Links findet, ist vorerst uninteressant, sowie alles, was ihr oben findet.



    Nun habt ihr ein neues Projekt erstellt und könnt damit eure kleinen oder großen Programme erstellen.
    Geändert von Palladin007 (04.06.13 um 13:57 Uhr)

  5. #4
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Das erste Programm: "Hallo Welt"

    Der Tradition gemäß mache ich zu Beginn auch ein kleines "Hallo Welt"-Programm um die grundlegende Syntax von C# etwas näher zu bringen.


    Wenn wir nun unser neu erstelltes Projekt anschauen, finden wir im Text-Editor folgende Zeilen:


    Code:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    Das sind Using-Statemants. Hier wird festgelegt, welche Klassenbibliotheken oder Namensräumen (später mehr zu Beidem) in dieser Datei verwendet werden.
    Auch das ist vorerst uninteressant.

    Code:
    namespace Hallo_Welt
    {
        class Program
        {
            static void Main(string[] args)
            {
            }
        }
    }
    Das ist das eigentliche Programm.

    Ihr seht überall die geschweiften Klammern. Zwischen ihnen wird Code geschrieben und das, was zwischen ihnen geschrieben wurde, ist ohne Weiteres außen nicht zugänglich. Klassen, etc. können daraus nur aufgerufen werden, wenn diese öffentlich deklariert wurden und der Namensraum bekannt ist. Aber auch dazu später mehr.

    Das Schlüsselwort namespace gibt einen Namensraum an. Dort sind die Klassen enthalten. Der Vorteil von so einem Namspace ist der, dass in zwei verschiedenen Namspaces Typ-Deklarationen denselben Namen tragen dürfen. Sie werden allerdings meist dafür verwendet, logische Bereiche zu schaffen und von einander zu trennen.
    Was Typ-Deklarationen sind, werden wir später genauer betrachten, zuerst schauen wir uns aber die Klasse an, mit der man einen neuen Typ erstellen kann.

    Das Schlüsselwort class erstellt eine neue Klasse, in der darauf einzelne Teile des Programmes enthalten sind.

    In unserer ersten Klasse ist auch unsere erste Methode gegeben.
    Methoden sind eine Art "Unterprogramme", in denen einzelne Teile des Programm-Codes gekapselt liegt. So kann man Code-Abschnitte in logische Bereiche einteilen, oder man muss ihn nicht immer wieder schreiben, da es ausreicht, die Methode aufzurufen. Es erspart also eine ganze Menge Arbeit, erleichtert die Übersicht und ermöglicht viele Dinge auch erst.
    Methoden sind für uns erst einmal das Wichtigste, da wir vorerst nur darin schreiben werden um die grundlegenden Sprach-Konzepte kennen zu lernen.

    Code:
    static void Main(string[] args)
    Diese Zeile ist der Methodenkopf.

    Er ist definiert durch den Rückgabewert (hier void), der Name (hier Main) und den Parametern (hier string[] args).
    Was das Wort "static" bedeutet, erfahren wir auch erst später.
    Der Anfang einer Klasse wird mit einer geöffneten geschweiften Klammer fest gelegt und mit einer geschlossenen geschweiften Klammer wieder geschlossen. Dort drin ist der Methodenrumpf, wo das stattfindet, was die Methode erledigen soll.

    Diese eine Methode mit dem Namen "Main" ist die wichtigste Methode im ganzen Programm, denn dort drin spielt sich alles ab. Der Beginn der Methode und das Ende beschreiben die gesamte Laufzeit des Programms. In ihr kann man weitere Methoden aufrufen und so ein komplexes Programm auf bauen.


    Was wir jetzt schreiben, ist ein einfaches Programm, dass einen Text, nämlich "Hallo Welt" anzeigen soll.

    Da wir eine Konsolen-Anwendung erstellt haben, können wir auch direkt die Konsole ansprechen und dort alles anzeigen lassen.

    Wir schreiben also das Wort Console. Das bringt uns nicht viel, weil wir damit nur die Konsole haben, aber sie soll ja auch etwas tun. Dafür gibt es die Methode, WriteLine. Diese Methode schreibt, wie der Name schon sagt, eine Zeile in die Konsole.

    Wir setzen also hinter unser "Console" einen Punkt und bekommen gleich eine breite Auswahl von Methoden und anderen Dingen.
    Dann kann man entweder "WriteLine" suchen, oder selber schreiben und am Ende eine geöffnete und eine geschlossene runde Klammern setzen. Zum Schluss wird die Befehlszeile noch mit einem Apostroph beendet.

    Das Apostroph ist ganz wichtig, denn der Compiler versteht sonst nicht, wo eine Befehlszeile zu ende ist. Man kann mehrere Befehle auch in eine Zeile schreiben - solange jedes Apostroph korrekt gesetzt wurde, versteht der Compiler das genauso gut.

    Das ganze sieht dann so aus:

    Code:
    Console.WriteLine();
    Der fertige Code sieht dann so aus:

    Code:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace Hallo_Welt
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine();
            }
        }
    }
    Wenn ihr nun oben in der Leiste unter Debuggen den Eintrag Debugging starten auswählt, oder einfach auf der Tastatur [F5] drückt, wird das Programm gestartet. Was dann passiert, ist im Grunde gar nichts. Die Konsole wird geöffnet und geschlossen.

    Logisch, denn wir rufen zwar die Methode WriteLine auf, aber geben ihr nichts zum Schreiben und es wird auch nirgendwo gesagt, dass das Programm geöffnet bleiben soll

    Also gehen wir wieder in unsere Zeile und setzen den Cursor zwischen die zwei runden Klammern. Dort kann dann angegeben werden, was geschrieben werden soll, also geben wir fix mal Hallo Welt ein. Das alleine reicht aber noch nicht, denn das Programm muss unseren Text auch als Text erkennen und das machen wir ganz einfach und zwar setzen wir am Beginn des Textes Anführungszeichen und am Ende auch. Der Text wird nun rot dargestellt und alles ist korrekt.

    Unsere Zeile sieht nun so aus:

    Code:
    Console.WriteLine("Hallo Welt");
    Wenn wir das Programm nun wieder so starten, wie vorhin auch, wird genauso viel passieren, wie vorher. Das liegt daran, dass Programm zwar den Text darstellt, aber die Konsole sofort wieder geschlossen wird.

    Damit wir noch Zeit haben, den Text überhaupt zu erkennen, müssen wir der Konsole den Befehl "ReadLine" geben. Diese Methode sagt dem Programm, dass es so lange warten soll, bis die Enter-Taste gedrückt wird. Eigentlich wird die Methode dafür verwendet, eine eingegebene Zeile vom Nutzer abzufragen, taugt aber auch ganz gut zum Pausieren des Programms.

    Also schreiben wir Console.ReadLine();
    Die Methode Console.Read(); geht genauso. Der Unterschied ist nur, dass Read() eine beliebige Taste erwartet.

    Nun haben wir diese zwei Zeilen in das Programm geschrieben:

    Code:
    Console.WriteLine("Hallo Welt");
    Console.ReadLine();
    Und damit ist unser erstes kleines Programm auch schon abgeschlossen.


    Was es nun tut, ist, in kleinen Schritten erklärt, folgendes:

    1. Die Konsole wird geöffnet
    2. Es wird eine Zeile Hallo Welt geschrieben
    3. Und dann wartet das Programm, bis die Enter-Taste gedrückt wird


    Bewundert also euren kleinen Text und drückt die Enter-Taste. Das Programm wird sich schließen.
    Geändert von Palladin007 (04.06.13 um 14:15 Uhr) Grund: Korrektur und kleiner Hinweis zu den Methoden

  6. #5
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Kommentare

    Kommentare sind einfach nur Text, der von dem Compiler ignoriert wird.

    Auf diese Weise kann man umfangreichere Programme mit einzelnen Kommentar-Zeilen versehen und erklären, was welche Aufgabe haben soll. Das hilft, die Übersicht zu behalten.

    Hier ein kleines Beispiel:

    Code:
    namespace Hallo_Welt
    {
        class Program
        {
            static void Main(string[] args)
            {
                /*
                 * Das hier ist ein Kommentar. Er beginnt mit /* und endet mit */
                 * (Die Zeile oben muss entfernt werden, damit es funktioniert, dann das: "Er beginnt mit /* und endet mit */" beendet das Kommentar)
                 * Alles, was dazwischen geschrieben steht, wird beim Ausführen des Programms ignoriert.
                 */
    
                Console.WriteLine("Hallo Welt");
    
                // Auch das hier ist ein Kommentar. Hier beginnt es mit zwei Slaches und endet am Ende der Zeile.
                // Um mehrere Zeilen zu erhalten, muss auch eine weitere Zeile auskommentiert werden.
    
                Console.ReadLine();
    
                /*
                 * Wenn dieses Programm nun ausgeführt wird, dann wird genau das passieren, wie im letzten Beitrag.
                 * Es wird die Konsole geöffnet, "Hallo Welt" hinein geschrieben und dann wartet es, bis "Enter" gedrückt wird.
                 */
    
                /* Ein Kommentar kann auch so geschrieben werden.*/
                // Oder auch so.
            }
        }
    }

    Noch einmal zusammenfassend:

    Es gibt zwei Möglichkeiten, ein Kommentar zu schreiben:

    1. Ein Kommentar wird begonnen mit /* und endet mit */
    2. Ein Kommentar beginnt mit // und endet am Zeilenende
    Geändert von Palladin007 (18.05.12 um 22:25 Uhr)

  7. #6
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Variablen und der Datentyp Integer

    C# ist eine stark typisierte Programmiersprache. Das heißt, dass alles mit Hilfe von Datentypen geregelt wird.
    Es gibt bereits in der Sprache verankerte Datentypen, Datentypen, die im Framework gegeben sind und man kann auch eigene Datentypen erstellen.


    Für den Anfang beschäftigen wir uns mit den grundlegenden Datentypen, die bereits in der Sprache verankert sind.


    Der wohl einfachste Datentyp ist die Zahl. Positiv, negativ, aber ohne Kommastellen.
    Eine solche Zahl wird mit Hilfe des Datentyps Integer angegeben.

    Um nun den Datentyp zu verwenden, müssen wir einen Speicherbereich reservieren, also so etwas, wie eine Box, in der wir dann unsere Zahl hinein legen können.
    Ein solcher Speicherbereich wird Variable genannt und wird euch überall begleiten.

    Wie wir nun einen solchen Speicherbereich belegen, geht nach diesem Prinzip:

    Code:
    Datentyp VariablenName;
    Wenn wir also einen Speicherbereich haben wollen, der eine einfache Zahl repräsentiert, müssen wir den Datentyp Integer (kurz: int) verwenden.

    Wir schreiben also diese Zeile in unser Programm:

    Code:
    int MeineZahl;
    Dieser Datenbereich ist jetzt reserviert, hat einen festen Datentyp und einen Namen, aber es ist noch nichts darin gespeichert.
    Wir müssen dieser Variable also einen Wert zuweisen, der dem Datentyp entspricht.
    Unser Schema wird nun so erweitert:

    Code:
    Datentyp VariablenName = Wert;
    Wenn wir nun das Beispiel 5 nehmen, sieht das bei uns so aus:

    Code:
    int MeineZahl = 5;
    Unsere Variable "MeineZahl" hat nun den Wert 5 und genau so wird sie auch verwendet.
    Wenn wir also irgendwo die 5 haben wollen, können wir auch unsere Variable hin schreiben und das Programm wird automatisch die Zahl, die in der Variable gespeichert wurde, verwenden.

    Hier ein kleines Rechen-Beispiel:

    Code:
    int Zahl1 = 5;
    int Zahl2 = 10;
    
    int Ergebnis = Zahl2 / Zahl1;
    
    Console.WriteLine(Ergebnis);
    Console.Read();
    Zahl1 wird mit 5 beschrieben und Zahl2 mit 10.
    Ergebnis bekommt hier dann das Ergebnis von Zahl2 geteilt durch Zahl1, also 10 durch 5, was laut meinem Taschenrechner 2 ist.
    Es gibt noch weitere Rechenoperatoren: Addition (+), Subtraktion (-), Multiplikation (*), Modulo (%) und natürlich Division(/).

    Modulo:
    Modulo ist ein Rechenoperator, der den Rest aus einer Division angibt.
    Rechnet ihr z.B. 10 / 3, dann würde die Ausgabe 3,3333333... sein (voraus gesetzt, ihr verwendet Fließkommazahlen. Wenn nicht, ist das Ergebnis 0. Aber dazu später mehr.) Wenn ihr nun aber 10 % 3 ausrechnen lasst, dann ist das Ergebnis 1, weil 9 genau durch 3 geteilt werden kann und dann noch 1 übrig bleibt.
    Also die Rest-Rechnung, die ihr in der Schule schon früh kennen gelernt habt.


    Wenn ihr das Programm also startet, werdet ihr auch sehen, er gibt eine 2 aus.

    Wenn ihr aber nun Zahl1 und Zahl2 vertauscht, das heißt Zahl1 (5) durch Zahl2 (10) rechten, müsste es, laut meinem Taschenrechner 0,5 sein.
    Wenn ihr das Programm nun Startet, werdet ihr sehen, da steht kein 0,5. Da steht nur 0.

    Das ist auch korrekt so, denn wie ich oben schon erwähnt habe, kennt der Datentyp int nur ganze Zahlen, ohne Komma. Also wird ganz einfach alles hinter dem Komma abgeschnitten. Es wird nichts gerundet.

    Und so kommt auch die 0 zu Stande.
    Wenn ich nun 15 durch 10 rechnen lasse, gibt mir mein Taschenrechner 1,5 aus.

    Nun denken wir nach, wenn wir alles hinter dem Komma abschneiden, bleibt nur noch die 1 übrig.
    Startet das Programm und es wird eine einsame Eins zeigen. ^^
    Geändert von Palladin007 (04.06.13 um 14:27 Uhr)

  8. #7
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Weitere Datentypen (string, double, boolean)

    Da wir ja im letzten Beitrag mit Hilfe der Integer gelernt haben, wie man mit Variablen arbeitet, stelle ich hier noch drei weitere Datentypen vor, mit denen ihr im Laufe der Zeit immer zu tun haben werdet.


    string

    String beschreibt einfach nur Text. Diese Datentyp ist es egal, was darin steht, solange es als Text erkannt wird.
    Und damit es als Text Erkannt wird, muss es in Anführungszeichen gesetzt werden.

    Wir schreiben das kleine Hallo Welt-Programm also um:

    Code:
    string nachricht = "Hallo Welt";
    Console.WriteLine(nachricht);
    Console.ReadLine();
    Wenn ihr das "Hallo Welt" nun so hinter die Variable schreibt, werdet ihr im Visual Studio fest stellen, dass der Text rot dargestellt wird, wie auch vorher im alten Hallo Welt-Programm, wo der Text halt in der Ausgabe der Console (Console.WriteLine();) rot dargestellt wurde.
    Das heißt nur, dass dieser Code als String erkannt wurde.

    Wenn ihr euren Text nun in der Variable vom Typ string habt, dann braucht ihr nur noch den Namen der Variable bei Console.WriteLine(); hinein zu schreiben und es passiert das gleiche, wie vorher auch.

    Der Text wurde also in der Variable gespeichert und später wieder daraus abgerufen.


    double

    Der Datentyp double stellt auch eine Zahl dar. Allerdings beschreibt er eine Zahl mit Kommastellen. Es gibt neben double noch float als Datentyp. Damit könnt ihr genau das gleiche darstellen, wie mit Double. Der einzige Unterschied ist der Wertebereich. Double hat einen sehr großen Wertebereich.
    Mit Hilfe dieser Zeile könnt ihr euch den größten Wert anschauen, den Double zu bieten hat:

    Code:
    Console.WriteLine(Double.MaxValue);
    Wenn ihr double nun als Datentyp verwendet, kann man auch Rechnungen rechnen lassen, wie 5 durch 10, der 15 durch 10.

    Code:
    double Zahl1 = 5;
    double Zahl2 = 10;
    double Ergebnis = Zahl1 / Zahl2;
    Console.WriteLine(Ergebnis);
    Console.ReadLine();
    Und siehe da, das Ergebnis ist 0,5.



    boolean

    Boolean ist einer der einfachsten Datentypen.
    Eine Variable mit diesem Datentyp kann nur zwei Werte annehmen: Ja und Nein.

    Also Programmcode sieht das dann wieder so aus:
    true -> Ja
    false -> Nein

    Eine solche Variable wird genauso definiert, wie andere auch, wobei es eigentlich egal ist, ob wie Boolean, oder das Kürzel bool verwenden.

    Ich werde in meinen Beispielen immer bool verwenden.


    Als Beispiel:

    Code:
    bool Wert1 = true;
    bool Wert2 = false;
    Das sind die einzigen beiden Möglichkeiten.
    Wozu dieser Datentyp wichtig sein kann, werde ich später noch erklären.
    Das erste Thema, was sich mit boolean beschäftigt, wird sich mit If-Abfragen beschäftigen.

  9. #8
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    If-Abfragen

    Und nun geht es weiter mit den If-Abfragen.
    Sie prüfen, ob eine AUssage wahr ist, oder nicht und erledigen je nach Festlage einige Aufgaben.

    Ihr Anwendung ist allgemein wichtig, da stendig irgend etwas überprüft werden muss.
    Mit ihrer Hilfe kann man z.B. eine Eingabe überprüfen und so einem Fehler, der zum Programm-Absturz führen würde, aus dem Weg gehen.


    Ihre Definition ist denkbar einfach:

    Wenn (Bedingung) dann (Anweisung) sonst (Anweisung)

    Wenn man das ganze jetzt nur noch ins Englische übersetzt, hat man fast die If-Frage.


    Korrekt sieht das ganze dann schließlich so aus:

    Code:
                if (true)
                {
    
                }
                else
                {
    
                }
    Das if ist unser "Wenn". In den runten Klammern steht immer die Bedingung und zwischen den geschweiften Klammern stehen die Anweisungs-Zeilen.
    Das else ist unser "dann" und wird dann ausgeführt, wenn die Bedingung nicht erfüllt wird.


    Zu den Bedingungen:

    Bei den Bedingungen gibt es ein paar Zeichen, die verwendet werden und die habe ich mal hier aufgelistet:

    == Vergleich
    < Kleiner als
    <= Kleiner oder gleich als
    > Größer als
    >= Größer oder gleich als
    != Ungleich
    && Logisches UND
    || Logisches ODER

    Die ganzen Vergleichsoperatoren sind denke ich klar.

    Interessant ist allerdings, dass man das Ausrufezeichen nicht nur bei dem Ungleich verwenden kann.
    Das Ausrufezeichen steht immer für das Gegenteil. In dem Fall bedeutet es das Gegenteil von Gleich, also Ungleich.

    Wenn ich also schreibe:

    Code:
    bool wert = !true;
    Dann hat das die gleiche Bedeutung, wie false, denn false ist das Gegenteil von true.


    Das logische Und, sowie auch das logische Oder werden immer zwischen zwei vergleichen geschrieben.
    Wenn ich also schreibe:

    Code:
    bool wert = true && true;
    Dann ist das Ergebnis, das in der Variable gespeichert wird war, weil sowohl vor dem UND als auch danach ein wahr erkannt wurde.
    Wenn ich aber schreibe:

    Code:
    bool wert = true && false;
    Dann ist das Ergebnis false, da wegen dem UND beide Prüfungen wahr sein müssen, das false aber nicht wahr ist.
    Wenn ich statt dem UND aber ein ODER setze, ist das etwas anderes, dann da muss nur eine der Bedingungen wahr sein:

    Code:
    bool wert = true || false;
    Hier ein passendes Beispiel mit Zahlen:

    Code:
    bool wert = 5 == 4 && 3 == 4;
    Das ist falsch, denn nur eine der Bedingungen ist wahr, wegen dem UND müssen sie es aber beide sein.

    Diese Schreibweise kann man nun immer weiter verschachteln.


    Code:
    bool wert = 5 / 2 < 3 && ( 5 + 3 == 6 || "hallo" == "hallo");
    Das würde wahr ergeben. Denn in der Klammer habe ich die Wahl zwischen zwei Bedingungen gelassen:
    -> 5 + 3 ist 8, also nicht 3. Diese AUssage ist also falsch
    -> "hallo" ist gleich "hallo", auch wenn es keine Zahlen sind, man kann sie trotzdem vergleichen.

    Da hier die Wahl ist, muss nur eines wahr sein und die zwei Bedingung wurde erfüllt, also erhält die ganze Klammer den Wert true.
    Nun bleibt nur noch die Frage, ob 5 durch 2 auch kleiner ist, als 3. Das stimmt, also wurden beide Beidingungen erfüllt, das Endergebnis ist also wahr.



    Dieses Prinzip müssen wir aber nicht bei den Variablen nutzen. Wenn man den Wert nicht speziell als Variable braucht, kann man ihn einfach direkt zwischen die Klammern der Bedingung schreiben und das Programm errechnet, ob die Bedingung erfüllt wurde, oder nicht.


    Am besten lässt sich das in einem kleinen Programm zeigen:
    els erstes erstellen wir uns eine Methode.
    Wie wir gelernt haben, besteht eine Methode aus Rückgabewert, Name und Parametern.
    Wir wollen jetzt eine kleine Methode schreiben, die überprüft, ob eine Zahl gerade ist, oder nicht.
    Dazu bedienen wir uns eines einfachen Tricks, den uns der Integer ermöglicht.
    Und der sieht so aus:

    Wenn eine gerade Zahl durch 2 geteilt wird, ergibt diese Hälfte eine ganze Zahl.
    Wenn eine ungerade Zahl durch 2 geteilt wird, ist die Hälfte keine ganz Zahl.
    Wir rechnen also die Hälfte der zu prüfenden Zahl aus und speichern sie in einer Integer-Variable, wodurch alle Kommastellen abgeschnitten werden.
    Darauf nehmen wir dieses Ergebnis und multiplizieren es wieder mit 2.
    Wenn das nun gleich der Ausgangszahl ist, dann haben wir eine gerade Zahl. Wenn nicht, dann ist sie ungerade.

    Code:
            // Hier ist der Rückgabewert "bool" für Boolean, der Methodenname "PrüfeObGerade" und
            // als Parameter wird die zu prüfende Zahl verlangt. Sie soll den Typ int für Integer haben und
            // trägt in der Methode den Namen "Zahl"
            static bool PrüfeObGerade(int Zahl)
            {
                int cache = Zahl; // Die übergebene Zahl wird hier in der Variable "cache" einmal abgespeichert.
                cache = cache / 2; // Nun teilen wir die Zahl durch 2
                cache = cache * 2; // Und multiplizieren sie auch wieder
    
                if (cache == Zahl) // Als Bedingung wird verglichen, ob "cache" nun gleich "Zahl" ist
                {
                    return true; // Wenn ja, haben wir eine gerade Zahl und es wird "true" für Wahr zurück gegeben
                }
                else // Das tritt ein, wenn die Bedingung nicht erfüllt wird
                {
                    return false; // Wenn ja, haben wir keine gerade Zahl und es wird "false" für Falsch zurück gegeben
                }
            }

    Wie ihr an diesem Beispiel sehen könnt, muss man beim Programmieren sich an die Sprache anpassen.
    Wer verstanden hat, wie sie funktioniert, wird auch später keine großen Probleme haben, weiter zu lernen.

    Viel Spaß



    Hinweis:
    Ich habe eben von duffguy den Hinweis bekommen, dass mein letztes Code-Beispiel sich auch eleganter programmieren lässt.
    Damit hat er auch recht, aber da ich darin If-Abfragen erklären wollte, werde ich die elegantere Variante hier zeigen:


    duffguy hat mir den Hinweis gegeben, dass man das Ergebnis der Bedingung in der If-Abfrage ja auch gleich zurück geben kann.
    Das geschieht nicht anders, als wenn wir das Ergebnis eines Vergleiches in eine Variable speichern, nur schreiben wir es hier nicht in eine Variable, sondern geben es direkt mit Hilfe von return zurück.
    Das sieht dann so aus:
    Code:
    return (cache == Zahl);
    Wer nun ganz sparsam sein will, kann die Klammern auch noch weg lassen, aber die dienen gut zur Übersicht.

    Der ganze Code sieht dann so aus:

    Code:
            static bool PrüfeObGerade(int Zahl)
            {
                int cache = Zahl / 2;
                cache = cache * 2;
                return (cache == Zahl);
            }
    Das kann man nun noch weiter vereinfachen.

    Dazu nehmen wir uns erst einmal diese Zeile:
    Code:
    int cache = Zahl;
    Hier wird der Inhalt von "Zahl" durch 2 geteilt in "cache" gespeichert.

    Der Inhalt der Variable wird danach in der nächsten Zeile direkt wieder mit 2 multipliziert.
    Warum also nicht gleich "Zahl" durch 2 teilen, in Klammern setzen und wieder mit 2 Multiplizieren?

    Zusammen gefasst können wir dann so schreiben:
    Code:
    int cache = (Zahl / 2) * 2;
    Und als letztes müssen wir nun noch überprüfen, ob cache nun gleich Zahl ist, oder nicht.
    Aber auch hier kann man wieder etwas zusammen schieben. Wir können nämlich einfach die Rechnung, die cache bestimmt, nehmen und direkt mit Zahl vergleichen, also so:
    Code:
    ((Zahl / 2) * 2 == 2)
    Und das müssen wir jetzt nur noch als Ergebnis der Methode zurück geben lassen.

    Unsere verkleinerte Methode sieht nun so aus:
    Code:
            static bool PrüfeObGerade(int Zahl)
            {
                return ((Zahl / 2) * 2 == Zahl);
            }
    Deutlich kleiner, oder?

    Entscheidet selber, was euch lieber ist. Wenn ihr lieber noch mit If arbeitet oder die Rechnung auf mehrere Variablen aufteilt, dann solltet ihr da auch tun, denn wenn euch bei so komprimierten Zeilen Fehler passieren, sind die auch schwerer zu finden. Und wenn ihr jemanden um Hilfe bittet, wird der es auch schwerer haben, sich dort hinein denken zu können.


    Geändert von Palladin007 (14.04.12 um 21:32 Uhr) Grund: Korrektur in einem Beispiel / Rechtschreib-Korrektur

  10. #9
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Schleifen (for; while; do-while; foreach)

    In C# gibt 4 verschiedene Schleifen. Alle 4 kann man ständig gebrauchen, deshalb ist es ein wichtiges Thema ^^


    Zu Beginn erst einmal das Wort break. Es wird in allen Schleifen dazu verwendet, die Schleife sofort zu beenden.
    Wenn wir in einer Schleife also schreiben break; dann wird an dieser Stelle die Schleife abgebrochen.


    Jetzt weiter mit den Schleifen:

    FOR-Schleife

    Die For-Schleife ist eine Zähl-Schleife. Sie zählt von einer Start-Zahl bis zu einem bestimmten Ende und zählt dabei in den fest gelegten Schritten. Ein nützliches Teil und so wird sie geschrieben:

    Code:
    for (int i = START; i <= ENDE; i++)
    {
        
    }
    Wenn ich das einmal mit einer Wort-Definition zeige:

    VON (ZAHLENTYP INDEX = START; INDEX <= ENDE; INTERVALL)
    {

    }

    In der Schleife wird im Prinzip eine neue Variable erstellt.
    Ganz am Anfang in den runden Klammern steht der Datentyp. Dieser Datentyp muss ein nummerischer Typ sein, also merkt euch einfach fürs Erste int und double. Ich persönlich habe double noch nie benutzt, das kann jeder halten, wie er möchte.

    Diese Variable vekommt einen Namen. Standartmäßig ist dieser Name i für Index, aber der kann im grunde frei gewählt werden.
    Darauf folgt dann ein Semikolon, das angibt, dass die Variable fertig definiert wurde.

    Dahinter folgt dann eine Bedingung, wie wir sie schon von der If-Abfrage kennen. Und tatsächlich, dort kann man auch einfach true rein schreiben, doch das ist nicht Sinn und Zweck dieser Schleife.
    Die Schleife zählt also einfach nur solange, wie in der Bedingung true raus kommt.
    Wenn wir also wollen, dass die Zahlen 1, 2, 3, 4 und 5 gezählt werden sollen, muss in der Bedingung stehen i<=5
    Das heist, die Schleife zählt so lange, bis i entweder kleiner als 5 ist, oder gleich.
    Diese Bedingung kann nun frei gestellt werden, aber zum zählen reicht das aus.
    Und auch hier hinter folgt ein Semikolon, das angibt, dass die Bedingung zuende ist.

    Als letztes folgt das Intervall. Als Standart steht dort immer i++. Das heist, dass i immer um eines erhöht wird. Wenn ihr i-- schreibt, dann wird i immer um eins verringert.
    Ihr könnt dort auch eine ganze Rechnung eingeben, wie wir sie schon kennen.
    Als Beispiel: i = i + 2
    Das zählt immer zwei auf i dazu, also zählt die Schleife in Zweier-Schritten.


    Gut, damit ist die Scheife auch beendet. Vorne wird die Variable, mit der gezählt wird, fest gelegt, danach die Bedingung, die angibt, wie lange gezählt wird und als letztes die Rechnung, die das Intervall bestimmt.


    Und hier haben wir auch unsere Schleife:
    Code:
                for (int i = 1; i <= 5; i++)
                {
                    Console.WriteLine(i);
                }
                Console.ReadLine();
    Hier wurde nun eine Schleife erstellt, die von 1 bis 5 zählt. Immer, wenn eins weiter gezählt wird, wird der Befehlsblock zwischen den geschweiften Klammern ausgeführt. Hier ist es wieder unsere Konsolen-Anweisung, die i in die Konsole schreibt.
    Wenn ihr das in ein Programm einfügt, werdet ihr sehe, dass dort 1, 2, 3, 4 und 5 untereinander aufgelistet wurde.

    Wenn ihr das Intervall auf 2 setzt (i = i + 2), dann wird dort nur 3 und 5 stehen, denn 1 + 2 = 3 und 3 + 2 = 5.

    Wenn wir jetzt theoretisch betrachten, was in der Schleife passiert:


    i wird als Variable von Typ int mit dem Startwert 1 fest gelegt.
    Mit i wird nun die Rechnung am Ende des SChleifenkopfes ausgeführt. Wenn dort i = i + 2 steht, wird i + 2 gerechnet.
    Dann wird überprüft, ob die Bedingung noch erfüllt wird. Unsere Zahl ist nun 3. Die 3 ist kleiner, als 5, also wird der Befehlsblock ausgeführt. Die 3 wird also hin geschrieben.
    Dann folgt wieder die Rechnung. Wieder 2 auf i zählen, in diesem Fall jetzt 3 + 2 = 5.
    Wir überprüfen: 5 ist nicht mehr kleiner als 5, aber wir haben ja fest gelegt, dass i kleiner oder gleich sein darf. Und 5 ist gleich 5, also wird der Befehlsblock ausgeführt.
    Es wird wieder die Rechnung ausgeführt, also 5 + 2 = 7
    Die Überprüfung ergibt, dass 7 größer als 5 ist, also wird sie nicht erfüllt, wenn es hies ja kleiner oder gleich 5.
    Da die Bedingung nicht erfüllt wurd, wird die Schleife beendet, ohne dass der Befehlsblock noch einmal ausgeführt wird.



    while-Schleifen

    Wer Englisch zumindest ein bisschen kann, und das sollte man bei der Programmierung, (zur Not tuts auch der Google-Übersetzer^^) wird fest stellen, dass while einfach nur während bedeutet.
    Und wie in der englischen Grammatik folgt auf das während eine Bedingung.

    Also sieht das als Schema so aus:

    WÄHREND (BEDINGUNG)
    {
    }

    In der Bedingung kommen wieder solche Bedingungen, wie die, die wir von If kennen.
    Das Programm prüft erst mal, ob die Bedingung erfüllt wird und führt dann so lange den Inhalt der geschweiften Klammern aus, bis die Bedingung nicht mehr erfüllt wird.
    Das kann z.B. der Fall sein, wenn eine Variable, die in der Bedingung enthalten ist, sich ändert, während die Schleife im Gang ist.


    Eine einfache Endlos-Schleife ist dann die hier:

    Code:
    while (true)
    {
    }
    Das würde ich allerdings nicht empfehlen, außer man bricht die Schleife von innen heraus mit break ab.


    Als Beispiel nehme ich mal einen ganz einfachen Taschenrechner. Den Code brauchen wir nicht, wir brauche nur das, was der Nutzer eingibt.
    Wenn es also ein kleines Menü gibt und dort wird aufgefordert, die Nummer eines Menü-Eintrages zu schreiben und zu bestätigen (wir erinnern und an Console.ReadLine() -> Gibt alles aus, was eingegeben wurde, bevor Enter gedrückt wurde).
    Wenn die Menüs also die Nummern 1, 2 oder 3 haben und 0 zum Beenden, dann müssen wir schauen, dass auch passiert.

    Und das passiert am besten mit der switch-Anweisung, doch dazu später noch mehr.

    Viel wichtiger ist, dass überprüft wird, ob die Eingabe auch korrekt ist. Wenn nämlich ein Buchstabe eingegeben wurde, was soll das Programm dann tun? Abstürzen, aus den Augen aus dem Sinn?
    Nein, es wird einfach noch mal zur Eingabe aufgefordert.

    Code:
                string eingabe;
    
                while (true)
                {
                    // Hier steht die Aufforderung, ein Menü zu wählen.
                    // "eingabe" wird beschrieben, durch den Nutzer
    
                    if (/*Überprüft, ob "eingabe" korrekt ist.*/)
                    {
                        break; //Die Schleife wird beendet und so kann ein korrektes "eingabe" später weiter verwendet werden
                    }
                    else
                    {
                        // Da die Eingabe falsch ist, muss eine richtige Eingabe abgefragt werden.
                        // Dazu geben wir erst mal einen kleinen Fehler aus und brechen die Schleife nicht ab
                        // Denn die Schleife beginnt gleich wieder von vorne, fragt nach der Eingabe, überprüft sie und reagiert entsprechend
                    }
                }
    Das ist die While-SChleife und die umkehrung dazu ist die Do-While-Schleife.

    do-while-Schleifen

    Diese Schleife macht das etwas anders, als die while-Schleife.
    Sie tut erst das, was zwischen ihren Klammern steht und danach überprüft sie.
    Sobald dann der Befehlsblock einmal ausgeführt wurde und dann die Bedingung geprüft wurde, geht es ganz normal so weiter, wie bei der while-Schleife.

    Und so wird sie geschrieben:

    Code:
                do
                {
                     // Das hier wird einmal ohne Überprüfimg ausgeführt und dann nur noch, wenn die Überprüfung positiv war
                }
                while (true);
    
                //Nun ist "eingabe" richtig und kann verwendet werden um die richtige Methode auszuwählen, je nachdem, was den Nutzer eingegeben hat.

    Das kann man z.B. für unser Taschenrechner-Problem nutzen:

    Code:
                bool richtig;
                do
                {
                    // Das hier wird einmal ohne Überprüfimg ausgeführt und dann nur noch, wenn die Überprüfung positiv war
                    // Die erste Eingabe wird einfach ausgeführt. Danach wird überprüft, ob die Eingabe korrekt ist und in "richtig" gespeichert.
                    // Die Bedingung besteht nun aus dieser Variable.
                }
                while (!richtig);
    In der Bedingung habe ich vor die Variable ein Ausrufezeichen geschrieben um die Bedeutung umzukehren.
    Denn wenn bei einer falschen Eingabe false gespeichert wird, würde das die Schleife beenden
    Nun wird in der Bedingung true benötigt um die Schleife zu beenden, denn wenn dort true steht, wird die Bedeutung umgekehrt, also sieht das Programm dort ein false und beendet die Schleife.


    Nun ist "eingabe" richtig und kann verwendet werden um die richtige Methode auszuwählen, je nachdem, was den Nutzer eingegeben hat.[/CODE]


    foreach-Schleife

    Eine foreach-Schleife durchläuft alle gegebenen Elemente und beendet sich, sobald keine Elemente mehr gegeben sind.
    Sie arbeitet mit allen Variablen, die mehr als eine Bedeutung tragen können, wie z.B. Listen oder Felder (Arrays).
    Diese Dinge werde ich später noch erklären.

    Hier eine kurze Beschreibung, wie eine foreach-Schleife verwendet wird:

    foreach (Datentyp ItemName in VariablenName)
    {

    }

    In dieser Schleife wird wieder eine Variable erstellt. Sie bekommt den Namen an der Stelle von ItemName und hat den Datentyp, der davor angegeben wird. Hinter dem "in" steht der Variablenname der Liste oder von dem Feld.
    (Listen oder Felder sind Sammlungen von Elementen mit dem selben Datentyp)
    Der Datentyp der in der Schleife erstellten Variable muss der Selbe sein, wie der Datentyp von den Elementen der Liste oder des Feldes.

    Die Schleie geht nun alle Elemente der Liste oder des Feldes nacheinander durch und stellt dieses Element unter dem Namen der Variable, die in der Schleife erstellr wurde, einmal zur Verfügung, bis die Schleife das nächste Element aufruft.
    Geändert von Palladin007 (14.04.12 um 16:36 Uhr)

  11. #10
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Methoden und Zugriffsmodifizierer

    Zitat Zitat von msdn
    Eine Methode ist ein Codeblock, der eine Reihe von Anweisungen enthält. In C# werden alle Anweisungen im Kontext einer Methode ausgeführt.
    In dem Sinne ist es natürlich wichtig, dass ihr versteht, eine Methode zu schreiben, zu verwenden und alles, was sie nun bietet.


    Ich habe an vorheriger Stelle schon die Bestandteile des Methoden-Kopfes erwähnt und das wiederhole ich noch einmal hier:


    Eine Methode besteht immer aus zwei Dingen: Methodenkopf und Methodenrumpf.
    Der Methodenrumpf ist in den geschweiften Klammern zusammen gefasst und der Methodenkopf darüber.


    Rückgabewert MethodenName(Datentyp1 Parameter1, Datentyp2 Parameter2, ... DatentypN ParameterN)
    {
    Hier ist der Methodenrumpf
    return Hier wird ein Wert zurück gegeben und die Methode endet
    }

    Der Rückgabewert kann jeder Datentyp sein. In, double, string, etc. Wenn aber nichts zurück gegeben werden soll, dann schreibt man void hin. Das steht dafür, dass es keine Rückgabe gibt, aber return könnt ihr trotzdem benutzen, um die Methoden sofort zu beenden. Ihr müsst dann einfach so schreiben: return;

    Der Methoden-Name ist beliebig. Was aber nicht akzeptiert wird, sind Punkte, Lehrzeichen und andere Zeichen, die für die Syntax wichtig sind.

    Die Parameter sind sozusagen die Schnittstelle zwischen zwei Methoden. Eine Methode kann so der anderen Werte übermitteln und wenn die Andere einen Rückgabewert gibt, kann die erste Methode auch Werte zurück erhalten.
    In den Klammern für die Parameter kann was stehen, muss aber nicht. Wenn dort nichts steht, könnt ihr der Methode auch keine Werte übergeben, wenn dort aber etwas steht, kann dort beliebig viel stehen.
    Ein Parameter wird dort mit dem Datentyp und folgendem Namen erstellt und mehrere Parameter sind durch Kommata getrennt.
    Diese Parameter werden dann mit dem dort aufgeschriebenem Datentyp und dem dort verwendeten Namen im Methodenrumpf weiter verarbeitet.


    Wie ihr eine Methode aufruft, ist eigentlich ganz einfach:

    Ihr schreibt den Methodennamen hin, und dann runde Klammern, wo die Daten für die Parameter übergeben werden. Klammer schließen und die Methode ist fertig eingebaut.

    Wenn ihr also unsere kleine Methode für die Kontrolle, ob eine Zahl gerade ist, nehmt:

    Code:
            static bool PrüfeObGerade(int Zahl) // Fragt nach einer Variable vom Typ in, die wir der Methode übergeben müssen
            {
                int cache = Zahl;
                cache = cache / 2;
                cache = cache * 2;
    
                if (cache == Zahl)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
    Dann könnt ihr die so aufrufen:

    Code:
            static void Main(string[] args)
            {
                int Zahl = 3;
                bool ergebnis = PrüfeObGerade(Zahl); // Hier steht der Methodenname und als Parameter die Zahl
                Console.WriteLine(ergebnis);
                Console.ReadLine();
            }
    Nun wird geschrieben, ob die Zahl gerade (true) oder ungerade (false) ist.


    Wenn ihr eine weitere Klasse habt und dort eine Methode, dann gibt es noch zwei weitere Dinge, die beachtet werden müssen:

    1. Zugriffsmodifizierer

    Es gibt 4 davon:

    • public
    • private
    • protected
    • internal


    Wichtig sind für uns die ersten zwei davon: public und private.

    Wer etwas Englisch kann, wird das so übersetzen: öffentlich und privat
    Und so werden sie auch verwendet.

    Diese Zugriffsmodifizierer werden immer an den Anfang des Methodenkopfes geschrieben und bestimmen so nun, wer sie aufrufen darf.

    Wenn dort public steht, darf man sie überall im Programm verwenden, ohne Einschränkung.
    private erlaubt die Nutzung nur in der jeweiligen Klasse.

    Wenn ihr also eine Klasse Person habt und darin eine Methode GetAge, dann müsst ihr überlegen, wo sie genutzt werden darf, denn wenn sie pulic ist, darf jeder darauf zugreifen, wenn sie private ist, dürfen nur die Methoden in der Klasse darauf zugreifen.

    Code:
        class Person
        {
            private static int Age = 18;
    
            public static int GetAge()
            {
                return Age;
            }
    
            private static void SetAge(int NewAge)
            {
                Age = NewAge;
            }
        }
    
        class Program
        {
            static void Main()
            {
                int Alter = Person.GetAge(); // Hier gibt die Klasse "Person" das gespeicherte Alter zurück.
                Person.SetAge(20); // Hier wird versucht, dieses Alter zu ändern, da die Methode aber private ist, geht das nicht
                Person.Age = 21; // Hier wird versucht, das Alter direkt zu ändern, allerdings geht das auch nicht, da es private ist
    
                Console.ReadLine();
            }
        }

    Eine Methode aus einer anderen Klasse wird also so aufgerufen, dass der Klassenname aufgeschrieben wird und nach einem Punkt kommt dann die Methode.

    In der Klasse "Person" habe ich aber auch eine Variable definiert. Das ist eine globale Variable, das heist, sie ist in der ganze Klasse gültig und kann direkt verwendet werden.
    Auch solche Variablen werden aufgerufen, wie Methoden, allerdings gibt es keine Parameter.
    Da diese Variable aber auch private ist, kann man sie nicht bearbeiten.

    Also geht nur die Methode GetAge und das auch nur, weil sie public ist. Wenn sie private wäre, könnte man sie auch nicht verwenden.

  12. #11
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Arrays und Listen mit Schleifen

    Arrays und Listen sind zwei Möglichkeiten, eine große Anzahl von Variablen des selben Datentypes zu speichern und zu verarbeiten.


    Arrays:

    Das deutsche Wort ist "Feld".

    Ein Feld/Array kann man sich als Auflistung vorstellen.
    Die Daten der Variablen stehen alle untereinander und links davon wird gezählt.

    Und im Groben verwendet man ein Array auch so. Es werden Variablen darin gespeichert (5, 10 oder auch 100) und können anhand des Indexes (Die Stelle, an der sich eine Variable befindet) abgerufen werden.

    Code:
    int[] ArrayName;
    So wird ein Array deklariert (erstellt). Man schreibt einfach hinter den Datentyp eine eckige Klammer auf und schließt sie sofort wieder.

    Code:
    int[] ArrayName = new int[6];
    Und so wird ein Array instanziert (es bekommt einen Wert zugewiesen). Es folgt nach dem Gleichheitszeichen das Schlüsselwort "new" erstellt hier ein neues Objekt (kommt später noch). Direkt nach einem Lehrschritt folgt dann noch einmal der Datentyp und in weiteren eckigen Klammern steht diesmal die Länge eines Arrays. Diese Länge muss fest gelegt werden.

    Wer einem Array direkt Inhalte zuweisen will, kann das so machen:

    Code:
    int[] ArrayName = new int[] { 1, 2, 1, 5, 8, 3 };
    Hier könnt ihr die vorher fest gelegte Länge weg lassen, da sie ja durch die ANzahl der bereits angegebenen Elemente bestimmt wird.
    Ihr könnt sie allerdings trotzdem fest legen. Wenn es dann aber heist, es gibt nur maximal 5 ELemente, es wurden aber 6 angegeben, dann wird das einen Fehler geben.

    Ein Array zu nutzen, ist an sich ganz einfach.

    Wenn ihr z.B: die Länge ausgegeben haben wollt, müsst ihr nur folgendes dort hin schreiben, wo ihr die Länge benötigt:

    Code:
    ArrayName.Length
    Um einen Wert aus dem Array abrufen zu können, müsst ihr den Index des Wertes kennen.
    Wenn ihr ihn könnt, wird er so abgerufen:

    Code:
    int[] ArrayName = new int[] { 1, 2, 1, 5, 8, 3 };
    int zahl = ArraName[3];
    Ihr müsst dazu den Namen des Arrays nehmen, ihm zwe eckige Klammern anhängen und darin den Index schreiben.



    Listen:

    Listen erfüllen im Grunde die selbe Aufgabe, als Arrays, haben allerdings ein paar nützliche Methoden mehr, als die Arrays.
    Allerdings kann bei einer großen Anzahl an Elementen zu Verlangsamungen kommen, da eine Liste minimal langsamer arbeitet.

    Eine Liste wird so deklariert:

    Code:
    List<int> ListenName;
    Es wird List geschrieben und in zwei spitzen Klammern dann der Datentyp. Das ist nun der Datentyp der Variable, die wir nun delarieren und die dann unsere anderen Variablen enthält.

    Eine Variable wird mit dem selben Prinzip instanziert, wie ein Array:

    Code:
    List<int> ListenName = new List<int>();
    Es folgt nach dem Gleichheitszeichen das Wort "new" und dann der Datentyp der Variable, hier List<int>. Als letztes kommen zwei runde Klammern und die Zeile ist beendet.

    Hier ist die Kapazität nicht erforderlich, kann aber in den runden Klammern angegegeben werden.


    Die Verwendung ist im Grunde ähnlich. Ein Element wird auf die selbe Weise abgerufen, wie bei Arrays und die Länge wird mit ListenName.Count abgerufen.
    Zusätzlich hat die Liste einige nützliche Methoden, wie diese hier:

    Code:
    List<int> ListenName = new List<int>();
    
    int zahl = 5;
    ListenName.Add(zahl);
    // Hier wurde der Liste ein weiteres Element hinzu gefügt.
    
    
    List<int> NeueListe = new List<int>() { 1, 2, 3, 4, 5 };
    ListenName.AddRange(NeueListe);
    // Hier wurde eine komplette Liste hinzu gefügt.



    Zum Schluss gibt es für Beides einen wichtigen Punkt zu klären:

    Der Compuer beginnt IMMER bei 0 zu zählen. Wenn ihr einen ein neues Array oder eine neue Liste habt und da da ist genau ein Element drin, dann hat das den Index 0.
    Wenn ihr drei Elemente darin habt, dann habt ihr dei Elemente mit den Indexen 0, 1 und 2.
    Wenn ihr das nicht beachtet, wird es ständig Fehler geben.




    Für beides gibt es aber noch die Verwendung in zwei Formen der Schleifen:

    Zählschleife:

    Code:
            static void Main()
            {
                List<int> ListenName = new List<int>() { 1, 2, 3, 4, 5 };
                int[] ArrayName = new int[] { 6, 7, 8, 9, 10 };
    
                for (int i = 0; i < ArrayName.Length; i++)
                {
                    Console.WriteLine(ListenName[i]);
                }
                for (int i = 0; i < ListenName.Count; i++)
                {
                    Console.WriteLine(ArrayName[i]);
                }
    
                Console.ReadLine();
            }
    Damit würdet ihr in der Konsole 1 bis 10 zählen lassen.
    Schön, sauber untereinander.
    Ihr könnt also einfach als Länger der Schleife die Länge der Liste eintragen und dann i als Index für die Liste oder das Array nutzen.
    Aber denk dran, die Schleife muss bei 0 beginnen, da der Computer immer bei 0 anfängt, zu zählen, also auch in der Liste der Index bei 0 beginnt.


    Code:
            static void Main()
            {
                List<int> ListenName = new List<int>() { 1, 2, 3, 4, 5 };
                int[] ArrayName = new int[] { 6, 7, 8, 9, 10 };
    
                foreach (int item in ListenName)
                {
                    Console.WriteLine(item);
                }
                foreach (int item in ArrayName)
                {
                    Console.WriteLine(item);
                }
    
                Console.ReadLine();
            }
    Und hier passiert das gleiche. DIe foreach-Schleife gibt einfach nacheinander alle Elemente aus und das wars. (Siehe Schleifen für die Verwendung)

  13. #12
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Switch

    Switch ist eine Art Schalter. Man gibt der Anweisung eine Variable und die Switch-Anweisung sicht deren Wert dann in ihrer Auswahl nach, ob der Wert darin enthalten ist. Wenn ja, werden die dort hinterlegten Anweisungen ausgeführt, wenn nein, kann auch ein Anweisungsblock ausgeführt werden.

    Das ist die Standart-Impelementierung:

    Code:
                switch (Variable)
                {
                    default:
                        {
                            break;
                        }
                }
    Sieht kompliziert aus? Das wird noch mehr, denn "default" ist nur der Name des Blocks, der ausgeführt wird, wenn kein passender Eintrag gefunden wurde.

    Es kommen noch beliebige "case"-Einträge hinein, die dann einen Wert erhalten und auf den Funktionsblock deuten.
    Dies sind die Blöcke, die gesucht werden.
    Es sieht vielleicht kompliziert aus, auch wenn diese Switch-Anweisung größer wird, aber an sich ist es ganz einfach. Man muss einfach nur immer nach dem case suchen und den Wert dahinter betrachten, dann ist das so einfach zu verstehen, wie eine simple Liste ^^


    Ein Beispiel:


    Code:
            static void Main()
            {
                Console.WriteLine("oOo..........Menü..........oOo");
                Console.WriteLine("Wählen sie eine Option:");
                Console.WriteLine("    1   Addition");
                Console.WriteLine("    2   Subtraktion");
                Console.WriteLine("    3   Multiplikation");
                Console.WriteLine("    4   Division");
                Console.WriteLine("    0   Beenden");
                string Eingabe = Console.ReadLine();
    
                switch (Eingabe)
                {
                    case "1":
                        {
                            Console.Clear(); // Diese Zeile löscht den gesammten Inhalt der Konsole
                            Console.WriteLine("Sie haben 'Addition' gewählt."); // Eine neue Zeile in der Konsole, die einen darauf Hinweist, was wir gewählt haben
                            break; // Das "break" hat die Aufgabe, zu verhindern, dass die Sache nach EInträgen vortgesetzt wird. Das muss sein, da jeder EIntrag nur einmal sein kann und die Suche zwangsläufig bei "default", also in diesem Fall der falschen Eingabe landen würde
                        }
                    case "2":
                        {
                            Console.Clear(); // so.
                            Console.WriteLine("Sie haben 'Subtraktion' gewählt."); // so.
                            // Und hier wird dann entweder eine Methode ausgeführt, oder es wird direkt programmiert, was passieren soll
                            break; // so.
                        }
                    case "3":
                        {
                            Console.Clear(); // so.
                            Console.WriteLine("Sie haben 'Multiplikation' gewählt."); // so.
                            // so.
                            break; // so.
                        }
                    case "4":
                        {
                            Console.Clear(); // so.
                            Console.WriteLine("Sie haben 'Division' gewählt."); // so.
                            // so.
                            break; // so.
                        }
                    case "0":
                        {
                            Console.Clear(); // so.
                            Console.WriteLine("Das Programm wird nun beendet."); // so.
                            return; // Da dieser Block das Programm beenden soll, muss die Main-Methode beendet werden. Wie wir bei den Methoden gelernt haben, muss bei dem Rückgabetyp "Void" nur "return;" da stehen und deshalb auch hier
                            // Hier ist kein break von Nöten, da die Methode und damit das Programm ja sowieso beendet wird und die Suche also nicht fort gesetzt wird
                        }
                    default:
                        {
                            Console.Clear(); // so.
                            Console.WriteLine("Die Eingabe ist nicht korrekt. Bitte wählen sie erneut."[/COLOR]); // Das weist darauf hin, dass die Eingabe nicht korrekt ist, da sie nicht in einem der case-Blöcke hinterlegt ist
                            // Die Frage nach der Eingabe wird wiederholt. Wie das passiert kann, kann man mit der Do-While-Schleife lösen, aber das ist uninteressant
                            break; // so.
                        }
                }
            }


    Dieses Beispiel würde ich so oder ähnlich in einerm kleinen Konsolen-Rechner verwenden.
    Es dient zur Menü-Auswahl, da es durch die Eingabe einer Nummer gleich die passende Funktion ausführt.
    WIe ihr gesehen habt, wird ein case-Block so definiert:

    Code:
    case "0": { ... }
    Als erstes das case-Stichwort, dann der mögliche Wert, nach dem gesucht werden soll (muss den Datentyp der Variable im Switch-Kopf haben) und als letztes ein Doppelpunkt. In den darauf folgenden geschweiften Klammern stehen dann die Anweisungen und zum Schluss werden sie von einem break gefolgt, dass den Switch-Block beendet.



    Dieses Switch kann mit jedem konstanten Datentyp verwendet werden.
    Was das bedeutet, wird euch später noch klar ^^

  14. #13
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    Objektorientierte Programmierung OOP

    Bevor ich in dieses schwierige Thema eintauche, ein paar Definitionen, die vielleicht überflüssig klingen, aber hier durchaus helfen können.
    Die habe ich aus meinem Info-Hefter, sind also von der Administratorin eines Gymnasiums formuliert oder zusammen gestellt und abgesegnet worden^^


    Klasse:
    Klassen sind Sammlung von Objekten mit gleichen Eigenschaften (Attributen), gemeinsamer Funktionalität (Methoden) und gemeinsame Beziehungen zu anderen Objekten.

    Objekt:
    Objekte sind allgemein Gegenstand des Interesses, insbesondere einer Beobachtung, Untersuchung oder Messung. Sie können Dinge oder Begriffe sein, sie besitzen bestimmte Eigenschaften und reagieren mit einem definierten Verhalten auf ihre Umgebung. Ihre EIgenschaften werden durch Attributwerte ausgedrückt und das Verhalten durch eine Menge von Methoden beschrieben.

    Attribut:
    Beschreibt die Daten, bzw. Eigenschaften einer Klasse. Alle Objekte einer Klasse besitzen dieselben Atribute, jedoch unterschiedliche Attributwerte.


    Ich denke, was das einzelne ist, wird nicht wirklich klar und das kann es auch erst durch Anwendung wirklich werden, da dieses Thema einige Bereiche bietet und der eigentliche Schwerpunkt von C# als Objektorientierter Sprache ist, aber wer sie nun richtig beherscht, dem stehen, grob gesagt, alle Türen offen, also nehemn wir den Aufwand einfach mal in Kauf^^

    Um das ganze nun mal zu erklären:

    Eine Klasse stellt einige Eigenschaften und Methoden zur Verfügung. Den Eigenschaften können nun Werte zugeordnet werden, sodass ein individuelles Objekt entsteht, welches verwendet werden kann und bestimmte Aufgaben erfüllt.
    Attribute sind die Eigenschaften oder Daten einer Klasse. In einer Klasse kann eine Variable eine Eigenschaft oder ein Datum (Einzahl von Daten) sein, der dann verschiedene Attributwerte zugewiesen werden. Eine Variable ist so ein Attribut, aber eine Variable vom Typ int kann verschiedene Zahlen speichern. Die Variable wird immer das selbe Attribut bleiben, die Werte, die sie annehmen kann, sind dabei die möglichen Attributwerte.

    Ein Objekt ist das eigentlich interessante an dem Ganzen. Es kann eine Klasse mit bestimmten Attributwerten sein und ist das, was eigentlich verarbeitet wird und die Aufgaben erfüllt. Daher kommt auch der Name Objektorientierte Programmierung.
    Wenn ihr z.B. eine Klasse namens "Person" habt und ihr habt zwei Objekte, werden sie als Variablen gespeichert. Das eine Objekt heist z.B. "HeinZ" und ist 19 Jahre alt und das ander Objekt heißt "Lena" und ist 17 Jahre alt.

    Oder eine Klasse "Baum". Es gibt viele Bäume, aber keiner kann mir erzählen, dass irgendwo zwei Bäume existieren, die exakt gleich sind. Aber jeder ist eines: Ein Baum.
    Der eine hat eckige Blätter und einen hohen Stamm, ein anderer ist etwas kleiner und hat runde Blätter, ...
    Es gibt viele Varianten, denn sie alle haben (um es mit Objektorientierter Programmierung zu beschreiben) andere Attributwerte der Klasse Baum. So würde z.B. hin schreiben:
    string Blütenfarbe = "blau";
    Das ist ein Attribut mit dem Attributwert "blau".

    Um das in der Fachsprache auszudrücken: Jeder Baum z.B. in einem einfachen Spiel ist ein Objekt der Baum-Klasse und enthält eine Instanz (Merkt euch den Begriff, den werde ich noch oft benutzen ) von Dieser.



    Die Objektorientierte Programmierung beschäftigt sich also damit, dass Klassen geschickt erstellt werden, dass sie ihre Aufgabe genau erfüllen und keine Fehler zulassen, gleichzeitig aber einfach gestaltet sind.




    In den folgenden Themen, werde ich genauer auf wichtige Bereiche der OOP eingehen.
    Darunter eine EInführung in die Klassen, Vererbung, etc.
    Und in balde werdet ihr auch lernen, was das Wort "static" bedeutet ^^

  15. #14
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    AW: Anleitung: C# lernen

    C# ist ein Klassen aufgeteilt.
    Und eine Klasse kann einen eigenen Datentyp "erstellen".

    Das Prinzip, wie so eine Klasse aufgebaut ist, ist immer das selbe:

    Code:
    // Eine Klasse wird mit dem Wort "class" bestimmt. Dahinter kommt der Name.
    // Wenn eine Klasse public ist, dann kann sie in jedem Namespace verwendet werden, wenn nicht, ist sie nur im aktuellen Namespace zugreifbar.
    public class KlassenName
    {
        // Hier stehen die Attribute in Form von Variablen. Sie sollten "private" sein, damit kein unbefugter Zugriff von Außen möglich ist.
        // Um den Zugriff kontrolliert zu ermöglichen, werden Eigenschaften definiert.
        private DatenTyp _VariablenName; // Ich habe vor jedem Namen einen Unterstrich gesetzt um sie von dem Namen der Eigenschaft zu unterscheiden
        private DatenTyp2 _VariablenName2;
        
        // Das ist der Konstruktor.
        // Zu beachten ist, dass er keinen Rückgabewert besitzt und der Name gleich dem Namen der Klasse sein muss
        // Der Konstruktor sollte auch "public" sein, denn sonst kann man diesen Konstruktor nicht nutzen, um eine neue Instanz der Klasse zu erstellen
        public KlassenName(Datentyp VariablenName /* Hier kommen die Parameter hinein, die der Klasse als aten übergeben werden können. */)
        {
            _VariablenName = VariablenName
            _VariablenName2 = StandartWert;
            // Hier werden die Eigenschaften geschrieben.
            // Entweder erhalten sie einen Standart-Wert, oder sie erhalten sie aus den übergebenen Parametern
        }
        // Es können mehrere Konstruktoren erstellt werden, allerdings müssen sie sich in den Parametern unterscheiden.
    
        
        //Hier landen die Eigenschaften. Sie sollten "public" sein, damit sie genutzt werden können, müssen es aber nicht sein
        public DatenTyp VariablenName // Eine Eigenschaft besitzt keine Parameter
        {
            // Ich habe "VariablenName" ohne Unterstrich genommen, da es die Eigenschaft ist, die den Wert des Attributs "_VariablenName" verarbeitet.
            // Der Datentyp muss auch der selbe sein, wie der zu verarbeiten Variable
            get
            {
                // "get" gibt den Block an, wo steht, wie und welche Variable zurück gegeben werden soll
                return _VariablenName;
            }
            set
            {
                // "set" gibt den Block an, wo steht, wie und welche Variable neu beschrieben wird. "value" steht hirbei für den Wert, der der Eigenschaft neu zugewiesen wird
                _VariablenName = value;
            }
            // Code ist nur in den Blöcken möglich
            // Es müssen nicht beide Blöcke definiert werden, aber es muss mindestens einer vorhanden sein.
        }
        
        
        // Hier kommen die Methoden hin. Sie können "public" oder "private" sein, das liegt im Ermessen des Programmierers
        public RückgabeTypDerMethode NameDerMethode(/* Parameter der Methode */)
        {
            // Code der Methode
            // Die Methoden sind hier genauso aufgebaut, wie wir sie schon kennen
        }
    }
    So wird dann ein neuer Datentyp erschaffen, mit den Methoden, die wir haben wollen und mit den Eigenschaften, die wir haben wollen. Sie tut dann genau das, was wir ihr sagen.

    Die nun folgende Klasse gibt eine kleine Klasse an, die einen Datentyp für Personen bereit stellt.

    Code:
    public class Person
    {
        // Die Attribute, die die Klasse besitzen soll
        private string _Name; // Name einer Person
        private int _Alter; // Alter einer Person
        private string _Wohnort; // Der Wohnort einer Person
        
        public Person(string Name, int Alter, string Wohnort)
        {
            // Alle Attributwerte werden durch die Parameter fest gelegt
            _Name = Name;
            _Alter = Alter;
            _Wohnort = Wohnort;
        }
        
        public string Name
        {
            get { return _Name; }
            // Ich habe keinen "set"-Block, da der Name sich norrmalerweise nicht ändert, also ist er nicht notwendig
        }
        public int Alter
        {
            get { return _Alter; }
            // Auch das ALter ändert sich nicht mal so nebenbei, daher auch hier kein "set"-Block
        }
        public string Wohnort
        {
            get { return _Wohnort; }
            set { _Wohnort = value; }
            // Der Wohnort kann sich auch ändern, da gibt es hier sowohl einen "set"- als auch einen "get"-Block
        }
        
        public void ZähleAlterWeiter()
        {
            // Die Methode ist dafür da, das ALter zu ändern.
            // Sie soll jedes Jahr aufgerufen werden und das Alter erweiten
            _Alter = _Alter + 1;
        }
    }

    Hier kann der Name, das Alter und der Wohnort gespeichert werden und auch wieder geändert werden.

    Was allerdings nicht geändert werden kann, ist der Name, da es eher ungewöhnlich ist, dass der Name geändert wird, daher wird das verboten.
    Außerdem kann man das Alter nicht beliebig ändern, da ja auch in Echt sich das Alter nicht so extrem ändern kann. Stattdessen gibt es eine Methode, das Alter um eins weiter zu zählen, die dann jedes Jahr aufgerufen werden kann.

    Später kann dann auch programmiert werden, dass das Alter sich automatisch anpasst. Man könnte z.B. das Geburtsdatum eintragen lassen und immer, wenn das Alter als Eigenschaft abgerufen wird, dann lassen wir aus dem Geburtsdatum das Alter errechnen.

    Wen die Klasse mehrere Attribute und Eigenschaften dazu erhält, könnte man auch eine Methode bauen, die alle Daten so aus gibt, dass sie als Adresse auf einen Brief gedruckt werden können oder man baut eine Methode, die aus dieser Adresse alle Daten heraus lesen kann und eine Variable vom Typ Person zurück gibt.
    Geändert von Palladin007 (20.04.12 um 12:40 Uhr)

  16. #15
    assimiliert Avatar von Palladin007
    Registriert seit
    19.08.11
    Ort
    NRW
    Beiträge
    2.244

    static

    Das Schlüsselwort "static" begleitet uns schon von Anfang an und das hat auch einen guten Grund.
    Es spielt nämlich eine große Rolle in den Klassen und der objektorientierten Programmierung.

    Wenn ein Attribut einer Klasse static ist, dann ist sie in jeder Instanz dieser Klasse genau gleich.
    Außerdem muss man keine neue Instanz deiner Klasse erstellen, um eine statische Variable ab rufen zu können.
    Allerdings können solche Attribute nicht von einer aktiven Instanz einer Klasse verändert werden.

    Bei den Methoden ist es das selbe. Eine instanzierte Variable kann diese Methode nicht aufrufen, aber wenn man einfach nur die Klasse und dadurch dann die Methode aufruft, ohne eine Instanz der Klasse, geht es wieder.
    Wenn wir vorher Methoden hatten, die alle static waren, dann hat das den Grund, dass unser erstes Programm kein Instanz von etwas war. Die ganze Klasse ist static gewesen.
    Wenn ihr eine Klasse erstellt, dann dürft ihr die Attribute, Eigenschaften und Methoden nicht static machen, da ihr sonst mit dem daraus entsthenden Variablentyp die statischen Objekte nicht verwenden könnt.

    Wenn sie nicht static ist, dann könnt ihr z.B. 5 Variablen des neuen Typs erstellen und alle können einen anderen Attributwert in dem selben Attribut speichern, denn diese Attribute sind dann nicht in der Klasse hinterlegt, sondern in der erstellten Variable, die nur das Muster, wie die Werte gespeichert werden können und was sie kann, von der Klasse vorgegeben bekommt.
    Wenn ihr Werte in der Klasse, ohne eine Variable, die eine Instanz benötigt, abrufen wollt, dann müsst ihr sie static machen und dann gelten sie für alle Instanzen gleich und lassen sich auch nicht ändern, außer die Methode ist selber static.



    oOo..........Ich werde noch passende Beispiele dazu erstellen, aber erst heute Nachmittag bis Abend..........oOo

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. Kommandozeile VI lernen?
    Von mogtar im Forum Alles rund um Linux
    Antworten: 4
    Letzter Beitrag: 01.03.09, 14:17
  2. Flash lernen
    Von Bogart im Forum Programmierung & Webdesign
    Antworten: 4
    Letzter Beitrag: 18.08.05, 12:20
  3. Schwäbisch lernen?!
    Von Gate_Au im Forum Comedy & Spiele
    Antworten: 1
    Letzter Beitrag: 11.07.03, 17:35
  4. Internet lernen
    Von BöhseKleene im Forum Hot Links
    Antworten: 2
    Letzter Beitrag: 05.03.03, 08:47

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •