C# - Einsteigertutorial

  • Heyho, bin mal wieder ein bisschen aktiv hier im Forum.
    Mir ist gerade ein wenig langweilig, also dachte ich mir, ich teil mal ein bisschen was von meinem Wissen mit euch :)
    Erstmal ein paar Fragen, die ich im Voraus beantworten will. Ich empfehle, das Zeug zu lesen. Ihr wollt
    wahrscheinlich wissen, mit was ihr es zu tun habt, bzw. was gut/schlecht daran ist :)


    Was ist C#?
    C# (gesprochen Si Scharp) ist eine Programmiersprache basierend auf dem .NET Framework von Microsoft (wahrscheinlich habt ihr schon
    mal davon in zusammenhang mit VB.NET gehört. Kein Wunder, VB.NET basiert nämlich auch darauf. Genau das
    ist auch der Grund, warum man (mit einem kleinen Zucken) sagen kann, dass C# in etwa gleich mächtig ist wie VB.NET)


    Warum gerade C#?
    Ich höre oft, dass Visual Basic (VB.NET) als Einsteigersprache empfohlen wird. Hat ja dieses "Basic", also "einfach" im
    Namen. Konnte der Aussage noch nie was ab, ich widersprech dem völlig. (Meiner Meinung nach ist die Syntax von
    VB nicht wirklich prickelnd, einfach schon gar nicht)
    C# hat eine (für eine Programmiersprache) sehr einfache Syntax (eine Syntax ist die Art und Schreibweise einer
    Script- oder Programmiersprache, quasi die Grammatik). Wenn man Englisch kann, kann man schon die halbe Sprache
    (übertrieben gesagt) :)
    Außerdem wird C# von sehr vielen Benutzern verwendet, die bei Problemen in Foren gepostet haben. Solltet ihr euch
    also gerade die Haare rausreißen, während ihr etwas nicht hinbekommt, so empfehle ich euch, mal nach der Fehlermeldung
    bzw. eurem Problem zu googlen :)
    Mit C# habt ihr sehr schnell Ergebnisse, es dauert (imho) nicht allzulange, die Grundlagen zu verstehen. Mit Windows Forms
    oder WPF (Windows Presentation Foundation) habt ihr außerdem die Möglichkeit, einfach und schnell durch einfache Klicks
    ansprechende, grafische Programmche zu machen! Nicht nur Desktop-Anwendungen, sondern auch Webapplikationen
    (also sprich "Webseiten mit Code im Hintergrund") könnt ihr machen!
    Nicht zu vergessen die Tatsache, dass C# von immer mehr Firmen benutzt wird. Wer also vielleicht später was damit vorhat,
    kann sicher sein, dass es da draußen immer jemanden gibt, der einen C#-Programmierer sucht :)


    Das hört sich ja göttlich an, gibt es denn überhaupt keine Nachteile an C#?
    Nichts ist perfekt, auch C# nicht. So ist dieses nicht plattformunabhängig und läuft "nur unter Windows". Deshalb in
    Anführungszeichen, weil es bereits schon eine recht gelungene Portierung für Mac/Linux gibt. Wenn ihr Mac/Linux
    verwendet, könnt ihr - anstatt Visual C# 2010 Express, das ich hier im Tutorial verwende - MonoDevelop benutzen,
    das C# auch dort unterstützt.
    Außerdem ist C# zwar recht performant, aber gegen bspw. C++ verliert sie knapp. Wenn euch dieser winzig kleine
    Unterschied nix ausmacht, seid hier hier genau richtig :)




    Genug geredet, auf geht's!


    Die Entwicklungsumgebung ist das Programm, in dem ihr eure Programme programmiert!
    Für C# finde ich das einzig wahre "Visual C# 2010 Express", zu finden auf der Microsoft Seite hier:
    http://www.microsoft.com/germa…ess/download/default.aspx


    Wenn ihr es gedownloadet und installiert habt, kann es losgehen!
    Startet als erstes Visual C# 2010 Express, das kann das erste Mal ein bisschen dauern, weil viel eingerichtet werden muss.


    In Visual C# sind die Programme, die ihr macht, Projekte. Ihr könnt auch eine Projektmappe erstellen, in der dann
    mehrere Projekte (Programme) sind. Nützlich z.B. bei einer Anwendung mit Client und Server, da habt ihr beides im Blick!
    Also erstellen wir erstmal ein Projekt!
    Das bewerkstelligt ihr am bestem mit dem "Neues Projekt erstellen..." Link auf der Startseite, oder über Datei -> Neues Projekt





    Wir fangen erstmal in der Konsole an, also wählen wir als Projekttyp C# -> Windows -> Konsolenanwendung, benennen sie, wie
    es uns passt und drücken auf OK.



    Ihr solltet jetzt ein Codefenster mit Code vor euch haben, den Visual C# für euch schon vorbereitet hat:



    Das Interface ist recht gut eingeteilt (die Toolbox links könnt ihr schließen, wie auf dem Bild gezeigt. Die brauchen wir jetzt noch nicht). Bei 1 seht ihr die aktuelle Datei (meist Codedateien), die ihr bearbeitet. 2 ist der Projektmappen – Explorer, in dem ihr euer Projekt verwalten und zugehörige Codedateien, etc. öffnen könnt.
    Bei 3 habe ich momentan die Ausgabe (Konsole) aktiviert, ihr solltet hier aber auf Fehlerliste umstellen. Visual Studio zeigt euch hier immer Fehler und Warnungen an, komplett auf Deutsch, mit Zeilennummern und allem Drum und Dran!
    Jetzt stellen wir erstmal Zeilennummern ein, die sind eigentlich essentiell. Keine Ahnung, warum Visual Studio die nicht schon von Anfang an aktiviert hat. Dazu geht ihr auf Extras -> Optionen…
    Dort aktiviert ihr alle Einstellungen, geht auf Alle Sprachen und setzt das Häkchen bei „Zeilennummern“:



    Jetzt werden erstmal der Aufbau und die Grundelemente von C# erklärt.
    Vielleicht wäre es nicht schlecht euch an dieser Stelle mitzuteilen, dass C# eine sogenannte "objektorientierte Sprache" ist.
    Das heißt, ihr könnt euer Programm in mehrere Module aufteilen. Wie das funktioniert, folgt ein bisschen später.


    Kommentare


    Um das Tutorial gut mitverfolgen zu können und euch auch Notizen innerhalb eures Codes zu machen, erkläre ich euch, wie
    ihr Kommentare in euren Code einfügt.
    Ein Kommentar ist Text innerhalb eines Codefiles, das vom Compiler ignoriert wird, also später nicht zu eurem Programm
    gehört. Es ist euch völlig selbst überlassen, eure Codes zu kommentieren. Ich rate aber dazu, da man später immer wieder
    weiß, was man da gemacht hat!


    Code
    1. // Ich bin ein einzeiliger Kommentar, ich gelte nur für diese Zeile
    2. /* Ich bin ein mehrzeiliger Kommentar, ich
    3. kann auch über mehrere Zeilen gehen,
    4. bis ich abgeschlossen werde durch */


    Statements


    Kommen wir zu den Statements, also Anweisungen. Damit sagt ihr eurem Programm, was es an dieser Stelle
    machen soll.
    Ihr solltet bei allem, was jetzt kommt, stehts beachten, dass C# case-sensitive ist. Das heißt nichts anderes als dass ihr Groß- bzw.
    Kleinschreibung beachten müsst!


    Statements bilden einen Codeblock, sie müssen innerhalb von zwei geschwungenen Klammern { und } geschrieben werden.
    Deshalb werden wir unsere Statements jetzt zwischen die geschwungenen Klammern von Main schreiben.
    Main ist der Einspringpunkt eines jeden Programmes.
    Einfach nach dem { eine neue Zeile einfügen und brav weiterlesen :)


    Variablen


    Das wohl einfachste Beispiel zu einem Statement wäre
    int meineZahl;
    Wichtig ist, dass nach jedem Statement ein Semikolon ; folgen muss, nicht vergessen!
    Aber was habe ich hier eigentlich gemacht? Eine Variable definiert! Das heißt einen Platzhalter für einen Wert erstellt,
    der später da reinkommen kann!
    Ich kann meineZahl jetzt jeden Wert geben, den ich will (natürlich gibt es hier Grenzen), jedoch keine Kommazahl!
    Das bewerkstelligen wir mit
    meineZahl = 123;


    Nicht so schwer, oder? Jetzt hat meineZahl den Wert 123 bekommen. Und wieder Semikolon um das Statement zu beenden.
    Das Ganze geht auch in einer Zeile:
    int meineZahl = 123;


    Warum aber eine Ganzzahl, und kein anderer Wert? Das liegt daran, dass wir die Variable als int (Integer) definiert haben, was eine
    Ganzzahl darstellt. Wenn ihr eine Variable definiert, reserviert ihr auch in eurem Arbeitsspeicher genug Platz für den größtmöglichen
    Wert, der in sie reinpasst. Bei einem int wären das übrigens 4 Byte. Diese Speicherreservierung ist auch der Grund, warum keine
    anderen Datentypen reinpassen, ihr könnt ja nicht mehr in sie reinstopfen, als Platz dafür gemacht worden ist ;)
    Daneben gibt es noch viele andere Datentypen:

    • int - Ganzzahl
    • string - Text
    • bool - kann nur true oder false (also wahr oder falsch sein)
    • float - Kommazahl
    • double - auch eine Kommazahl, aber mit mehr Kommastellen

    Es gibt natürlich noch mehr, aber das sind für den Anfang die wichtigsten.
    Vielleicht mal zu jedem ein Beispiel:

    Code
    1. int meineZahl = 123;
    2. string meinText = "Hallo Welt"; // Text (strings) kommen immer zwischen zwei Anführungszeichen
    3. bool meinBool = true; // das ist kein Text, sondern der Wert true
    4. float meineZahl = 123.123
    5. float meineZahl = 123.1234566789


    Beachtet, dass Variablennamen einzigartig innerhalb des Codeblocks sein müssen, in dem sie definiert werden.
    Mit anderen Worten: wenn ihr diesen Block kopiert, wird das nicht funktionieren, weil 3 mal eine Variable namens
    meineZahl definiert werden soll -> geht nicht!
    Wichtig bei Variablennamen ist: sie müssen mit einem Buchstaben anfangen!
    Seht einfach dazu, dass ihr eure Variablen sinnvoll und so aussagekräftig wie möglich benennt, dann kann euch nichts
    passieren.


    Mit Variablen können wir viel anstellen!
    Wir können z.B. mathematische Operationen wie addieren oder subtrahieren auf ihnen ausführen!

    Code
    1. int zahlA = 3;
    2. int zahlB = 5;
    3. int zahlC = zahlA + zahlB;// <--- zahlC hat nach dem Ausführen dieses Statements den Wert 8
    4. string textA = "Hallo";
    5. string textB = textA + " Welt"; // <--- textB hat den Wert "Hallo Welt"


    Das funktioniert aber nur für Variablen mit demselben Datentyp, bzw. für ein paar Ausnahmen (z.B. ein int kann einem float addiert
    werden, die Endvariable, in die das Ergebnis gespeichert wird, muss aber vom Typ float sein!)
    Auch lassen sich Zahlen mit + an Text anhängen (der Datentyp der Variable, in die das Ergebnis gespeichert wird, muss string sein!).


    Ich denke, ihr habt fürs erste genug vom Variablendeklarieren, vielleicht wollt ihr eure Variablen mal ausgeben lassen?
    Fürs erste gebe ich euch den Befehl zum Text-ausgeben, ich erkläre später, was es damit auf sich hat.

    Code
    1. Console.WriteLine("Hier euer Text");
    2. string meinText = "auch das ist Text";
    3. Console.WriteLine(meinText);


    An das Ende eures Codeblocks fügt ihr noch folgende Zeile ein:
    Console.ReadLine();
    Ausführen könnt ihr euer Programm mit der F5-Taste oder über den grünen Play-Button oben in der Leiste.
    Vielleicht spielt ihr euch jetzt am besten noch ein wenig mit den Variablen und mit der Ausgabe. Wenn ihr fertig seid, könnt ihr mit
    dem nächsten Teil weitermachen!
    Hier habt ihr noch ein Beispiel, wie das ganze aussehen könnte:


    Arrays


    Wenn wir schon bei Variablen sind, möchte ich an dieser Stelle gleich noch Arrays erklären.
    Meist werden sie als Art "Schubladen" erklärt. Eine alte und simple, aber doch einfach zu verstehende und auch
    wahre Aussage.
    Also stellt euch unter einem Array ein Kästchen mit mehreren Schubladen darin vor, in die ihr Sachen legen könnt.
    Diese Sachen sind in unserem Fall Variablen.
    Auch Arrays haben einen Datentyp, nämlich den der Variablen, die in die Schubladen reinkommen (immerhin könnt
    ihr in eure Schubladen zu Hause auch nicht mehr reinstopfen, als Platz dafür ist, richtig? Ihr habt ja schon vorher
    bei den Variablen erfahren, dass für diese genausoviel Speicherplatz reserviert wird, wie nötig ist (z.B. int hat 4 Bytes).
    Somit kann auch in ein Element vom Array nicht mehr rein, wie Platz dafür ist!).
    Sehen wir uns mal eine Definition eines solchen Arrays an, für den Anfang vielleicht ein int-Array:

    Code
    1. int[] meinZahlenArray = new int[10]; // Das Array wird 10 Schubladen haben. Es passen ab jetzt genau 10 Elemente und nicht mehr rein!


    Jetzt haben wir ganze 10 Integer auf einmal! Zugreifen kann man auf die einzelnen Elemente mit der eckigen klammer und dem Index
    (der Schubladennummer, wenn man so will):

    Code
    1. meinZahlenArray[0] = 5; // Zu beachten: der Index fängt bei 0 an, das heißt ich kann als Index 0-9 angeben, nicht aber 10!
    2. meinZahlenArray[1] = 10;
    3. meinZahlenArray[2] = 43;
    4. ...
    5. usw.


    Wir werden Arrays später noch oft brauchen, prägt sie euch also ein :)

    Funktionen


    Funktionen, oder auch Methoden genannt, erleichtern uns das Leben erheblich.
    Funktionen sind Codeblöcke, in denen Variablen deklariert oder verändert werden und auch wiederum
    andere Funktionen aufgerufen werden können.

    Main ist eines der besten Beispiele für eine Funktion.
    Wir haben darin Variablen deklariert, verändert und... eine Funktion aufgerufen?
    Ja, wirklich!
    WriteLine() ist auch eine Funktion! (bitte ignoriert für den Moment das Console, das
    vor dem
    WriteLine steht, ich komme dazu später, Ehrenwort
    ;) )
    Auch eine Funktion ist ein Statement, sie braucht einen Semikolon am Ende.
    Funktionen verlangen oft Parameter, die zwischen die () geschrieben werden (z.B. WriteLine verlangt
    als Parameter einen string, den, der nachher ausgegeben werden soll!).
    Wenn die Funktion keine Parameter verlangt, so müsst ihr trotzdem ein Klammerpaar machen (so wie
    bei dem ReadLine()).
    Übrigens: dieses ReadLine war deshalb notwendig, weil das Programm nur solange ausgeführt wird, bis
    alle Statements innerhalb der Main Methode ausgeführt wurden.
    ReadLine ist solange nicht beendet, bis der Benutzer die Enter-Taste drückt!


    Eine weitere wichtige Sache, die es über Funktionen zu wissen gibt ist, dass sie einen Rückgabewert
    besitzen.
    Dieser kann jetzt ein int, string, bool, etc. sein, oder ganz einfach void, also nichts. (WriteLine hat
    z.B. void als Rückgabewert).
    Um euch das ein bisschen besser zu zeigen, hier ein bisschen kommentierter Code:

    Code
    1. string textZahl = "123"; // wir wollen diesen Text als Zahl haben, damit wir damit rechnen können!
    2. int zahl1 = 7; // zahl1 und zahl2 sollen addiert werden
    3. int zahl2; // in diese Variable wollen wir 123 als Zahl bekommen
    4. int ergebnis; // das Ergebnis aus zahl1 + zahl2
    5. zahl2 = Convert.ToInt32(textZahl);//ToInt32 liefert einen Integer als Rückgabewert zurück, das können wir dann in zahl2 speichern!
    6. ergebnis = zahl1 + zahl2;// <- ergebnis: 130


    Ich hoffe, das war verständlich :)
    Übrigens, sobald ihr den . nach Convert macht und zu ToInt32 scrollt und ein bisschen wartet, öffnet sich ein kleiner Popup, in
    dem ihr alle Informationen über die Funktion - Rückgabewert oder was für Parameter die Funktion benötigt - stehen.


    Jetzt wird es aber Zeit für unsere erste, eigene Funktion!
    Da wir jetzt wissen, dass eine Funktion einen Rückgabewert haben muss, müssen wir uns noch einen für unsere eigene aussuchen!
    Für den Anfang ist void ausreichend, denke ich.
    Wir wollen eine Funktion schreiben, die den User zu Beginn des Programms begrüßt und es ihm erklärt.


    Um mit unserer neuen Funktion anzufangen, fügt zuerst eine neue Zeile nach der } derMain-Methode ein. Eine Methode sollte neben/unter
    einer Methode stehen. Logisch, oder?
    Wir wollen eine Funktion ohne Rückgabewert, und sie soll Text ausgeben, am sinnvollsten wäre also für den Anfang:

    Code
    1. void ZeigeBegruessung()
    2. {
    3. }


    Am besten immer gleich die geschwungenen Klammern einfügen, dann vergisst man sie nicht. Zwischen diese kommt jetzt der Code, der
    beim Aufrufen unserer Funktion ausgeführt werden soll!
    Das fällt bei uns ziemlich leicht aus:

    Code
    1. void ZeigeBegruessung()
    2. {
    3. Console.WriteLine("Willkommen in meinem Programm!");
    4. Console.WriteLine("Sie benutzen das Programm folgendermassen:");
    5. Console.WriteLine("") //enthält einen leeren String, macht uns also eine neue Zeile
    6. Console.WriteLine("Hier würde die erklärung stehen. Blöd nur, dass das Programm noch nichts kann!");
    7. Console.WriteLine();
    8. }


    Das wars auch schon, unsere erste, eigene Funktion!
    Diese können wir jetzt einfach in der Main-Funktion aufrufen mit:
    ZeigeBegruessung();


    Ihr seht dann in der Konsole:

    Code
    1. Willkommen in meinem Programm!
    2. Sie benutzen ads Programm folgenermassen:
    3. Hier würde die erklärung stehen. Blöd nur, dass das Programm noch nichts kann!


    Wenn ihr diesen Teil noch nicht verstanden habt, bitte lest ihn nochmals, denn jetzt folgen kompliziertere Funktionen.


    Wie wärs mit einer Funktion, die uns zwei Zahlen addiert und als Rückgabewert das Ergebnis von diesen zurückliefert?
    Als Rückgabetyp wählen wir also int. Auch anders als in unserer ZeigeBegruessung-Funktion ist, dass wir dieses Mal
    Parameter brauchen!

    Code
    1. int AddiereZahl(int zahl1, int zahl2)
    2. {
    3. }


    Wir können jetzt die Variablen zahl1 und zahl2 innerhalb der AddiereZahl Funktion benutzen, aber außerhalb der
    { } sind sie nicht da, das dürft ihr nicht vergessen!
    Wir bestimmen, was innerhalb der Funktion zurückgegeben wird, mit dem Schlüsselwort return.
    return gibt den angegebenen Wert zurück und verlässt die Funktion an dieser Stelle.
    Bei der ZeigeBegruessung Funktion haben wir kein return gebraucht, weil kein Rückgabewert vorhanden war.
    Natürlich hätten wir darin return benutzen können, wenn wir z.B. wollen, dass in einem bestimmten Fall die Funktion
    ein wenig früher verlassen wird. Dazu aber mehr später.


    Visual Studio wird euch aber die AddiereZahl Funktion rot unterstreichen, weil wir noch keinen Rückgabewert
    definiert haben. Programmieren wir die Funktion mal fertig:

    Code
    1. int AddiereZahl(int zahl1, int zahl2)
    2. {
    3. int ergebnis = zahl1 + zahl2;
    4. return ergebnis;
    5. }


    Das Ganze geht noch ein Stück kürzer:

    Code
    1. int AddiereZahl(int zahl1, int zahl2)
    2. {
    3. return zahl1 + zahl2;
    4. }


    In der Main-Funktion können wir die Funktion wie auch schon die ToInt32-Funktion behandeln.
    Ein Beispiel wäre:

    Code
    1. int ergebnis;
    2. int meineZahl = 4;
    3. int andereZahl = 10;
    4. ergebnis = AddiereZahl(meineZahl, andereZahl); // Ergebnis: 14


    Nicht allzu schwer, oder?
    Funktionen sind sehr wichtig, wenn ihr sie nicht ganz verstanden habt, lest euch dieses Kapitel
    bitte nochmals durch. Ansonsten viel Spaß beim Weiterlesen!


    Abfragen


    Ihr werdet früher oder später zu dem Punkt kommen, an dem ihr auch den Status von Variablen abfragen müsst.
    Ist der String, den der User eingegeben hat leer? Ist Zahl1 größer als Zahl2?
    In C# geht das über Abfragen, ein recht einfaches Prinzip. Es wird das Schlüsselwort if benötigt. Hier mal das Grundgerüst:

    Code
    1. if(Bedingung)
    2. {
    3. //Wenn die Bedingung eintrifft, also true ergibt, wird dieser Code ausgeführt
    4. }


    Eine Bedingung ist - ganz klar - ein bool, immerhin kann sie wahr oder falsch sein!


    Ein Beispiel:


    Bedinungen können nicht nur direkte Vergleiche sein, man kann auch überprüfen, ob ein Wert größer bzw. kleiner als ein anderer ist.
    Dazu einfach das == mit einem > bzw. < Zeichen ersetzen.
    Die Bedingung muss aber nicht zwingend in einem bool gespeichert sein, man kann sie der Abfrage auch direkt übergeben:


    Ich dachte, die if-Abfrage erwartet einen bool? Was hat das dann mit ==, < und > zu tun?
    Ganz einfach, Aussagen wie (zahl2 > zahl1) ergeben auch true bzw. false, somit könnt ihr sie auch in
    eine Variable speichern!

    Code
    1. int zahl1 = 5;
    2. int zahl2 = 10;
    3. bool istZahlGroesser = zahl2 > zahl1; // in diesem Fall hat istZahlGroesser den Wert true


    Ganz schön praktisch, oder?


    Es kann euch aber passieren (bzw. es wird eigentlich immer der Falls ein), dass ihr nicht JEDEN einzelnen
    Fall, der eintreten kann, mit einer if Abfragen wollt.
    Sagen wir, ihr wollt eine Zahl abfragen. Wenn sie einen bestimmten Wert hat, soll ein Codeblock ausgeführt
    werden. Wenn aber nicht, ein anderer. Wäre ein bisschen doof, für alle anderen möglichen Zahlen außer
    dieser ein if zu schreiben, was?
    Dazu gibt es else. Wie der Name schon sagt, tritt dieser Fall ein, wenn die Bedingung der if-Abfrage darüber
    nicht eingetroffen ist.
    Ohne viel Gerede am besten mal ein Beispiel dazu:


    Recht simpel, nicht?


    Ein weiteres Problem tritt jetzt auf, wenn mehrere Fälle als zwei möglich sind. Dafür gibt es
    else if. Erst wieder Code:


    Beachtet hier, dass wenn das erste if eintrifft, die anderen else if nicht mehr abgefragt, sondern übersprungen werden.


    Das wars erstmal mit Abfragen. Wenn ihr das verstanden habt, können wir mit etwas fortgeschrittenerem Zeugs anfangen.


    Schleifen


    Irgendwann kommt ein Zeitpunkt, an dem es euch nicht mehr ausreicht, nur eine Liste von Anweisungen durchzuführen, sondern
    Dinge mehrmals ausführen müsst, nämlich in einer Schleife.
    Schleifen funktionieren ähnlich wie if-Abfragen, sie verlangen eine Bedingung (einen bool) als Parameter. Sie werden dann
    solange ausgeführt, bis die Bedingung im sogenannten Schleifenkopf false ist.


    Wir fangen mit der sogenannten while-Schleife an. Das Grundgerüst für diese sieht so aus:

    Code
    1. while(Bedingung)
    2. {
    3. //Anweisung/en
    4. }


    Als Bedingung kommt wie schon bei der if-Abfrage alles in Frage, das einem bool
    entspricht. Bedenkt, dass wenn die Bedingung beim Einstieg in die Schleife schon false ist, sie auch gar nicht erst
    betreten/ausgeführt wird!
    Ein Beispiel:


    Weiteres gibt es zu dieser Schleifenart nicht zu sagen. Ihr könnt euch mit dieser Schleife z.B. ein Menü für euer Konsolenprogramm
    basteln. Das geht ganz einfach! Ihr packt euren Programmcode in eine while-Schleife,
    die von einer bool-Variable abhängig ist. So werdet ihr immer an den Anfang eurer
    Schleife katapultiert (vielleicht die Ausgabe eures Menüs?), bis ihr irgendwann im Code die Variable auf false
    setzt, somit wird die Schleife verlassen und das Programm beendet. So erspart ihr euch auch das Console.ReadLine()!


    Das könnte z.B. so aussehen (innerhalb der Main):


    Weiter gehts mit den for-Schleifen. Diese sind die wohl komplexesten Schleifen, zumindest was den
    Schleifenkopf angeht. Im Gegensatz zur while-Schleife verlangt der Schleifenkopf hier ganze
    3 Bedingungen (das stimmt jetzt so nicht ganz, weil man die letzte Bedinung wenn nötig weglassen kann, dazu aber später mehr).
    Die erste ist eine Variablendefinition, wie wir sie schon kennen. Die zweite - wie schon vorhin - die Abbruchbedingung der Schleife.
    Die dritte und letzte Bedingung dient zum Inkrementieren/Dekrementieren der sogenannten Zählervariable (die wir in der ersten Bedingung definiert haben).
    Damit das Ganze nicht allzu sehr verwirrt, hier lieber erstmal der Code einer handelsüblichen for-Schleife:

    Code
    1. for(int i = 0; i < 10; i++)
    2. {
    3. //Anweisung/en
    4. }


    Im ersten Teil definieren wir eine Integer-Variable (sie wird eigentlich immer i getauft) und setzen sie auf 0. Im zweiten definieren wir die Bedingung der Schleife.
    Solange i also kleiner als 10 ist, soll die Schleife ausgeführt werden. Und im dritten Teil - und das ist jetzt das eigentlich Neue - legen wir fest, dass i nach jedem
    Schleifendurchgang um 1 erhöht werden soll (variable++; erhöht den Variablenwert um 1, das ist ein ganz normales Statement).
    Das ist wohl eine der praktischsten Schleifen. Vielleicht mal ein Beispiel für die Spieleprogrammierung: Stellt euch vor, ihr habt eine Highscore und müsst die
    ganzen Spieler mit ihren Punkten ausgeben. Das könnt ihr natürlich nicht statisch machen! Dank einer for-Schleife
    lässt sich das ganze aber einrichten:

    Code
    1. string[] namen = new string[] { "Max", "Paul", "Harald", "Lukas" };
    2. int[] punkte = new int[] { 10, 4, 5, 9, 2 };
    3. Console.WriteLine("Highscore:");
    4. Console.WriteLine(""); //Leerzeile
    5. for(int i = 0; i < namen.Length; i++) //.Length ist die Länge des Arrays
    6. {
    7. Console.WriteLine(namen[i] + " " + punkte[i] + " Punkte"); //Bei jedem Schleifendurchgang wird i um 1 erhöht, das heißt, das Array wird komplett durchgegangen!
    8. }


    Am besten, ihr probiert den Code aus, so versteht ihr die Arbeitsweise der Schleife am besten!





    Im nächsten Teil werden wir uns der grafischen Programmierung mit Fenstern widmen!


    Bis dahin wünsche ich euch viel Spaß mit diesem Teil des Tutorials.
    Greetz


    PS: @Mods/Administration: Wäre es möglich für den Code-Tag Farb-Formatierung zu aktivieren? Ich hätte meinen Code farbig unterlegt, aber der [code]-Tag entfernt die Farben automatisch...

  • Hi, habe mir mal den Anfang angeschaut.
    Was mir sofort aufgefallen ist, ist die kürze, was bedeutet, dass viele Dinge fehlen müssen, die sicher wichtig sind.


    Du gehst sofort auf irgendeinen Code ein und erklärst ihn so, als würde man Syntax und Semantik schon kennen. Für Einsteiger sehe ich das dann nicht mehr so passend. Ich hätte zuerst mit grundlegenderen Dingen angefangen, egal, welchen Sinn das Programm hätte.
    Z.B. hättest du die Main-Methode gar nicht so ausführlich erklären brauchen, weil es für Anfänger eh unverständlich wäre.


    Ich hätte zuerst mit den einfachstens Grundlagen unabhängig von OOP begonnen und das danach erst erklärt, um später keine tausend Lücken einbauen zu müssen.


    Ich würde einfach mal vorschlagen, dass du dir die Zeit nimmst, das Tutorial richtig zu strukturieren und zu überlegen, wie ein Anfänger in dem Bereich das Verständnis am besten entwickeln kann.



    Zitat

    Von Zeile 1-4 seht ihr die using-Statements, dort werden die Bibliotheken eingebunden, die ihr in dieser Codedatei zum Programmieren benutzen wollt!

    Am besten noch mal nachschlagen, was using bewirkt und Namespaces passend dazu ;)

  • So, ein paar Fehler haben sich eingeschlichen...

    Zitat

    C# (gesprochen Si Scharp oder auch Cis) ist eine Programmiersprache basierend auf dem .NET Framework von Microsoft (wahrscheinlich habt ihr schon mal davon in zusammenhang mit VB.NET gehört. Kein Wunder, VB.NET basiert nämlich auch darauf. Genau das
    ist auch der Grund, warum man (mit einem kleinen Zucken) sagen kann, dass C# in etwa gleich mächtig ist wie VB.NET)



    Zitat

    Ich höre oft, dass Visual Basic (VB.NET) als Einsteigersprache empfohlen wird. Hat ja dieses "Basic", also "einfach" im
    Namen. Konnte der Aussage noch nie was ab, ich widersprech dem völlig. (Meiner Meinung nach ist die Syntax von
    VB nicht wirklich prickelnd, einfach schon gar nicht)
    C# hat eine (für eine Programmiersprache) sehr einfache Syntax (eine Syntax ist die Art und Schreibweise einer
    Script- oder Programmiersprache, quasi die Grammatik). Wenn man Englisch kann, kann man schon die halbe Sprache
    (übertrieben gesagt)


    VB wird empfohlen, da man mit Englisch dort wirklich die halbe Sprache kann. C# ist wesentlich abstrakter und kann Neulinge durch das ganze geklammere und die ";" abschrecken/verwirren (find ich zwar nicht, ich hab aber auch vor C#, Java und VB C++ gelernt, also das richtige und nicht den .net "Schrott")


    Zitat

    Mit C# habt ihr sehr schnell Ergebnisse, es dauert (imho) nicht allzulange, die Grundlagen zu verstehen. Mit Windows Forms
    oder WPF (Windows Presentation Foundation) habt ihr außerdem die Möglichkeit, einfach und schnell durch einfache Klicks
    ansprechende, grafische Programmche zu machen! Nicht nur Desktop-Anwendungen, sondern auch Webapplikationen
    (also sprich "Webseiten mit Code im Hintergrund") könnt ihr machen!
    Nicht zu vergessen die Tatsache, dass C# von immer mehr Firmen benutzt wird. Wer also vielleicht später was damit vorhat,
    kann sicher sein, dass es da draußen immer jemanden gibt, der einen C#-Programmierer sucht


    Genau so schnell gibt es auch in VB oder VC++ Ergebnisse. Wenn man einfach die GUI mit ein paar Klicks auf bauen kann wird einem einfach viel arbeit abgenommen.
    Auch ist C# nicht die einzige Sprache die gesucht wird. Je nach dem wo man Arbeiten will werden auch Sprachen wie PHP, HTML, CSS, JS (Webdevelopment) und C++ (Gamedevelopment) benötigt (in den letzten Jahren wurden aber auch andere Sprachen in diesem Zusammenhang und vorgefertigten Programmen (diese sind dann aber meist in c++ geschrieben) zur Spieleentwicklung populär.), auch Java wird oft verwendet.


    So, den Rest hab ich nur mal überflogen, falls es da Fehler geben sollte, wird sicherlich Krissel095 sich melden.
    Nur noch eine Kleinigkeit zur Performance: bei (V)C# und VC++ sollte sie eigentlich identisch sein (eigentlich auch VB, aber das lasse ich jetzt mal weg, da du es auch nicht erwähnt hast) da nach dem Compilieren relativ identische Anwendungen (bytetechnisch) herrauskommen sollte. Alle Unterschiede die entstehen, entstehen durch den Compiler, da im Endeffeckt beides fürs .net-Framework ist. "native" C++ ist hingegen schneller (Zahlen hab ich jetzt leider nicht), da dort schon mal kein Framework zwischen die Anwendung und den Prozessor geschaltet ist.

    Users[4939].postCount++;


    • Weltherrschafts AG in Cooperation mit Weltuntergangs GmbH:
      "Wir sorgen dafür, dass sie sich keine Sorgen um Morgen machen müssen!"
  • Counterbug : danke für die Info, sollte das vielleicht noch ein wenig anfängerfreundlicher machen... Was schlägst du denn vor, noch länger zu erklären vor dem Code?
    Zu dem using: ja, ich weiß, dass das so nicht wirklich stimmt. Aber für einen Anfänger using zu erklären bräuchte erstmal ein wenig fortgeschritteneres Wissen^^ Vielleicht formulier ich es so um: "mit den usings am Anfang könnt ihr euch die Arbeit jedes mal System. zu schreiben ersparen". So ist das nicht falsch und man wird nicht mit unnötigem Wissen vollgestopft, das man überhaupt noch nicht braucht, oder soll ich neben der Direktive auch noch die Anweisung erklären? ;)


    Edit: hab grad auf Wikipedia nachgesehen und auch gegoogelt, eine "Cis" Aussprache konnt ich nirgends finden, zumindest nicht für C# :P


    prime : von der "Cis"-Aussprache hab ich noch nie gehört, aber danke für den Tipp^^
    Also in VB werden dafür Abkürzungen wie "Dim" verwendet, C# hat in der Regel die Methoden ausgeschrieben (und ich sagte auch "meiner Meinung nach"). Von daher find ich C# eig. einfacher.
    Klar hat man in den anderen genannten Sprachen schnell Ergebnisse, deswegen kann es doch hier trotzem als Pro gelten ;)
    Auch das mit der Verbreitung ist einer der Vorteile (.NET Programmierer werden immer mehr gesucht).
    Java ist extrem langsam, davon würd ich abraten :P

  • Zitat

    Counterbug : danke für die Info, sollte das vielleicht noch ein wenig anfängerfreundlicher machen... Was schlägst du denn vor, noch länger zu erklären vor dem Code?

    Zuerst solltest du überhaupt erklären, worauf man beim schreiben von verschiedenen Dingen achten muss.
    Warum stehen da zB. die Klammern () und {}, das hast du völlig ausgelassen und ist wichtig. Basics werden halt ausgelassen. Dann könntest du damit beginnen, eigene einfache Prozeduren zu schreiben, um das Verständnis von Methoden zu verdeutlichen und wie sie wiederum benutzt werden. Hello World ist überhaupt nicht anfängerfreundlich, weil man daran nichts erklären kann, was zuerst erklärt werden muss. Und wie gesagt, gehe danach auf OOP ein, sonst verstehen Anfänger nicht, was du hier zu erklären versuchst.


    Zitat

    Zu dem using: ja, ich weiß, dass das so nicht wirklich stimmt. Aber für einen Anfänger using zu erklären bräuchte erstmal ein wenig fortgeschritteneres Wissen^^

    Und deshalb willst du jemanden etwas völlig falsches beibringen? Wie dumm ist das denn. Erklär es einfach gar nicht, sondern warte, bis du Namespaces erklärt hast.


    Zitat

    Vielleicht formulier ich es so um: "mit den usings am Anfang könnt ihr euch die Arbeit jedes mal System. zu schreiben ersparen"

    Die Beschreibung bringt es auch nicht, weil sie nicht beschreibt, was sie wirklich tut. S.O.


    Zitat

    Java ist extrem langsam, davon würd ich abraten :P

    Vorurteil.

  • 1. Ok, ich überarbeit es mal, danke für die Tipps :)
    2. so ganz falsch ist die Info auch nicht, aber ich habs jetzt eh ausgebessert und (hoffentlich verständlich) erklärt.
    3. siehe 2.
    4. nicht Vorurteil, Tatsache^^ Ich arbeite auch hin und wieder in Java und nicht nur die Sprache selbst, sondern auch IDEs wie eclipse oder Mono sind extrem langsam oO
    sagen wir einfach mal... ich weiß, warum ich sage, dass es langsam ist ;)


    Schau morgen nochmal rein, hoffe es is dann anfängerfreundlich genug xP

  • Java ist langsam. Das liegt u.A. daran, dass die Laufzeitumgebung erstmal geladen werden muss (bei den meisten läuft Java nicht 24-7 im Hintergrund, es sei denn, sie laden mit JDownloader oder Vuze :P).
    Außerdem ist Java sehr ressourcenhungrig, das kannst du nicht abstreiten ^^ (Schau mal auf deinen Arbeitsspeicherverbrauch, wenn du Vuze oder JDownloaer offen hast ;) )
    Java verzichtet halt bewusst auf Sachen wie optimierten Datenzugriff. Das Ganze kommt dann (angeblich) Sicherheit und Komfort zugute.
    C# ist allein schon deshalb schneller, weil ein recht großer Teil der dll's, die C# verwendet, schon im Speicher beim Start von Windows mitgeladen wird.


    Edit: @Krissel: Ich sag ja nicht, dass Java überirdisch langsam ist^^ Aber es gibt halt nen Grund, warum die meisten Spieleentwickler eben zu C++ greifen (auch wenn das teilweise an DirectX liegt).
    PS: auf deine Kritik freue ich mich am meisten :P

  • Krissel095
    Dann versuche aber bitte niemals eine Kugel zu rendern ^^
    Je nach 3D-Engine tötet alles und daher ist Minecraft auch nur mit Würfeln und Flechen aufgebaut.


    @Java
    Es kommt einfach auf die Aufgaben an, die man lösen möchte. In manchen ist .net schneller in manchen Java. (ok, in einigen ist .net Schneller, das ligt imo aber auch daran, das .net für Windoof optimiert ist und Java unter zig Betriebssystemen läuft.)


    @IDE
    Die IDEs sind langsamer, da sie auch auf Java basieren (zumindest Eclipse, wie es mit Mono aussieht weiß ist nicht) und wie oben gesagt manche Abläufe in Java langsamer sind als in .net (von anderen Sprachen ohne Framework oä ganz zu schweigen und es gibt alternativen ohne Java, die auch ohne Framework laufen und daher wirklich um einiges schneller sind).


    speed
    Wenn es dir so um Geschwindigkeit geht: lern ASM.


    @edit
    Nunja verschiebt nur den Start der Umgebung von einer Verzögerung im Windoof start in den Programmstart was sogar meines erachtens besser ist. Auch ligt die "Verschwendung" von den Resourcen bei dem JDownloader an den zip Threads und der GUI.
    Zum Verbrauch von Resourcen gibt es aber auch das perfekte Gegenbeispiel: Firefox, das ist nicht in Java geschrieben und schluckt einige male mehr RAM als der JDownloader.


    @edit:c++
    wie schon gesagt ist dass das "native" C++ das ganz ohne Frameworks oä auskommt und natürlich schneller ist .

    Users[4939].postCount++;


    • Weltherrschafts AG in Cooperation mit Weltuntergangs GmbH:
      "Wir sorgen dafür, dass sie sich keine Sorgen um Morgen machen müssen!"
  • Genauso, wie Java in einigen Bereichen langsam ist, ist es in anderen auch viel schneller. Davon weißt du scheinbar nicht.
    Für den RAM-Verbrauch gibt es die Garbage-Collection, die schnell abläuft.


    Zitat

    Java ist langsam. Das liegt u.A. daran, dass die Laufzeitumgebung erstmal geladen werden muss (bei den meisten läuft Java nicht 24-7 im Hintergrund, es sei denn, sie laden mit JDownloader oder Vuze :P).

    Mir ist es lieber, wenn es nicht läuft, bis ich es brauche, das ist unnötige Leistung, die mir woanders fehlt.


    Zitat

    Java verzichtet halt bewusst auf Sachen wie optimierten Datenzugriff. Das Ganze kommt dann (angeblich) Sicherheit und Komfort zugute.

    Ob Java nicht-optimal arbeitet, sei mal dahingestellt. Das (angeblich) kannst du aber weglassen.



    Übrigens, Java's Multi-Threading ist ziemlich effizient und angeblich sogar fehlerfreier als das Komplexe von C.


    ABer gehen wir nicht länger auf Java ein, die Gegenargumente wurden dir ja genannt und das passt nicht zum Thema.

  • prime : auf ASM hab ich aber keine Lust :D
    zu Firefox: das hat auch n riesen-Interface und viel mehr Funktionen. Allein die ganzen Tabs, die im Hintergrund "laufen". JDownloader hat 4 Tabs (weiß nicht genau aus dem Kopf).


    Counterbug : ich sage ja nicht, dass Java der allerletzte Dreck ist und ich sie nie verwenden würde (Ich hatte vorher gesagt, dass ich auch teilweise mit Java arbeite, z.B. für Android-Apps, die ich für mich selbst schreibe)
    Also ich habe gern 32MB mehr im RAM und hab dafür zig Bibliotheken sofort auf Abruf bereit (wie viel ist 32MB heutzutage schon, bei den RAM-Sticks heutzutage...) :)
    Ich weiß nicht, wie die Garbage-Collection in Java abläuft (ich weiß, dass man sie in C++ selbst erledigen muss, in C# wird sie vom GC erledigt, etc.), aber sie scheint nicht wirklich gut zu laufen.
    Warum zum Teufel braucht mein Vuze dann immer mindestens 300-400MB im RAM? (Vielleicht liegt das auch an der GUI, damit hat Java nicht wirklich was zu tun, sondern die Bibliotheken, die sie dafür verwendet haben...)
    Das "angeblich" war gemeint als "ich hab gelesen, dass das daran liegt, dass es Komfort und Sicherheit zugute kommt".
    Ich würde Java für etwas verwenden, das ich plattformunabhängig brauch. Für große Spiele würd ich C++ verwenden. Für Applikationen, bei denen ich weiß, dass sie "nur" auf Windows laufen müssen, nehm ich halt C#.
    In diesem Sinne Java schlecht machen wollte ich nicht. Die einzige Sprache, die ich überhaupt nicht abkann, ist VB.NET. Ach, und Prolog (das musst du dir mal ansehen, wenn du was sinnloses sehen willst :) )


    Edit: Okay, aber jetzt bitte BTT^^

  • Ja, es gibt dafür Bibliotheken, aber man kann die GUI auch selber coden und das schluckt dann nunmal RAM. Vuze kenn ich nicht, aber bei JDownloader ist alles selber gecodet oder wird über Themes eingestellt. Siehst du schon daran, das wenn du das Fenster minimierst/ausblendest einiges von der RAM und de Prozessor wieder freigegeben wird. (RAM lastig war bei mir der JDownloader noch nie, nur prozessorlastig aber man muss ihn ja nicht immer offen haben, minimieren oä sollte reichen.)


    Ja, aber das wars jetzt dann auch damit. ^^
    wie Flibber100 reineditiert hat:
    Back 2 Topic
    Rest per PN oder in nem neuen Thread

    Users[4939].postCount++;


    • Weltherrschafts AG in Cooperation mit Weltuntergangs GmbH:
      "Wir sorgen dafür, dass sie sich keine Sorgen um Morgen machen müssen!"
  • Zitat

    Wichtig bei Variablennamen ist: sie müssen mit einem Buchstaben anfangen!


    Naja, das stimmt nicht so ganz. Variablen dürfen nur nicht mit Zahlen beginnen, ansonsten kannst du auch erlaubte Sonderzeichen, wie z.B. "_" an den Anfang setzen:


    Code
    1. int _meineVariable;


    Btw:

    Zitat

    int[] punkte = new string[] { 10, 4, 5, 9, 2 };


    Waargh ._.


    Ansonsten finde ich das Tutorial gut gelungen, für Anfänger gut verständlich ;) Allerdings werden viele mit deinen Variablen nicht zurechtkommen, da in C# standarmäßig Option Strict aktiviert ist und somit sowas wie

    Code
    1. int a = 5;
    2. Console.WriteLine(a);


    zu Compilerfehlern führt. Wäre vllt. noch ganz nett, wenn du erklärst, dass Datentypen implizit konvertiert werden müssen ;)


    MfG

  • Aah, endlich jemand mit Kritik :-)


    Zu 1. Stimmt, ganz vergessen, mein Fehler. Danke xP


    2. Ja ich weiß, aber da du Arrays meistens sowieso nicht statisch definierst dachte ich, das sei für einen Anfänger leichter zu verstehen ;-)


    Zu 3. Ich hab das Tut jetzt nicht wirklich nochmal durchgesehn, bin mir aber ziemlich sicher überall einen string angehängt zu haben, um die Konvertierung nicht manuell machen zu müssen (ich wahr wohl faul und wollt mich vor ner Erklärung drücken :-P )
    Werde es aber noch abändern und eine Erklärung dafür reinmachen... wenn ich Zeit hab^^


    Ansonsten danke für die Kritik, freue mich dass es gut verständlich ist. Ich denke manchmal ich habe Probleme mit der Erklärung, weil das Zeug für mich so selbstverständlich scheint. Ich denke du weißt vielleicht, was ich meine ;-)


    Für Verbesserungsvorschläge und Fragen bin ich immer offen :-)


    Greetz

  • Bei 2. geht es darum, dass du ein String-Array in einem Int-Array speichern willst...


    Nicht nur das...
    Er speichert ein String-Array in einem Int-Array, wobei er das String-Array aus nummerische Werten des Typs Integer erstellt. (In der Annahme, das der Standart Typ für Zahlen in C# Integer ist)

    Users[4939].postCount++;


    • Weltherrschafts AG in Cooperation mit Weltuntergangs GmbH:
      "Wir sorgen dafür, dass sie sich keine Sorgen um Morgen machen müssen!"
  • Das ist mir gar nicht aufgefallen, weil ich es direkt zum Int-Array geändert hätte und die Werte dann richtig gewesen wären :D


    Falsch, bei Option Strict On eben nicht und das war auch mein, bzw. primes Kritikpunkt an dem Codeschnipsel. ;) Implizite Konvertierung sollte man schon erklärt bekommen, wenn man mit C# arbeitet.


    MfG