Visual C# 2011 Grundkurs

Methoden

LinkedIn Learning kostenlos und unverbindlich testen!

Jetzt testen Alle Abonnements anzeigen
Methoden erlauben, modularen, leicht erweiterbaren und wartbaren Code zu schreiben. Zusätzlich können wir damit Fremdfunktionen nutzen. Wie Sie eigene Methoden schreiben und welche Typen es gibt, erfahren Sie hier.
14:11

Transkript

Wir schauen uns jetzt einmal an, wie wir mithilfe von Methoden unser Programm ein bisschen modularer und sauberer aufbauen können und damit leichter erweiterbare und wartbare Code schreiben können. Diese Modularität innerhalb von meinem Programm kann ich mit sogenannten Methoden erreichen. Diese Methoden sind - man kann sich vorstellen - wie eine Art Unterprogramm, d.h. wir haben einmal unser Hauptprogramm und zu bestimmten Zeitpunkten springen wir von diesem Hauptprogramm in unser Unterprogramm, führen dort eine Berechnung durch. Nachdem wir die Berechnung durchgeführt haben, springen wir wieder zurück in unser Hauptprogramm. Hier auf der rechten Seite haben wir so eine Methode nicht. Dort lesen wir zunächst einen Wert "A1" und dieser eingelesene Wert "A" wird danach in irgendeiner Weise verarbeitet und berechnet. Was dort passiert, ist jetzt mal egal. Dann machen wir etwas anderes und irgendwann lesen wir den Wert "B1" ein. Dann führen wir genau dieselbe Rechnung, die wir oben durchgeführt haben mit dem Wert "A", mit dem Wert "B" durch. Danach geht das Programm wieder weiter. Wir lesen den Wert "C" ein und führen erneut diese Berechnung von oben durch, diesmal mit dem Parameter "C". Das Ganze ist natürlich relativ unschön. Wenn man sich jetzt überlegt, dass ich oben z.B. bei der Variable "A" nicht eine "5" addieren möchte, sondern eine "6", also diese Rechenart sich ändert, dann muss ich das an dieser Stelle ändern, ich muss es an dieser Stelle ändern und ich muss es an dieser Stelle ändern. Ich habe also einen relativ wartbaren Code, weil ich für eine Änderung in diesem sogenannten Algorithmus, also in dieser Berechnungsvorschrift an drei Stellen etwas ändern möchte. Das ist z.B. ein Punkt, wo ich Methoden einsetzen kann. Ich kann hingehen und das Ganze in eine Methode auslagern. Diese Methode heißt "komplizierte Berechnung" und hat hier einen sogenannten Parameter "X". Das heißt, ich übergebe dieser Methode einen Wert. Jetzt gehe ich hier oben in mein Programm hinein, lese diesen Wert "A" ein. Dann statt diese Berechnung zu machen wie vorher, rufe ich diese Methode A auf. Diese Methode A rufe ich auf und übergebe den eingelesenen Lesewert "A" an diesen Parameter "X", und dann wird diese Berechnung durchgeführt. Danach springe ich wieder aus diesem Unterprogramm in mein Hauptprogramm, mache hier  wieder irgendetwas, danach lese ich den Wert von "B" ein. Wenn ich hier unten an dieser Stelle bin, führe ich nicht wieder die Berechnung mit "B" durch, sondern ich rufe mein Unterprogramm auf und übergebe "B" an den Parameter "X". Dort führe ich diese Berechnung wieder durch. Danach springe ich wieder zurück. Lese irgendwann den Wert "C" ein und auch hier wieder - anstatt diese Berechnung im Code zu machen und noch mal zu schreiben - rufe ich diese Methode auf. Diese Methode springt nach oben, übergibt den Wert an den Parameter "X". Dann wird "X" ausgerechnet, also damit "C". Ich springe wieder zurück und mein Programm ist beendet. Das ist jetzt ein Vorteil von Methoden. Es gibt noch einen ganzen Bereich an Vorteilen. Zum einen macht es das Programm modular, das haben wir gerade gesehen. Wir haben da eine Art Modulberechnung, was wir immer wieder verwenden könnten. Wenn wir späteren Projekten irgendwann einmal eine ähnliche Berechnung machen würden, könnten wir auf dieses Unterprogramm "Berechnung" zurückgreifen und könnten das bei uns anwenden. Es wird wesentlich übersichtlicher. Wir haben das eben gesehen. Wir haben ein relativ langes Programm gehabt, wo sehr viele Berechnungen drin waren. So haben wir diese Berechnung an der zentralen Stelle gekapselt und können dann diese Berechnung immer aufrufen. Dass es leichter wartbar ist, haben wir eben schon gesehen. Wenn wir die Berechnung mehrfach durchführen, hätten wir normalerweise eine Änderung an mehreren Stellen machen müssen. So müssen wir diese eine Veränderung dann nur innerhalb von unserer Methode machen und schon wird das überall übernommen. Ein anderer - noch interessanterer - Aspekt ist die einfache Nutzung von Fremdfunktionalitäten. In der Methode Console.WriteLine ist eine Funktionalität definiert, die Text auf der Konsole ausgibt. Wie das Ganze im Hintergrund funktioniert weiß ich nicht, wissen die wenigsten denke ich. Es ist nicht wichtig. Ich weiß einfach, dass ich diese Methode aufrufe, dieser Methode einen String übergebe und dieser String dann auf dem Bildschirm dargestellt wird. Das reicht. Das ist eben ein weiter Vorteil, dass ich irgendwelche Funktionalität definieren kann und den anderen Entwicklern zur Verfügung stellen kann, einfach indem sie diese Methoden dann aufrufen. Das Ganze war ein bisschen abstrakt. Wir schauen uns mal an, wie man solche Methoden praktisch in Visual Studio definieren kann und sie dann ausführen kann. Damit das Ganze ein bisschen schneller geht, habe ich schon mal ein bisschen Quelltext vorbereitet, den wir jetzt später in solche Methoden auslagern werden, also aus denen wir Methoden bauen werden. Zunächst hier oben eine Eingabe, weil diese Eingabe wird von dem Benutzer auf der Console eine Eingabe erwartet. Diese Eingabe sollte eine Zahl sein. Die wird in der Variable Stream-Input gespeichert. Danach wandle ich  diese Variable Stream-Input in eine Integer Zahl um. Mit dieser Integer Zahl führe ich eine Berechnung durch. Ob das hier Sinn macht, sei mal dahingestellt. Am Ende gebe ich dieses Ergebnis hier aus. Bei Methoden unterscheidet man grob erst mal zwei Arten von Methoden: Zum einen Methoden ohne Rückgabewert und Methoden mit Rückgabewert. Rückgabewert heißt, dass ich hier an dieser Stelle eine Methode aufrufe, die mir nachher irgendeinen Wert zurückliefert wie z.B. eine Zahl. Hier oben bei ConsoleReader, das ist eine Methode mit Rückgabewert, weil die mir den eingelesenen String zu der Console zurückgibt. Console.WriteLine hingegen ist eine Methode, die keinen Rückgabewert hat, weil das an dem Schlüsselwort "void", weil eben dieses WriteLine etwas auf dem Bildschirm ausgibt. Aber das war es dann auch. Ich bekomme keinen Wert zurückgeliefert, den ich in meinem Programm weiter verwenden kann. Als erstes lagern wir diesen Eingabebereich hier oben aus. Wir wollen dort, dass der Benutzer etwas auf der Console eingibt und dass wir das nachher in eine integer Zahl umwandeln, die wir dann weiter in unserem Programm verwenden können. Also wir brauchen eine Methode mit Rückgabewert. Methoden werden außerhalb von "Main" deklariert. Wenn wir jetzt hier eine Methode deklarieren wollen, müssen wir zunächst "static" davor schreiben. Das hat einen bestimmten Grund. Da gehen wir jetzt nicht näher darauf ein. Dann müssen wir angeben, ob diese Methode einen Rückgabetyp hat oder nicht. Bei uns wird sie einen Rückgabetyp haben, denn wir möchten aus der Methoden später den in "int" umgewandelten eingelesenen Wert zurückgeben. Unser Typ, den wir zurückgeben ist also ein Integer-Datentyp. Da müssen wir dieser Methode einen Namen geben. Ich nenne das mal "reach.input". Dieses "reach.input" bekommt jetzt keinen Parameter, denn wir müssen kein Parameter übergeben. Eigentlich, was diese Methode benötigt, generiert sie selber, aber liefert uns ein Ergebnis zurück. Kein Parameter sieht derart aus, dass ich eine offene und eine geschlossene Klammer habe. Wenn ich Parameter hätte, würden die hier in der Klammer stehen. In dieser "re-input"-Methode möchten wir jetzt gerne die Eingaben lesen, deswegen kopieren wir mal hier oben diesen Code. Wir schneiden ihn besser aus und fügen ihn hier unten in diese Methode wieder ein, um ihn da zu verwenden. Wir haben jetzt hier die Zeile, um das Ganze von der Konsole einzulesen, um das Ganze in eine Integer Variable zu konvertieren und dann steht hier in der Integer Variable mein eingelesener Wert. Diesen eingelesenen Wert gebe ich an dieser Stelle zurück in mein Hauptprogramm. Das mache ich mit dem Schlüsselwort "return". "Return" und dann der Name der Variable, die ich zurückgeben möchte. Hier oben in der Methode muss ich jetzt zunächst diese Methode "re-input" aufrufen. Man sieht schon, wenn ich jetzt hier "read" erkennt Intellisense automatisch, dass eine Methode erstellt wurde und bietet uns hier die Autovervollständigung an, um das Ganze aufrufen. Da die Methode keine Parameter hat, muss ich nur eine offene und eine geschlossene runde Klammer machen und beende das Ganze mit einem Semikolon. Jetzt wollen wir an diesen eingelesenen Wert aus der Methode irgendwie herankommen. Wenn man mit der Mause auf die Methode geht, sieht man schon, dass der Rückgabewert dieser Methode, links hier, ein Integer ist. Das heißt, ich muss diesen Integer irgendwie speichern. Ich nenne auch diese Variable "Input". Wichtig an dieser Stelle hier, diese Variable "Input" hier existiert nur zwischen diesen Klammern. Das heißt, diese Variable "Input" hier unter ist eine andere, die heißt jetzt gerade zufällig so. Das ist der erste Teil. Den schauen wir uns jetzt mal hier an. Wir setzen einen BreakPoint in die erste Zeile, starten das Debugging und unser Debugging-Cursor ist in der entsprechenden Zeile. Wenn ich jetzt F11 drücke, dann springt er, an dieser Stelle, von meiner Main-Methode in meine Re-Input-Methode. Diese "re-input"-Methode wird von dem Benutzer eine Eingabe erwartet. Wir geben mal eine Fünf ein, drücken Enter und dann ist der Debug-Cursor hier in der nächsten Zeile. Wir konvertieren das Ganze in eine Zahl, also eine "5". Hier gebe ich diesen eingelesenen konvertierten Wert "5" zurück an die Aufrufstelle. Der wird hier in die Variable Input reingestellt. Dann führe ich diese Berechnung aus. Zufällig kommt da "15" raus und gebe das Ganze hier auf der Console wieder aus. Wir schauen uns das an: das Ergebnis ist "15". Als nächstes wollen wir versuchen, hier diese Berechnungen in eine Methode auszulagern. Diese Berechnungen werden in einer Methode ausgeführt. Dieser Methode muss ich natürlich diesen Wert von Input erst mal übergeben, damit er weiß, womit er rechnen muss. Am Ende muss ich diesen berechneten Wert von Input wieder an das Hauptprogramm zurückgeben, weil ich diesen Input später noch ausgeben möchte. Deswegen brauchen wir jetzt eine Methode, die zum Einen ein Parameter hat vom Typ Integer und die ein Integer wieder zurückliefert. So eine Methode schreiben wir uns hier unten mal: "static". Wir haben gerade gesagt, sie muss ein Integer zurückliefern, eben das berechnete Ergebnis. Ich nenne sie mal "calculate". Hier oben müssen wir diese Zahl, die sie berechnen soll, übergeben. Das ist ein Parameter. Wie bei normalen Variablen muss ich ein mal sagen, was für ein Typ dieser Parameter ist, also "Int" und dann muss ich diesen Parameter benennen: "wa". Dann wieder hier unten der Anweisungsblock, der von der Methode ausgeführt wird. Jetzt gehen wir oben hin und nehmen diesen Bereich mit geklickter Maustaste, schieben ihn runter und formatieren. Dieses Input hier ersetzen wir durch "wa", weil das war die Variable hier oben und hier heißt sie jetzt "wa". Das ganze kann man relativ schnell machen, indem man Strg+F drückt. Strg+F haben wir eine Schnellsuche, dann können wir in meinem Quelltext suchen. Dort suchen wir mal nach dem Wort "input", ersetzen das Ganze durch die Zeichenkette "wa", drücken auf "alle ersetzen", und dann wurden diese Vorkommen im Hintergrund ersetzt, und wir haben hier unsere Berechnung. Wir bekommen hier einen Wert übergeben. Mit diesem Wert führen wir eine Berechnung durch, und unten müssen wir diesen Wert wieder zurückgeben. Oben in der Mainmethode rufen wir das Ganze jetzt mal auf. Wir rufen hier die Methode "calculate" auf. Man sieht hier schon, auch das wird hier vorgeschlagen. Wenn ich jetzt eine offene Klammer mache, dann sieht man hier im Intellisense, das er uns anzeigt, dass wir der Methode einen Parameter vom Typ Integer definiert haben. Den wir auch mal an und schließen das Ganze mit einem Semikolon ab. Jetzt haben wir in unserer Methode einen Rückgabewert vom Typ Integer, also unser berechneter Wert und den schreiben wir einfach in die Input-Variable rein. Das kann ich durchaus machen, weil zunächst wird hier die Methode "calculate" mit Input aufgerufen. Das Ergebnis nachher überschreibt den alten Wert aus Input.  Als letztes schauen wir uns eine Methode an, die keinen Rückgabewert hat. Wir werden jetzt mal diese Ausgabe hier in eine Methode auslagern. Dazu gehen wir runter, schreiben eine neue Methoden, wieder "static" vorweg, schreiben dann "void", weil diese Methode eben keinen Rückgabetyp hat, dann brauchen wir keine Rückmeldung oder kein Ergebnis davon in unserem Programm. Also "void", wir nennen das mal "output". Dann müssen wir diesem Output das berechnete Ergebnis übergeben. Dieses berechnete Ergebnis ist vom Datentyp "int". Auch das hier nennen wir mal "wa". Hier ist es ebenfalls so, dass dieses "wa" hier oben vollkommen verschieden ist zu diesem "wa" hier unten. Dann nehmen wir diesen Quelltext, ziehen den hin mit gedrückter Maustaste in die Output-Methode und ändern hier den Namen von "input" auf "wa", weil diese Variable hier "wa" heißt.  Dann bleibt uns nur noch als letztes zu tun, diese Methode Output aufzurufen. Auch hier Intellisense hat das erkannt. Er zeigt uns: "ich brauche ein Parameter vom Typ Integer". Dann übergeben wir ihm den Input und dann sind wir fertig. Wir schauen uns das Ganze im Debugger an. Ich führe das Ganze hier oben aus und lande hier vor dem Aufruf meiner Methode. Wenn ich F11 drücke, springt er wieder in unsere Methode rein, das hatten wir eben schon. Ich gebe noch mal "5" ein, F11, ich gehe in den Bereich, wo das Ganze zurückgegeben wird. Nach Beendigung der Methode beendet sich das Ganze wieder und springt in die Mainmethode. Das Ergebnis von unserer Eingabe - die "5" - wird dann hier gespeichert in der Variable Input. Hier rufe ich die Methode "calculate" auf mit dem Wert "Input = 5". Diese Variable Input 5 wird an dieser Stelle hier an die Methode übergeben und in die Variable eingeschrieben. Das heißt, wenn ich jetzt hier F11 drücke, dann steht oben in der Variable "wa" der Wert "5", den ich oben übergeben habe. Jetzt führte ich hier diese Berechnung durch, also wieder unser Ergebnis "15".  Ich sage hier, "return wa". An dieser Stell wird dann der berechnete Wert zurückgegeben. Mit Drücken durch F11 und nochmal F11 verlasse ich diese Methode. Der berechnete Wert von "15" wurde hier in die Variable Input geschrieben. Jetzt habe ich als letztes die Methode ohne Rückgabewert mit Parameter. Dort übergebe ich diese berechnete "15", springe hier mit F11 in diese Methode rein. Auch hier wurde die "15" an den Parameter "wa" übergeben, dann gebe ich das Ergebnis hier aus und es ist abgeschlossen. Wir schauen uns das mal in der Console an und dort ist ausgegeben: das Ergebnis ist 15. Das Ganze könnte man jetzt öfters machen. Ich könnte hier mit "re-input" eine x-beliebige Anzahl von Zahlen einlesen, diese verarbeiten, dann mit mehreren Aufrufen von "calculate" berechnen lassen und sie dann mit der Methode Output ausgeben. Wir haben uns im Video angeschaut, wie man Programme modularer aufbauen kann, wie man bestehenden Code aufscheint und diese über Methode verteilen kann. Es gibt zum Einen Methoden mit Rückgabewert, dann gebe ich den Datentyp an. Es sind diese Methoden hier. Dann gebe ich hier den Datentyp der Rückgabe an. Es gibt Methoden ohne Rückgabewert. Das ist z.B. diese Methode hier mit dem Schlüsselwort "void". Mit Rückgabewert brauche ich immer dann, wenn ich in der Methode etwas berechnet habe und diesen berechneten Wert in meinem Hauptprogramm weiterhin benötige. Ohne Rückgabewert verwende ich, wenn ich in der Methode etwas durchführe, dessen Ergebnis ich bei der Aufrufstelle nicht mehr verwenden muss. Zusätzlich gibt es Methoden, einmal ohne Parameter wie "input", was wir gebaut haben. Dort war es gar nicht erforderlich, dass wir einen Parameter übergeben. Dann gibt es Methoden mit Parametern, z.B. in der Methode "calculate". Dort mussten wir den eingelesen Wert übergeben und das ist eben ein Parameter. Es könnte auch mehrere Parameter geben, die immer durch Komma getrennt sind. Sie sehen dann z.B. so aus, aber das war an dieser Stelle nicht nötig.

Visual C# 2011 Grundkurs

Steigen Sie in die C#-Programmierung ein und lernen Sie sowohl die Grundlagen der Sprache C# als auch die Entwicklungsumgebung Visual Studio 2010 und .NET-Framework kennen.

7 Std. 28 min (81 Videos)
Derzeit sind keine Feedbacks vorhanden...
Hersteller:
Software:
Visual Studio Visual Studio 2010
Exklusiv für Abo-Kunden
Erscheinungsdatum:27.06.2011

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!