|
| |
VB.NET - Ein- und Umsteiger| Subroutine schreiben | |  | | Autor: Sloorg | | Datum: 09.05.14 04:37 |
| Hallo zusammen, 
ich stehe vor folgendem Problem: Und zwar möchte ich eine Subroutine als Konsolenprogramm schreiben, der man eine natürliche Zahl als Anzahl und ein Zeichen übergibt und die das Zeichen anzahl mal wieder ausgibt. Hat jmd. vielleicht eine Idee, wie man das lösen könnte? Hier meine ersten Überlegungen, aber so klappt das nicht:
Imports System.Console
Module Module1
'eine Subroutine, der man eine natürliche Zahl als Anzahl und ein Zeichen
'übergibt und die das Zeichen Anzahl mal an den Bildschirm schreibt.
Public zahl, anzahl As Integer, zeichen As Char
Dim erg As String
Sub Main()
Write("Bitte natürliche Zahl eingeben: ")
zahl = ReadLine()
Write("Bitte ein Zeichen eingeben: ")
zeichen = ReadLine()
WriteLine(anzahl)
WriteLine(erg)
Warten()
End Sub
Sub rechnung(ByVal anzahl As Integer, ByVal zeichen As Char)
Dim erg As String
For zeichen As Char = 1 To anzahl
erg = zeichen * anzahl
Next
Return erg
End Sub
Sub Warten()
Write("Bitte EINGABE drücken: ")
ReadLine()
End Sub
End ModuleSchöne Grüße,
Sloorg. | |
| Re: Subroutine schreiben | | | | Autor: argoped | | Datum: 09.05.14 11:19 |
| Meinst Du sowas ?
Imports System.Console
Module Module1
'eine Subroutine, der man eine natürliche Zahl als Anzahl und ein Zeichen
'übergibt und die das Zeichen Anzahl mal an den Bildschirm schreibt.
Public zahl, anzahl As Integer, zeichen As Char
Dim erg As String
Sub Main()
Write("Bitte natürliche Zahl eingeben: ")
zahl = ReadLine()
Write("Bitte ein Zeichen eingeben: ")
zeichen = ReadLine()
Dim s As String = rechnung(zahl, zeichen)
WriteLine(s)
Anzeigen(zahl, zeichen)
Warten()
End Sub
Sub Anzeigen(anzahl, zeichen)
For i As Integer = 0 To anzahl - 1
WriteLine(zeichen)
Next
End Sub
Function rechnung(ByVal anzahl As Integer, ByVal zeichen As Char) As String
Dim erg As String = ""
For i As Integer = 1 To anzahl
erg &= zeichen
Next
Return erg
End Function
Sub Warten()
Write("Bitte EINGABE drücken: ")
ReadLine()
End Sub
End Module | |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 09.05.14 12:45 |
| Eine Subroutine wird zwar eigentlich nicht gebraucht, aber ...
Imports System.Console
Module Module1
'eine Subroutine, der man eine natürliche Zahl als Anzahl und ein Zeichen
'übergibt und die das Zeichen Anzahl mal an den Bildschirm schreibt.
Sub Main()
Dim anzahl As Integer, zeichen As Char
Dim input As String
Do
Write("Bitte natürliche Zahl eingeben: ")
input = Console.ReadLine()
Loop While Not Integer.TryParse(input, anzahl) Or anzahl < 1
Write("Bitte ein Zeichen eingeben: ")
zeichen = CChar(ReadLine())
WriteLine(anzahl)
WriteLine(rechnung(anzahl, zeichen))
Warten()
End Sub
Function rechnung(ByVal anzahl As Integer, ByVal zeichen As Char) As String
Return StrDup(anzahl, zeichen)
End Function
Sub Warten()
Write("Bitte EINGABE drücken: ")
ReadLine()
End Sub
End Module
Beitrag wurde zuletzt am 09.05.14 um 13:01:39 editiert. | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 09.05.14 16:33 |
| | OK, DaveS, sorry! | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 09.05.14 16:38 |
| Hallo argoped,
super, das funktioniert! Ihr seid halt doch Profis hier, ne? Vielen Dank, wär da alleine nicht draufgekommen.
- Will mal zur Übung einige Subroutinen und Funktionen basteln. Weißt du evtl. noch ein paar gute Beispiele?
Beste Grüße,
Sloorg. ;>) | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 09.05.14 16:42 |
| Hallo Manfred X,
super, vielen Dank, das funktioniert! ;>)
Was bedeutet denn diese Zeile?: Loop While Not Integer.TryParse(input, anzahl) Or anzahl < 1
(Etwa, falls es keine nat. Zahl ist, dass sie dann geändert wird?) Das "Dup" in der Return-Zeile ist mir auch neu...
Beste Grüße,
Sloorg! B) | |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 09.05.14 17:53 |
| Wenn Du Dich in VB einarbeiten willst, wird normalerweise
die Lektüre einer Einführung in das "Objektorientierte Programmieren"
empfohlen.
Man erstellt statt Funktionen/Subroutinen in Modulen
Klassen, die durch ihre Eigenschaften, Methoden und Ereignisse eine
bestimmte (wiederverwendbare) Funktionalität bereit stellen.
Das Net-Framework ist eine riesige Ansammlung solcher Klassen, d.h.
die MSDN-Doku vermittelt einen Überblick darüber, wie Klassen
konstruiert werden, wie speziellere Klassen daraus abgeleitet und
- in den Beispielen - wie sie verwendet werden.
| |
| Re: Subroutine schreiben | | | | Autor: ErfinderDesRades | | Datum: 09.05.14 20:31 |
| StrDup ist eine Methode aus dem Microsoft.VisualBasic.Strings - Modul.
Der Microsoft.VisualBasic - Namespace ist bis auf ganz wenige Ausnahmen angefüllt mit Krimskrams, welcher sehr viele veraltete Konzepte von vb6 nachbildet.
Das ist ziemlich ungünstig, wenn man sich in OOP einfinden will, denn so bleibt man dem veralteten Programmierstil verhaftet, und lernt wichtige Teile der Systematik der moderneren und ganz anneren Sprache vb.net u.U. niemals kennen.
Konkret: Statt olle vb6-StrDup bietet die moderne String-Klasse einen Konstruktor, um derlei Strings zu bilden: Function rechnung(ByVal anzahl As Integer, ByVal zeichen As Char) As String
Return New String(zeichen, anzahl)
End Function(ist übrigens Quatsch, eine Methode anzulegen, die nur eine einzige und so triviale Zeile enthält)
Auch hätte ich noch eine "Meta-Erläuterung" zu ManfredX' Erläuterungen:
Wenn du im Editor auf einen dir unbekannten Begriff gehst - sei es ein Klasenname, sei es ein Schlüsselwort wie "Loop" -
Und dann drückst du F1, dann öffnet sich die kontextbezogene Hilfe im INet-Browser.
Wenn man diese Einrichtung kennt (und sie funktioniert), dann kann man sich enorm viele Fragen selbst beantworten.
Probiers aus, mit dem Begriff "Loop", aber auch mit dem Begriff "String"
Ach so, noch zum "bösen Namespace": In den Projekteigenschaften auf dem Reiter "Verweise" ist recht weit unten eine CheckedListbox, die alle projektweiten GeneralImporte auflistet.
Dort solltest du den GeneralImport "Microsoft.VisualBasic" unchecken, sodass Microsoft.Visualbasic nicht mehr automatisch projektweit importiert ist.
Das schützt dich davor, versehentlich auf veraltete Programmier-Konzepte zurückzugreifen.
Der Namespace bleibt dennoch weiter verfügbar, nur musst du dann die Sachen vollqualifiziert addressieren, oder aber du setzt den Import ganz oben in deine Datei. Hat den Vorteil, dass du weißt was du tust.
(Rechtschreibfehler urheberrechtlich geschützt)
Beitrag wurde zuletzt am 09.05.14 um 20:34:28 editiert. | |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 09.05.14 20:46 |
| Hallo!
Der Namespace Microsoft.VisualBasic enthält VB-spezifische Klassen.
Das meiste ist damals vom Umstell-Assistenten verwendet worden,
um VB6-Programme in Net zu konvertieren.
Eine allgemeine Aussage, der Namespace sei insgesamt veraltet, ist falsch.
Er braucht deshalb nicht aus den allgemeinen Imports entfernt zu werden.
Die Methode "StrDup" war kein Bestandteil von VB6.
Ihre Nutzung ist nicht überholt und kein "Verstoß" gegen irgendwelche
OOP-Regeln.
| |
| Re: Subroutine schreiben | | | | Autor: ErfinderDesRades | | Datum: 09.05.14 21:05 |
| also ich nenne es nicht oop und veraltet, denn StrDup, grade wenn man den GeneralImport benutzt ist einfach ein Codewort was im aktuellen Namensraum herumschwirrt, tut was es soll, aber ohne in die OOP-Systematik eingebunden zu sein.
Hingegen den dafür vorgesehenen Konstruktor der String-Klasse zu verwenden ist OOP, denn der Konstruktor ist da angesiedelt, wo er hingehört: inne String-Klasse.
Beides funktioniert, nur empfehle ich den OOP-Ansatz, schon einfach, um OOP-Denke einzuüben (@Sloorg: vlt. auch mal die String-Klasse im ObjectBrowser angugge).
Zum OOP-Ansatz gehört auch das Prinzip Kapselung, und wenns problemlos möglich ist, den aktuellen Namespace klein zu halten, ist das ein Vorteil.
Und wie gesagt: 95% des Microsoft.Visualbasic-Namespace-Krams ist entbehrlich. Also darauf zu verzichten leitet einen automatisch dahin, nach den entsprechenden modernen Konzepten des Frameworks sich umzuschauen - ob das nun String-Verarbeitung betrifft, Dateizugriffe oder was auch immer.
(Rechtschreibfehler urheberrechtlich geschützt) | |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 09.05.14 21:22 |
| Die "strDup"-Methode bietet Überladungen, die andere
Parameter-Optionen anbieten als der String-Konstruktor.
Das ist bei einer ganzen Reihe von Methoden in "Microsoft.VisualBasic"
der Fall. Sie ermöglichen andere Aufrufe als die entsprechenden
Methoden anderer Framework-Namespaces.
Aber: Was soll's ?
| |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 09.05.14 22:07 |
| So so .....
Was hat die Duplizierung eines Zeichens eigentlich im KONSTRUKTOR
der System.String-Klasse zu suchen?
Wäre es nicht im Sinne des OOP eher angebracht, in dieser Klasse
statt dessen eine Instanz-METHODE wie z.B. "StrDup" zu realisieren,
die eine enthaltene Zeichenfolge vervielfältigen kann?
Wg. der "Unveränderlichkeit" von Zeichenfolgen in String-Variablen?
Fragen über Fragen
Beitrag wurde zuletzt am 09.05.14 um 22:20:55 editiert. | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 10.05.14 14:59 |
| | Merci für die Info! Schönes Wochenende. | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 10.05.14 15:08 |
| Hallo Erfinder des Rades,
danke für die Erklärung. - Hier ging's ja nur um ne Übung, damit ich Subroutinen schreiben lerne.
Ich hatte mich vorher etwas mit VB 6.0 beschäftigt, daher ist in VB.NET doch einiges ungewohnt. Aber mit der Zeit werd ich's schon kapieren. Dann 'n schönes Wochenende,
schöne Grüße, Sloorg! B) | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 10.05.14 15:21 |
| ooops -  da gab's ja ne heftige Diskussion... tja, da kann ich leider noch nicht mitreden. ;>)
Weiß jmd. vllt. noch ein paar gute Beispiele für Subs und Functions? Hab zwar hier was gefunden, aber noch kein Plan, wie ich das für Konsole umsetzen kann...:
http://marco.seaside-graphics.de/programmierung/vb_net/vb-net-eigene-sub-routine-functions-in-vb-net-programmen-einsetzen
Aber danke nochmal für eure guten Tips, Leute - habt mir sehr weitergeholfen.
Nice greetz,
Sloorg! :B | |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 10.05.14 16:54 |
| Hallo!
Einen Kurs kann man hier nicht geben, aber eine Übersicht über
die Aufgaben:
Du "springst zu kurz", wenn Du damit beginnst, zu verstehen, wie
Functions/Subs einzusetzen sind, falls Du Dich zuvor nicht
damit vertraut gemacht hast, was eine Klasse (Class) ist und
welche Bedeutung deren Konstruktor (New), die Eigenschaften (Property),
die Ereignisse (Events) und die Methoden (Function, Sub) haben.
Du solltest auch verstanden haben, was "Werttypen" und was "Referenztypen"
sind, worin genau die Unterschiede bestehen.
Auf dieser Kenntnis-Grundlage kannst Du Dich damit beschäftigen, was Parameter
einer Function/Sub bewirken, die mit "ByVal" oder "ByRef" gekennzeichnet sind
- danach auch mit dem Schlüsselwort "Optional" und dem "ParamArray".
Jetzt steht der fruchtbaren Beschäftigung mit konkreten Methoden, die als Function
oder als Sub realisiert sind, nichts mehr im Wege.
Das beginnt mit den Schlüsselwörtern, die den Zugriffsbereich auf eine Methode
festlegen (Private, Protected, Friend, Public).
| |
| Re: Subroutine schreiben | | | | Autor: ErfinderDesRades | | Datum: 11.05.14 11:04 |
| ich weiß, eiglich wisst ihrs beide besser, aber es hat wohl Vorrang, mir zu widersprechen, oder gar meine Empfehlungen zu verfälschen, und dann zu widersprechen, und so sachen - wie gesagt: wenn so feste dagegen gehalten wird, hats kein Zweck.
(Rechtschreibfehler urheberrechtlich geschützt) | |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 11.05.14 12:23 |
| Deine Unterstellung, ich würde hier - gegen besseres Wissen - Aussagen von Dir
widersprechen, weise ich zurück.
Zitat:
[I]Der Microsoft.VisualBasic - Namespace ist bis auf ganz wenige Ausnahmen angefüllt
mit Krimskrams, welcher sehr viele veraltete Konzepte von vb6 nachbildet.
Das ist ziemlich ungünstig, wenn man sich in OOP einfinden will, denn so bleibt man
dem veralteten Programmierstil verhaftet, und lernt wichtige Teile der Systematik
der moderneren und ganz anneren Sprache vb.net u.U. niemals kennen. [/I]
Die Empfehlung "Microsoft.VisualBasic" nicht zu importieren, kann man geben.
Sie ist von Dir aber falsch begründet worden.
VB ist älter als das Framework. Unter anderem deshalb enthält "Microsoft VisualBasic"
einige Klassen, die bekannte VB-Funktionen zur Verfügung stellen, für die es im
Net-Framework (teilweise) andere Realisierungen gibt.
Manches ist auch neu und einiges gibt es nur dort. Und ein paar "Konzepte" gelten
als veraltet - siehe Doku.
Die Verwendung dieser VB-spezifischen Funktionen hemmt nicht die Einarbeitung in OOP,
oder in die Systematik des Net-Framework. Kenntnisse zu "OOP" oder zum "Framework" muß
man - bei Bedarf - eben erlernen.
VB.Net operiert zwar auf der Grundlage des Net-Framework, ist aber - anders als C# -
nicht auf eine Net-Sprache zu reduzieren.
Gut lesbarer Code, ein einfacher Einstieg, Kompatibilität zu anderen Basic-Dialekten u.a.
sind wichtige Zielsetzungen dieser Programmier-Sprache (- sonst wäre sie unnötig.)
Beitrag wurde zuletzt am 11.05.14 um 12:24:39 editiert. | |
| Re: Subroutine schreiben | | | | Autor: ErfinderDesRades | | Datum: 11.05.14 13:02 |
| Manfred X schrieb:
| Zitat: | |
Die Verwendung dieser VB-spezifischen Funktionen hemmt nicht die Einarbeitung in OOP | |
Na eben doch.
Ohne GeneralImport auf Microsoft.Visualbasic ist man eher geneigt, OOP-systematisch zu denken:
Ich möchte Funktionalität zum Erstellen eines Strings aus sich wiederholenden Zeichen?
Das suche ich in der String-Klasse.
Ich möchte einen String an bestimmten Zeichen splitten? Ich gucke in die String-Klasse.
Ich möchte einen Teilstring bilden? Ein OOP-Programmierer guckt in die String-Klasse.
Ich möchte den Index eines TeilStrings finden? Ich suche in der String-Klasse.
Ich möchte das heutige Datum? Ein OOP-Progger guckt in die Date-Structure.
Ich möchte aus einem String einen Integer auslesen? Ein OOP-Progger guckt erstmal in die String-Klassse, dann in die Integer-Structure.
Dieses systematische OOP-Denken übt sich leichter ein, wenn man nicht so aufgeschnappte VB-Classic-Altlasten im aktuellen Namespace rumfahren hat, wie StrDup, Split, Mid$, Left$, Right$, Instr, Now, CInt (in Reihenfolge der Beispiele)
Und das vermeidet man ganz einfach, indem man diesen kontraproduktiven GeneralImport entfernt.
Bleibt noch für Sloorg anzumerken, **wie** man in die String-Klasse, die Date-Structure, die Integer-Structure guckt: Nämlich, indem man den ObjektKatalog zur Ansicht holt - bei mir geht das mit F2, kann sein in anderen Konfigurationen mit anderen Shortcuts- evtl. muss man bischen suchen im Menü.
Auch das ist Einarbeiten in OOP: Dass man lernt die Doku zu nutzen, also ObjectBrowser und MSDN.
(Rechtschreibfehler urheberrechtlich geschützt) | |
| Microsoft VisualBasic | | | | Autor: Manfred X | | Datum: 11.05.14 13:54 |
|
Überblick über die Visual-Basic-Laufzeitbibliothek:
http://msdn.microsoft.com/de-de/library/c157t28f%28v=vs.100%29.aspx
Selbstverständlich sind auch alle Klassen und Module der VB-Laufzeitbibliothek
im IDE-Objektkatalog verzeichnet und sie können beim Programmieren ohne
Einschränkung genutzt werden. (Informieren sollten sich Einsteiger stets in der
MSDN-Dokumentation.)
Als VBler kann man z.B. sowohl in das "Microsoft.VisualBasic.Strings"-Modul
schauen oder in die "Mscorlib.System.String"-Klasse. Mit OOP hat das nix zu tun.
| |
| Re: Microsoft VisualBasic | | | | Autor: ErfinderDesRades | | Datum: 11.05.14 14:33 |
| Manfred X schrieb:
| Zitat: | |
Als VBler kann man z.B. sowohl in das Microsoft.VisualBasic.Strings-Modul
schauen oder in die Mscorlib.System.String-Klasse. Mit OOP hat das nix zu tun. | |
Naja - für mich besteht **Objekt**orientiertheit u.a. darin, dass ich vorrangig die **Objekt**-Methoden der beteiligten Klassen zu nutzen suche (und mir denken kann, wo ich sie finde), wie String.Split(), String.Substring(), und nur sehr nachrangig Klassen-unabhängige Methoden, die in beliebigen Modulen angesiedelt sein mögen.
Es ist der OOP-Denke-Unterschied, ob ich codeDim Ranz = Mid("oller vb-classic-Ranz ist sowas",19,4)
'oder
dim oop = "die oop-String.SubString-Methode nutzen".Substring(4,3)| Zitat: | |
(Informieren sollten sich Einsteiger stets in der MSDN-Dokumentation.) | |
Das würde ich mit Ausschließlichkeit nicht behaupten. Der Objektkatalog hat andere Stärken und Schwächen als MSDN, ich bevorzuge daran die kompakte Darstellung des Inhaltes und die effiziente Suche-Funktion.
Und mit F1 kommt man vom OB auch direkt im entsprechenden MSDN-Artikel raus.
(Rechtschreibfehler urheberrechtlich geschützt) | |
| Re: Microsoft VisualBasic | | | | Autor: Manfred X | | Datum: 11.05.14 14:49 |
| Wichtig ist die explizite Deklaration von Variablen (wg. OOP u.a)
Dim v1 As String = Mid("traditionelle VB-Laufzeitbibliothek", 1, 4)
'oder
Dim v2 As String = "String-SubString-Methode des Framework".Substring(0, 3)"Mid" ist kurz, fehlertolerant und eins-basiert,
"Substring" ist lang und null-basiert.
Beides kann man machen.
http://msdn.microsoft.com/de-de/library/8kyd8789%28v=vs.100%29.aspx
Beitrag wurde zuletzt am 11.05.14 um 15:03:16 editiert. | |
| Re: Microsoft VisualBasic | | | | Autor: ErfinderDesRades | | Datum: 11.05.14 15:11 |
| na toll!
Jetzt kann ich dir die Vorteile von String.SubString gegenüber dem schlechter designeten Mid() auseinandersetzen, die dir sicherlich längst bekannt sind?
Und der Fragesteller hat mit Sicherheit völlig den Faden verloren.
Gute Arbeit, Leute!
(Rechtschreibfehler urheberrechtlich geschützt) | |
| Re: Microsoft VisualBasic | | | | Autor: Manfred X | | Datum: 11.05.14 15:30 |
| MID(,,) verwendet intern die String-Substring-Methode,
kann also problemlos beim Programmieren benutzt werden.
Es ist - neben der Eins-Basierung - lediglich dafür gesorgt, daß fehlende Zeichen
(Nothing) im ersten Parameter oder Längenüberschreitungen im 2./3.-Parameter
abgefangen werden -> Rückgabe: Leerstring, statt dem Werfen einer Ausnahme.
(Ausnahme: wenn Start <= 0 oder Length < 0).
Beitrag wurde zuletzt am 11.05.14 um 15:35:44 editiert. | |
| Re: Subroutine schreiben | | | | Autor: argoped | | Datum: 11.05.14 18:18 |
| Na ja,
Beispiele gäb's wie Sand am Meer. Wenn Du wirklich tiefer in VB einsteigen möchtest solltest Du dir ein Buch kaufen. Möglichst dünn! Nach und nach werden Dir dann die Feinheiten klar und Du kannst Dir alles weitere aus dem Netz saugen. Online gibt's auch was von Galileo Computing das ist aber nicht so dünn (openbook.galileocomputing.de/einstieg_vb_2010/).
also noch viel Spaß mit VB. | |
| Re: Subroutine schreiben | | | | Autor: ErfinderDesRades | | Datum: 11.05.14 18:56 |
| "openbook.galileocomputing.de/einstieg_vb_2010"
Hmm - ein Buch zu lesen halte ich auch für eine gute Idee, nur grade dieses Buch ist ein echter "Anfänger-Verderber".
Es diskualifiziert sich schon allein dadurch, dass die meisten dortigen Codebeispiele nur unter Option Strict Off kompilierbar sind.
Sich aber nicht an Option Strict On zu gewöhnen erschwert es einem Anfänger ungemein, verschiedene Datentypen voneinander zu unterscheiden, und so trifft man in Foren häufig auf vb-Programmierer, die auch nach Jahren der Praxis noch immer nicht die Frage beantworten können: "Welchen Datentyp hat der und der Ausdruck?"
Also meine Buch-Empfehlung ist genauso umsonst, aber ist noch viel dicker, und ist auch unbequem zu lesen (Pdf), aber dafür ist es inhaltlich von ausgezeichneter Qualität: http://www.microsoft.com/germany/msdn/aktuell/news/microsoftvisualbasic2005dasentwicklerbuch.aspx
(Rechtschreibfehler urheberrechtlich geschützt) | |
| Re: Subroutine schreiben | | | | Autor: ErfinderDesRades | | Datum: 11.05.14 20:20 |
| 2010-Version: http://www.microsoft-press.de/url.asp?cnt=mspress_vb2010
BeispielDateien dazu: http://www.microsoft-press.de/support.asp?s110=535&s100=389&s101=&suchen.x=0&suchen.y=0
Wobei ich trotzdem das 2005er bevorzuge, weil dort die essentiellen Grundlagen gründlicher abgehandelt werden.
In spätere Versionen ist Linq und Wpf noch mit hineingestopft - etwas zu Lasten der Basics.
(Rechtschreibfehler urheberrechtlich geschützt) | |
| Re: Subroutine schreiben | | | | Autor: Franki | | Datum: 12.05.14 00:40 |
| Hallo Manfred X
| Zitat: | |
Auf dieser Kenntnis-Grundlage kannst Du Dich damit
beschäftigen, was Parameter
einer Function/Sub bewirken, die mit "ByVal" oder
"ByRef" gekennzeichnet sind | |
Du hast ja recht, aber diesen Unterschied gab es auch schon bei VBClassic. Wenn man den als Umsteiger damals nicht verstanden hat oder sich dafür interessiert hat wird man es auch unter .NET nicht tun.
| Zitat: | |
Jetzt steht der fruchtbaren Beschäftigung mit konkreten
Methoden, die als Function
oder als Sub realisiert sind, nichts mehr im Wege.
Das beginnt mit den Schlüsselwörtern, die den Zugriffsbereich
auf eine Methode
festlegen (Private, Protected, Friend, Public).
| |
Auch in VBClassic gab es ähnliche Unterscheidungen die oft nicht genutzt worden sind sondern einfach der Standardwert beibehalten worden ist.
Ich sehe das einfach so, dass es sich bei solchen Fragen einfach um Fragesteller handelt die ihr Programm ans laufen bekommen wollen und denen es völlig egal ist warum und wieso das dann läuft. Und wenn es dann funktioniert ist die Aufgabe erfüllt, auch wenn sie programmiertechnisch gesehen mangelhaft ist. Das merkt der Kunde ja nicht.
Gruß
Frank
| |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 12.05.14 05:30 |
| Hiya,
nochmals vielen Dank für die vielen Tips und Anregungen. Da gibt's ja einiges zu erforschen...
- Mir wurde nur ans Herz gelegt, mich mit ein paar Beispielen für Subroutinen und Funktionen zu beschäftigen und Berechnungen auszuführen, dann kommt erst OOP... usw. Daher bin ich grade auf der Suche nach Beispielen und Lösungen. Nachbauen geht ja noch, wenn man eine ähnliche Vorlage hat, aber selbst irgendwas zu schreiben, ohne dafür ein Beispiel zu haben - nicht so einfach, bis unmöglich.
Dann ciao und ne schöne Woche,
Sloorg! ;>) | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 12.05.14 05:57 |
| OK, thx to all of u ppl! Hab mir schon alles von galileocomputing runtergeladen, was mit vb zu tun hat. ;>)
Einen dicken Wälzer hab ich ja letztes Jahr durchgearbeitet: VB 6.0 Schritt für Schritt (von nem Kumpel bekommen als Einstieg). Möchte aber doch jetzt in VB.NET einsteigen - ist halt doch etwas Umstellung...
Nochmal merci´für die vielen Anregungen und Tips!
Bye 4 now,
Sloorg! B) | |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 12.05.14 11:18 |
| Die von Dir gewählte Vorgehensweise ist "schwierig".
Eine Function/Sub enthält "gewöhnlichen" VB-Code.
Entscheidend ist die Gestaltung der Parameterliste.
Sie bestimmt, welche aktuellen Variablen-Inhalte in
welcher Form an die Function/Sub übergeben werden und
ob "innerhalb" vorgenommene Änderungen an übergebenen
Werten/Klassen-Instanzen an das rufende Programm zurückgeliefert
werden oder nach Abschluß der Routine verfallen -> ByRef oder ByVal.
Das Verhalten von Wertttyp-Variablen (z.B. Integer, allgemein: Structure)
ist in dieser Hinsicht anders als das von Referenztyp-Variablen
(Klassen-Instanzen).
Du mußt Dir deshalb diese vier Fallunterscheidungen erarbeiten.
Ein weiterer Gesichtspunkt ist in diesem Zusammenhang der Geltungs-
Bereich von Variablen. Sind sie auf Klassen-/Modul-Ebene deklariert
(sollte ein Ausnahmefall sein! - Membervariablen) dann brauchen sie an die dort enthaltene
Function/Sub nicht übergeben werden, sondern in der Soubroutine sind
sie direkt zu verwenden (abzufragen oder zu modifizieren).
Verständlich werden diese Zusammenhänge am besten, wenn man Beispiele für
die Gestaltung von Klassen durcharbeitet - und sich dabei klarmacht,
wie die Klassen-Methoden dort (ein-)gebaut worden sind.
Beitrag wurde zuletzt am 12.05.14 um 11:39:30 editiert. | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 13.05.14 00:22 |
| Klingt einleuchtend! (Variablen, Strukturen + Arrays sowie Datentypen & Operatoren hatte ich ja schon, sowie Übergabe byval od. byref etc.)Bei Klassen bin ich ja mittlerweile - kenn ich noch von Ruby her (hab da mal vor ein paar Jahren reingeschnuppert; ist also ähnlich). Aber so ist nun mal die Vorgehensweise in diesem Crashkurs, da wird jedes Thema kurz angerissen und dann sollst du mit der Vorlage von nur wenigen Beispielen eigene Programme zum Thema erstellen. Ich muss gestehen, da bin ich teilweise echt überfordert... :P
Aber nach dem Kurs werde ich alles nochmal durcharbeiten; hab auch hier einige Tutorials gefunden.
| |
| Re: Subroutine schreiben | | | | Autor: Franki | | Datum: 15.05.14 00:52 |
| Hallo,
da du den "Wälzer" zu VB6 erst vor einem Jahr durchgearbeitet hast solltest du alles schnellstmöglich vergessen was du als Anfängerwissen von VB6 hsst.
.NET ist ein ganz anders Konzept, wenn du dich da einarbeiten möchtest ist Halbwissen von VB6 eher schädlich bzw. hinderlich. Je weniger du von VB6 weißt, desto einfacher ist der Einstieg in .NET.
Andererseits spricht auch nichts dagegen einfache VB6 Programme weiter zu verwenden, die funktionieren auch unter aktuellem Windows und werden es die nächsten Jahre auch noch.
Da bei mir auch die finanzielle Seite eine Rolle spielt mach ich es so, dass ich neue Projekte mit .NET mache und ältere Projekte nach wie vor mit VB6 pflege wenn ich damit weiterhin den Anforderungen der Kunden gerecht werden kann. (Die interessiert nämlich nicht womit die Anwendung programmiert worden ist, eher ob sie funktioniert oder nicht und ob sie ihre gewohnte Arbeitsumgebung am Bildschirm haben)
Gruß
Frank
| |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 17.05.14 04:46 |
| Hi Franki,
ja, ich dachte halt, ich lerne erst Grundwissen über VB mit VB 6.0 (da ich das Buch von nem IT bekam - und wenn's schon nix kostet, dachte ich "wieso nicht"?!). Ich muss sagen, das war schon auch für Einsteiger sehr gut erklärt und ich konnte fast alle Programme nachbauen (Wär schön, wenn's sowas auch für .NET gäbe mit vielen Beispielprogrammen. Das hieß "Schritt für Schritt von Halvorson).
- Aber ich mach grad nen Crash-Kurs und bin jetzt bei Lekt. 7 und es sind immer noch nur Konsolenprogramme (Lekt. 7 von 10) und sehr viel Mathe... :P Da hätt ich gleich bei C od. Ruby bleiben können. Aber bald geht's ja endl. los mit "echten" Programmen. Ich möchte lieber was sehen, als nur Text zu lesen.
Aber jetzt hab ich's schon angefangen, also zieh ich's auch durch! Freu mich, wenn ich den Kurs endl. durch hab, dann kann ich mich mal drauf konzentrieren, was mich wirklich interessiert. (Auf jeden Fall keine Konsolenprogramme, lol! :P ) - Aber ich dachte auch schon dran, die alten VB 6 Programme in .NET zu übernehmen. Mal sehen, ob's funktioniert. Muss man da alles neu schreiben, od. gibt's nen Trick die zu konvertieren?
Schöne Grüße,
Sloorg! B) | |
| Re: Subroutine schreiben | | | | Autor: ErfinderDesRades | | Datum: 17.05.14 05:27 |
| oh jeh
Du hast echt Pech. Erstmal hast du dir lauter vb6-Zeugs beigebracht, was dir nun in .Net pausenlos im Weg steht. Weil in .Net wird **alles**, zu 100% anders gemacht als in vb6.
Mit den Strings hast du ja schon einen winzigen Vorgeschmack (Objekt-Methoden (OOP) versus Modul-Methoden), aber es gibt keinen Bereich - 0 - , bei dem es nicht ebenso fundamental konzeptionell anders wäre, ob nun Dateizugriffe, Fehlerbehandlung, Control-Arrays, Grafik, Internet-Zugriffe - du kannst einfach gucken, wohin du willst: Immer sieht es ein bischen so aus, als würde vb6 noch gehen, aber wenn dus dann **richtig** anfassen willst, musst du den vb6-Kram jedesmal wieder verwerfen.
Ich hab dir ja bereits empfohlen, den GeneralImport auf Microsoft.VisualBasic (wo der ganze vb6-Schrott drinne ist) - rauszunehmen, aber das wurde ja kunstreich zerredet, sodass du nicht mal dazu kamst, nachzufragen, was ein GeneralImport eigentlich ist - oder weißt du das etwa?
Ja, und ungefähr das gleiche ists mit der Konsole: Konsole-Programmierung ist ganz schwerpunktmäßig prozedural, und damit total unintuitiv, umständlich, und blendet eine Kern-Denkweise der .Net-Programmierung total aus:
nämlich ein interaktives Programm ist heutzutage vor allem **eventorientiert**.
Und das wird im VisualStudio ja fabelhaft unterstützt, da schmeißt du ein paar Buttons aufs Form, und behandelst deren Click-Events, oder behandelst das Form_Load-Event, oder Events beim Checken einer Checkbox, und und und...
Jede User-Interaktion findet über Events statt, nur bei Konsole nicht: Da hält das Programm an, und wartet auf eine Texteingabe (facepalm).
Und die ganzen Schleifen und verzweigungen und Textausgaben der Konsole-Wurstelei - du wirst dich später fragen, warum das alles so mühsam sein musste.
Jo, und wenn du ehrlich zu dir bist, wirst du feststellen: also im Grunde hätte es gar nicht gemusst...
naja egal.
Auch diese meine Einlassung wird aller Wahrscheinlichkeit nach wieder zerredet werden. Man wird sicher fabelhafte Argumente finden, warum vb6 eine gute Vorbereitung auf vb.net ist, und das Konsole-Programmierung Grundlagen bildet, die in Windows.Forms viel schwieriger zu bilden gewesen wären - lol!
(Rechtschreibfehler urheberrechtlich geschützt) | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 17.05.14 07:44 |
| Ja, da stimme ich dir größtenteils zu! Naja, ein paar Grundbegriffe aus VB kann ich hier in .NET ja noch verwenden, aber halt nicht allzuviel. Ich hatte ja auch nicht erwartet, dass mein dzt-iger Kurs hauptsächlich aus Konsolenprogrammen besteht... ich brauch eher was für's Auge - das gefiel mir an VB 6.0 damals im Gegensatz zu den Linux und Ruby-Verfechtern - die waren mir dann doch zu fanatisch... Bin vor 2 Jahren aus Ruby ausgestiegen...
Naja, ich zieh das erstmal durch, dann hab ich ja zumindest das Grundwissen über .NET... :P
Aber für nen grafikorientierten Typen wie mich sind Konsolenprogramme wohl das letzte, was ich brauche...
Salut, Sloorg! B) | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 17.05.14 07:47 |
| Ahja, hier die Lösung zu "Subroutine":
Imports System.Console
Module Module1
'Schreiben Sie eine Sub, der Sie eine natürliche Zahl als Anzahl und ein
' Zeichen
'übergeben und die das Zeichen Anzahl mal an den Bildschirm schreibt.
Public zahl, anzahl As Integer, zeichen As Char
Dim erg As String
Sub Main()
Write("Bitte natürliche Zahl eingeben: ")
zahl = ReadLine()
Write("Bitte ein Zeichen eingeben: ")
zeichen = ReadLine()
Anzeigen(zahl, zeichen)
Anzeigen(31, "-")
Anzeigen(31, "-")
Warten()
End Sub
Sub Anzeigen(ByVal anzahl, ByVal zeichen)
For i As Integer = 0 To anzahl - 1
Write(zeichen)
Next
WriteLine()
End Sub
Sub Warten()
Write("Bitte EINGABE drücken: ")
ReadLine()
End Sub
End Module... Das wär die Lösung gewesen... Aber etwas gelernt!
Bye, Sloorg! B) | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 17.05.14 08:20 |
| Welcome to the "Yellow Submarine"-Subroutine:
http://www.youtube.com/results?search_query=the+beatles+yellow+submarine+official+video
Dachte, das muss ich loswerden, is mir grad eingefallen, dieses Wortspiel!
Yours,
Sloorg. | |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 17.05.14 12:44 |
| Hallo!
Schade.
Eine Lösung ist Dir hier gezeigt worden.
Dieser Code ist ... [ZENSIERT]:
keine explizite Datentyp-Konvertierung,
keine Datentypen in der Parameterliste,
kein Abfangen von Fehleingaben,
unnötige Verwendung von modul-globalen Variablen,
unnötige Programmierung einer Subroutine. | |
| Re: Subroutine schreiben | | | | Autor: Sloorg | | Datum: 17.05.14 13:30 |
| Ich weiß, Manne,
- viele Wege führen nach Rom. Nur der Aufgabensteller hatte halt seinen eigenen... :P
Wär ohne eure Hilfe eh nicht draufgekommen. - Aber mir egal - hauptsache, es funzt, sag ich immer!
Aber war alles sehr lehrreich - man sieht, wie man die Aufgabe auf unterschiedliche Weise lösen konnte!
Nochmal merci!
| |
| Re: Subroutine schreiben | | | | Autor: Manfred X | | Datum: 17.05.14 14:16 |
| Nochmal:
Der von Dir gepostete Code ist keine brauchbare Variante einer Lösung.
Wenn ein Programm bestimmte Eingaben vom Benutzer erwartet, dann
muß im Code geprüft werden, ob sie dieser "Erwartung" entsprechen.
Das Programm erzeugt sonst Ausnahmen oder liefert sogar falsche oder
unbrauchbare Ergebnisse.
Typsicheres Programmieren (z.B. explizite Variablen-Deklaration und
Wert-Konvertierung) ist bei umfangreicheren Programmen ein wesentliches
Mittel, um Fehlermöglichkeiten zu reduzieren (z.B. IDE-Überwachung).
Das gilt auch für die Geltungsweite deklarierter Variablen.
Was nur lokal (in einer Routine) benötigt wird, ist auch dort zu deklarieren.
Es droht sonst Verwechslungsgefahr (und anderes!).
| |
 | Sie sind nicht angemeldet!
Um auf diesen Beitrag zu antworten oder neue Beiträge schreiben zu können, müssen Sie sich zunächst anmelden.
 Einloggen | Neu registrieren |
 |
|
Neu! sevPopUp 2.0 
Dynamische Kontextmenüs!
Erstellen Sie mit nur wenigen Zeilen Code Kontextmenüs dynamisch zur Laufzeit. Vordefinierte Styles (XP, Office, OfficeXP, Vista oder Windows 8) erleichtern die Anpassung an die eigenen Anwendung... Weitere InfosTipp des Monats TOP Entwickler-Paket 
TOP-Preis!!
Mit der Developer CD erhalten Sie insgesamt 24 Entwickler- komponenten und Windows-DLLs. Die Einzelkomponenten haben einen Gesamtwert von 1605.50 EUR...
Jetzt nur 599,00 EURWeitere Infos
|
April 2024
Sie sind aktuell nicht angemeldet.