Ich habe am Ende noch keinen Kommentar zu Ihrer expliziten zweiten Frage gesehen: "2: Ist dies zwingend genug, um über einen Wechsel zu C # nachzudenken, wenn der Fall VB.NET die Möglichkeiten, die ich mit Code habe, irgendwie einschränkt?"
Ich bevorzuge den Ansatz mit mehr Optionen, bei dem C # dem Programmierer die Wahl lässt, ob er die Optionen des Programmierers einschränkt. Ich bevorzuge C # sehr, aber allein für die Groß- und Kleinschreibung würde ich nicht einmal denken, dass es dem Erlernen einer Sprache nahe kommt, nur weil es die Groß- und Kleinschreibung berücksichtigt. Alle Funktionen sind wichtig, und wenn ich mir die Vorteile von C # und VB.NET anschaue, bevorzuge ich C #. Aber ich werde Ihnen eine wirklich ausgewogene Perspektive geben, voreingenommen ja, weil ich eine Präferenz habe, aber ich werde auch ehrlich über die Nachteile von C # sein.
Zunächst einmal haben beide Sprachen Vor- und Nachteile. Die Unterschiede, die Sie in einer Sprache machen können, die in der anderen nicht möglich sind, nehmen ab, da Microsoft zum Glück beide Sprachen verbessert und sie offenbar keine unfaire Parteilichkeit gegenüber beiden Sprachen zeigen.
Als C # zum ersten Mal herauskam, hatte VB keine XML-Kommentare, die man vor Methoden stellen konnte, die ich in C # geliebt habe. Ich hasste das in VB.NET. Aber ich habe im Laufe der Jahre gesehen, dass viele Funktionen, die nicht in einer Sprache verfügbar sind, zur anderen hinzugefügt werden. (Das gleiche Team von MS-Entwicklern entwickelt sowohl C # als auch VB. Daher ist es sinnvoll, dass die Funktionen ziemlich ähnlich werden.)
aber Sie haben gefragt, was C # hat, was VB nicht hat. Hier sind einige, an die ich sofort denken kann:
1: C # ist prägnanter und erfordert weniger Eingabe .. auf VIELE Arten! Ich habe sogar Dummheit gesehen, als die gegenteilige Behauptung aufgestellt wurde, dass VB das Tippen spart. Aber bitte hören Sie den Leuten zu, die Ihnen sagen, dass sie beide Sprachen verwenden, und keine wird von ihnen selten verwendet. Ich benutze sowohl C # als auchVB, C # zu Hause, weil es mir gefällt (und wenn ich bei der Arbeit mit C # arbeite), und meine neueren Jobanfragen, dass ich VB und nicht C # verwende. Daher benutze ich VB jetzt häufiger (seit ungefähr 10 Monaten), aber in meinem persönlichen Zeugnis bevorzuge ich C # sehr, und in Bezug auf die tatsächliche Eingabe ist VB wesentlich häufiger. Das einzige Beispiel, das ich gelesen habe, in dem jemand tatsächlich versucht hat zu sagen, dass VB prägnanter ist, war ein 'with ...'-Beispiel mit einer langen Variablen im with, sodass Sie in VB einfach' .property 'verwenden können. Dies ist eine Dummheit in der Behauptung, dass VB weniger Tippen benötigt. Es gibt einige Dinge (und nicht nur dieses Beispiel), bei denen VB kürzer ist, aber in der Praxis viel häufiger, wenn C # prägnanter ist.
Aber der Hauptgrund, warum ich glaube, dass C # prägnanter ist, sind die ausführlichen "IF / THEN" -Anweisungen von VB. wenn Aussagen häufig sind. In C # gibt es kein "Dann" -Wort zum Eingeben! :) Auch alle 'end ...' - Anweisungen müssen eingegeben werden, was in c # normalerweise nur eine schließende Klammer '}' ist. Ich habe gelesen, dass einige Leute behaupten, dass diese Ausführlichkeit in VB.NET ein Vorteil für VB ist, da mehrere schließende Blockanweisungen / Symbole verschachtelt werden können und unmittelbar nebeneinander enden, aber ich bin völlig anderer Meinung. Eine Person kann fast immer ein Programm besser in C # oder VB schreiben als ein anderer Programmierer, da die nächste Code-Revision besser gestaltet werden könnte. Dies gilt für die 'Verwirrung zahlreicher schließender Klammern in C #'. Wenn die verschachtelten Blöcke alle vom gleichen Typ sind wie mehrere verschachtelte IFs, hat VB das gleiche Problem wie in C #. Dies ist in VB kein Vorteil. Genau in dieser Situation möchte ich kommentieren, was mein Schlusssymbol oder meine Schlusserklärung in beiden Sprachen beinhaltet. Ja, dies ist ausführlicher, aber in beiden Sprachen haben Sie die Möglichkeit, klar zu sein, was in urteilsbasierten, situationsspezifischen Fällen wichtig ist. Ich denke, Code Klarheit ist sehr wichtig.
2: VB hat keine mehrzeiligen Kommentare. Als ich mit VB gearbeitet habe, hatte ich nichts dagegen. dann ging ich zu ein paar Sprachen im C-Stil. Jetzt bin ich zurück und benutze hauptsächlich VB.NET bei der Arbeit. Ich vermisse sie. Es ist nur etwas, das Sie bequem finden und dann verlieren müssen. :((
3: VBs 'andalso' und 'orelse' sind ziemlich ärgerlich, wenn man in C # einfach '&&' und '||' schreibt. wieder weniger tippen. Dies ist in meinem Code sowohl in VB als auch in C # nicht selten. Wenn für die Funktionalität 'OR' vs 'OrElse' normalerweise keine Rolle spielt, außer dass 'OrElse' für den Computer schneller ist. Wenn ein Programmierer also nur 'Or' und 'And' in VB verwendet, erzeugt er weniger optimalen Code für Jemand, der Klarheit des Codes mag. 'Or' ist viel einfacher zu überfliegen als 'OrElse'.
4: Mehr Flexibilität bei der Code-Platzierung in C #. Wenn eine Zeile lang ist und Sie sie in die nächste Zeile einschließen möchten, hasse ich es, wenn VB.NET meinen Code "kontrolliert". C # macht es ein wenig, aber ich finde es nützlicher in C #, wo es in VB viel kontrollierender ist. Dies ist jedoch eher die VB.NET-IDE als die C # -IDE als die Sprache selbst. aber ich weiß nicht, ob Sie beide oder nur die Sprachfunktionen ohne IDE-Unterschiede wollen.
5: Eine, die ich wirklich vermisse, ist das Erstellen eines neuen Codeblocks in C #. In einer Methode passiert möglicherweise viel, und ich möchte eine Variable in einem sehr kleinen Codeblock deklarieren, aber diese Variable nicht außerhalb dieses Blocks deklarieren die gesamte Methode. In C # können wir einfach einen neuen Block mit '{' erstellen und ihn mit '}' beenden. VB hat keine solche Funktion, aber die engste Übereinstimmung besteht aus einem bedingungslosen Block "If True Then" und "End If". (Beachten Sie erneut das 2-stellige C # gegenüber dem 18-stelligen VB.NET-Äquivalent ... mehr Eingabe in VB.)
6: Selbstinkrementierungs- und Dekrementierungsoperatoren: ++ und - wie in myVariable++oder ++myVariableoder den entsprechenden Dekrementierungsversionen. das ist sehr praktisch ... manchmal. Hier ist ein Beispiel für tatsächlichen Code, als ich C # sehr vermisst habe:
// C#:
while (txt.Length > x)
{
thisChar = txt[x];
if (charsAllowedWithoutLimit.Contains(thisChar)) { ++x; }
else if (allowLettersWithoutLimit && char.IsLetter(thisChar)) { ++x; }
else if ((x2 = charsAllowedWithLimit.IndexOf(thisChar)) >= 0)
{
++x; if (++usedCountA[x2] > charAllowedLimit[x2]) { break; }
}
else { break; }
}
' VB.NET:
While (txt.Length > x)
thisChar = txt(x)
If (charsAllowedWithoutLimit.Contains(thisChar)) Then
x += 1
ElseIf (allowLettersWithoutLimit AndAlso Char.IsLetter(thisChar)) Then
x += 1
Else
x2 = charsAllowedWithLimit.IndexOf(thisChar)
If (x2 >= 0) Then
x += 1
usedCountA(x2) += 1S
If usedCountA(x2) > charAllowedLimit(x2) Then Exit While
Else
Exit While
End If
End If
End While
Und um ein SEHR gutes Beispiel zu geben, in dem C # regiert, ist dies mehr Code, den ich kürzlich persönlich geschrieben habe:
// C#
public static bool IsNotWithin(this Byte v, Byte v1, Byte v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this SByte v, SByte v1, SByte v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this Int16 v, Int16 v1, Int16 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this Int32 v, Int32 v1, Int32 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this Int64 v, Int64 v1, Int64 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this UInt16 v, UInt16 v1, UInt16 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this UInt32 v, UInt32 v1, UInt32 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this UInt64 v, UInt64 v1, UInt64 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this Decimal v, Decimal v1, Decimal v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsWithin(this Byte v, Byte v1, Byte v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this SByte v, SByte v1, SByte v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this Int16 v, Int16 v1, Int16 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this Int32 v, Int32 v1, Int32 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this Int64 v, Int64 v1, Int64 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this UInt16 v, UInt16 v1, UInt16 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this UInt32 v, UInt32 v1, UInt32 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this UInt64 v, UInt64 v1, UInt64 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this Decimal v, Decimal v1, Decimal v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
' And the VB equivalent is a mess! Here goes:
<Extension()>
Public Function IsNotWithin(v As Byte, value1 As Byte, value2 As Byte) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
<Extension()>
Public Function IsNotWithin(v As SByte, value1 As SByte, value2 As SByte) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
<Extension()>
Public Function IsNotWithin(v As Int16, value1 As Int16, value2 As Int16) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
' the % suffix means 'As Integer' in VB.
<Extension()>
Public Function IsNotWithin(v%, value1%, value2%) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
' the & suffix means 'As Long' in VB.
<Extension()>
Public Function IsNotWithin(v&, value1&, value2&) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
<Extension()>
Public Function IsNotWithin(v As UInt16, value1 As UInt16, value2 As UInt16) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
<Extension()>
Public Function IsNotWithin(v As UInt32, value1 As UInt32, value2 As UInt32) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
<Extension()>
Public Function IsNotWithin(v As UInt64, value1 As UInt64, value2 As UInt64) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
' the @ suffix means 'As Decimal' in VB.
<Extension()>
Public Function IsNotWithin(v@, value1@, value2@) As Boolean
Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function
<Extension()>
Public Function IsWithin(v As Byte, value1 As Byte, value2 As Byte) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
<Extension()>
Public Function IsWithin(v As SByte, value1 As SByte, value2 As SByte) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
<Extension()>
Public Function IsWithin(v As Int16, value1 As Int16, value2 As Int16) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
' the % suffix means 'As Integer' in VB.
<Extension()>
Public Function IsWithin(v%, value1%, value2%) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
' the & suffix means 'As Long' in VB.
<Extension()>
Public Function IsWithin(v&, value1&, value2&) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
<Extension()>
Public Function IsWithin(v As UInt16, value1 As UInt16, value2 As UInt16) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
<Extension()>
Public Function IsWithin(v As UInt32, value1 As UInt32, value2 As UInt32) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
<Extension()>
Public Function IsWithin(v As UInt64, value1 As UInt64, value2 As UInt64) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
' the @ suffix means 'As Decimal' in VB.
<Extension()>
Public Function IsWithin(v@, value1@, value2@) As Boolean
Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function
Vielleicht ist dies ein ausreichender Beweis dafür, dass C # prägnanter ist. Aber nicht alle Programmierer mögen Prägnanz. Einige lesen lieber "wenn a <b dann ...", weil es für ihre menschliche Sprache natürlicher ist. Und das ist gut so. Einstellungen sind in Ordnung. Für mich ist Handarbeit ein Faktor, den ich schätze, und ich denke, jeder kann sich daran gewöhnen, in beliebigen Symbolen zu denken, die er bevorzugt, denn "wenn" und "dann" sind Symbole eines Alphabets und C # 's "if (Bedingung) -Anweisung"; Syntax sind auch Symbole. Einer ist der Syntax eines Nicht-Programmierers näher als der andere. Ich bevorzuge die prägnante.
Ich denke auch, dass es ärgerlich ist, 'c' nach Zeichenliteralen in VB zu verwenden, um es zu einem Zeichenliteral und nicht zu einer Zeichenfolge zu machen. Ich mag die Prägnanz von C # viel mehr. Wenn für eine Methode ein Zeichenliteral erforderlich ist, müssen Sie ein Zeichen und keine Zeichenfolge mit einer Zeichenlänge angeben. Daher müssen Sie manchmal ":"cin VB verwenden, während dies in C # der Fall ist ':'. Ich denke, das ist kein Problem.
Um fair zu sein, werde ich sagen, dass es für VB Vorteile gibt, wie zum Beispiel, dass ich nach Methodenaufrufen keine leeren Klammern setzen muss, z. B. Dim nameUpper$ = name.ToUpperInvariantwenn C # die leeren Klammern benötigt : string nameUpper = name.ToUpperInvariant(). oder doppelt so hoch wie es zu Besatz: Dim nameUpper$ = name.Trim.ToUpperInvariantvs string nameUpper = name.Trim().ToUpperInvariant(). Ich mag VBs prägnante Verwendung dessen, wie ich es $oben verwendet habe, um es als Zeichenfolge zu dimmen, wobei C # diese Verknüpfungen nicht hat. VB hat diese Verknüpfungen für die Typen String, Integer, Long, Decimal, Single und Double, aber der Nachteil ist, dass sie weniger klar sind, daher verwende ich sie mit Vorsicht. Trotzdem bevorzuge ich prägnanten Code.
Nun, das sind nur ein paar Gedanken von diesem erfahrenen Programmierer, und wenn ich bedenke, ist dies mein Programmierzeugnis von C # gegen VB. beide sind meiner meinung nach nette sprachen. aber ja, ich bevorzuge immer noch C #.
ps Da ich vorhabe, den größten Teil meines Lebens zu programmieren, habe ich sogar wieder gelernt, mit der effizientesten Tastatur zu tippen: der Dvorak-Tastatur, die etwa 1/3 des Aufwandes für die Eingabe von Englisch erfordert als mit einer QWERTY-Tastatur. Schlag es nach. Vielleicht möchten Sie auch wechseln. ;) es hat mir das Tippen um 67% erleichtert! :) Ich ermutige jeden, über den Tellerrand hinaus zu denken und eine bessere Effizienz Ihrer Arbeit zu bewerten. Das Dvorak Simplified Keyboard Layout und C # haben dies für mich getan. :) :)
PSS Ich würde Dvorak und C # mit Metrik vergleichen, im Gegensatz zum QWERTY-Tastaturlayout und VB mit den empirischen Messungen. Dvorak, Metrik und C # sind nur "sauber". ABER VB ist nicht wirklich weit dahinter. Es muss jedoch abwärtskompatibel zu altem VB6-Code und Pre-.NET-Code sein, wie z. B. 'Or' vs 'OrElse' und 'IIF ()'.
Ich beende mit Vorsicht. Seien Sie bitte vorsichtiger, als Menschen zuzuhören, die nicht wirklich wissen, wovon sie sprechen. Die Hälfte aller Nachteile gegen VB und C # sind es nichtEs gibt immer noch Probleme, und die Leute schreiben immer noch, dass sie nicht wissen, welche Nachteile es in der Sprache wirklich noch gibt. Das beste Beispiel, das ich mir vorstellen kann, sind XML-Kommentare für Methoden, die dreifaches Apostroph in VB oder dreifache Schrägstrich-Kommentarsymbole in C # verwenden. Aber bitte erkennen Sie selbst, ob eine Person aus Unwissenheit oder aus Erfahrung spricht. Persönliches Zeugnis bedeutet, dass sie es aus ihrer realen Erfahrung wissen. Und wenn jemand viel Erfahrung damit hat, dann lege die Ohren auf. Ich habe mehr als 10 Jahre Erfahrung in C # und VB. Und es läuft darauf hinaus: Beide sind (sehr) gute Sprachen. Und die meisten Unterschiede können Sie sofort innerhalb von 5 Minuten nach dem Lesen des Codes sehen. Aber ja, bei anderen Merkmalen kann es Jahre dauern, bis ein Handicap gefunden wird. Und ein Handicap, das mir bekannt ist (in C #), kann ich ' Ich denke nicht einmal an eine reale Lebenssituation, in der es nützlich wäre. Vielleicht ist es doch kein Handicap.
Viel Spaß beim Codieren!