wake-up-neo.com

Ist VB wirklich case unempfindlich?

Ich versuche nicht, hier ein Argument anzufangen, aber aus irgendeinem Grund wird normalerweise behauptet, dass Visual Basic zwischen Groß- und Kleinschreibung unterscheidet und C-Sprachen nicht (und irgendwie ist das eine gute Sache).

Aber hier ist meine Frage: Wo ist die Groß- und Kleinschreibung von Visual Basic nicht genau? Wenn ich schreibe ...

Dim ss As String
Dim SS As String

In der Visual Studio 2008 oder Visual Studio 2010 IDE wurde in der zweiten IDE die Warnung "Lokale Variable SS ist bereits im aktuellen Block deklariert" angezeigt. In der VBA-VBE tritt ein Fehler nicht sofort auf, sondern es wird nur der Fall automatisch korrigiert.

Fehlt hier etwas mit diesem Argument, dass Visual Basic nicht zwischen Groß- und Kleinschreibung unterscheidet? (Auch wenn Sie wissen oder eine Antwort wünschen, warum wäre das eine schlechte Sache?)

Warum stelle ich diese Frage überhaupt?

Ich verwende Visual Basic seit vielen Jahren in vielen seiner Dialekte, manchmal als Hobbyist, manchmal für kleine Unternehmensbezogene Programme in einer Arbeitsgruppe. Seit den letzten sechs Monaten habe ich an einem großen Projekt gearbeitet, viel größer als ich erwartet hatte. Ein großer Teil des Beispielquellcodes da draußen ist in C #. Ich habe kein brennendes Verlangen, C # zu lernen, aber wenn es __. Dinge gibt, verpasse ich das C # Bietet an, dass Visual Basic dies nicht tut (ein Gegenteil Wäre VB.) .NET bietet XML ​​Literals ) an, dann würde ich gerne mehr über diese Funktion erfahren. Daher wird in diesem Fall häufig argumentiert, dass die Sprachen C Zwischen Groß- und Kleinschreibung unterscheiden und Das ist gut, und in Visual Basic ist die Groß-/Kleinschreibung __ nicht beachtlich und das ist schlecht. Ich würde gerne wissen...

  1. wie genau ist Visual Basic Groß- und Kleinschreibung wird nicht berücksichtigt, da jeder einzelnes Beispiel im Code-Editor wird case sensitive (Bedeutung case wird korrigiert) ob ich es oder nicht und
  2. ist dies zwingend genug für mich, zu C # zu wechseln, falls VB.NET case irgendwie einschränkt, was ich mit Code tun könnte.
112
Todd Main

Der Unterschied zwischen VBA und VB.NET besteht nur deshalb, weil VB.NET kontinuierlich im Hintergrund kompiliert wird. Beim Kompilieren des VBA wird eine Fehlermeldung angezeigt.

Wie Jonathan sagt , können Sie sich bei der Programmierung von VB.NET neben String-Vergleichen, XML und einigen anderen Situationen als Groß- und Kleinschreibung unterscheiden.

Ich denke, Sie interessieren sich für das, was sich unter der Haube befindet. Nun, die .NET Common Language Runtime ist Groß- und Kleinschreibung wird berücksichtigt, und der VB.NET-Code hängt von der Laufzeit ab. Sie können also feststellen, dass zur Laufzeit zwischen Groß- und Kleinschreibung unterschieden wird, z. wenn es nach Variablen und Methoden sucht.

Mit dem VB.NET-Compiler und -Editor können Sie das ignorieren, weil sie in dem Fall korrigieren in Ihrem Code.

Wenn Sie mit dynamischen Funktionen oder mit dem Late-Binding (Option Strict Off) herumspielen, können Sie nachweisen, dass die zugrunde liegende Laufzeit die Groß- und Kleinschreibung berücksichtigt. Eine andere Möglichkeit, dies zu erkennen, besteht darin, zu erkennen, dass Sprachen, die die Groß- und Kleinschreibung berücksichtigen, wie C #, dieselbe Laufzeitumgebung verwenden, sodass die Laufzeitumgebung offensichtlich die Groß- und Kleinschreibung berücksichtigt.

EDIT Wenn Sie die IDE aus der Gleichung entfernen möchten, können Sie immer von der Befehlszeile aus kompilieren []. Bearbeiten Sie Ihren Code in Notepad so, dass er ss und SS hat, und sehen Sie, was der Compiler macht.

EDIT Zitat aus Jeffrey Richter in den .NET Framework-Entwurfsrichtlinien Seite 45.

Um klar zu sein, ist die CLR eigentlich Groß- und Kleinschreibung Einige Programmierung Sprachen wie Visual Basic sind der Fall unempfindlich. Wenn der Visual Basic-Compiler .__ ist. Versuch, einen Methodenaufruf an eine .__ aufzulösen. Typ, der in einer Groß-/Kleinschreibung definiert ist In einer Sprache wie C # ermittelt der Compiler (nicht die CLR) den tatsächlichen Fall des Methodennamens und bettet ihn in .__ ein. Metadaten. Die CLR weiß nichts über diese. Nun, wenn Sie Reflection verwenden an eine Methode zu binden, die Reflexion APIs bieten die Möglichkeit, Suchvorgänge ohne Berücksichtigung der Groß- und Kleinschreibung. Dies ist das Inwiefern bietet die CLR Groß- und Kleinschreibung.

100
MarkJ

Ein Teil des Problems besteht darin, dass Sie die Sprache von der Erfahrung mit IDE trennen müssen.

Als Sprache ist VB.NET sicherlich ein Fall, der in Bezug auf Bezeichner unempfindlich ist. Wenn Sie DateTime.Parse und datetime.parse aufrufen, wird derselbe Code gebunden. Im Gegensatz zu Sprachen wie C # können keine Methoden oder Typen definiert werden, die sich nur von Fall zu Fall unterscheiden.

Als IDE versucht VB.NET, den Fall vorhandener Bezeichner beizubehalten, wenn es einen Codeblock auflistet. Hübsche Listen werden immer dann angezeigt, wenn Sie die aktuelle logische Codezeile verlassen. In diesem Fall verlässt man die zweite Deklaration von SS. Das hübsche Lister bemerkt, dass es einen Bezeichner mit diesem Namen gibt, und korrigiert ihn, um übereinstimmende Fälle zu erhalten.

Dieses Verhalten wird jedoch nur als Benutzerwert hinzugefügt. Es ist kein Teil der Kernsprache.

21
JaredPar

VB ist meist Groß-/Kleinschreibung unempfindlich, es gibt jedoch Ausnahmen. Beispielsweise ist bei XML-Literalen und beim Verstehen die Groß- und Kleinschreibung zu beachten. String-Vergleiche sind im Gegensatz zu beispielsweise T-SQL in der Regel zwischen Groß- und Kleinschreibung unterschieden. Und natürlich gibt es Edge-Fälle beim Umgang mit Vererbung, COM und Dynamic Language Runtime.

16
Jonathan Allen

Ja, der VB.NET-Compiler behandelt Kennungen unabhängig von der Groß- und Kleinschreibung. Und ja, das kann Probleme verursachen, wenn Baugruppen verwendet werden, die in einer anderen Sprache geschrieben wurden oder COM-Komponenten verwenden. Der erste Fall wird durch die Common Language Specification abgedeckt. Die relevante Regel lautet:

Für zwei Bezeichner Sie müssen sich deutlich voneinander unterscheiden als nur ihr Fall.

Der COM-Fall wird vom Typbibliothek-Builder ziemlich grob behandelt, er zwingt das Gehäuse von Bezeichnern mit demselben Namen, um identisch zu sein. Auch wenn diese Bezeichner unterschiedliche Rollen haben. Mit anderen Worten, ein Methodenparameter mit dem Namen "Index" erzwingt, dass der Methodenname "Index" auf "Index" zurückgesetzt wird. Das hat ziemlich viel Kopfkratzer hervorgebracht, wie man sich vielleicht vorstellen könnte :)

9
Hans Passant

VB ist case bewahrend (in der IDE), aber case insensitive. Es ist gewissermaßen wie das Windows-Dateisystem. Hello.txt und hello.txt werden als derselbe Dateiname betrachtet.

Die IDE geht davon aus, dass die Deklaration einer Variablen der "richtige" Fall für diese Variable ist, und passt jede Instanz dieser Variablen an die Deklaration an. Dies geschieht aus Gründen der Augenweide und der Beständigkeit, nicht jedoch der Funktionalität. 

Ich habe mehrere Fälle gesehen, in denen der Fall nicht automatisch an die Deklaration angepasst wurde, und die Anweisung funktioniert genauso. Sie können auch einen beliebigen Texteditor verwenden, um Code zu schreiben, der sich in verschiedenen Fällen gut kompilieren lässt. 

Eine Randnotiz:

Die meisten PEOPLE denken unabhängig von der Groß- und Kleinschreibung. Wenn wir das Wort "Hund" sehen, wird das Wort in unseren Gedanken in Bedeutung übersetzt. Die Bedeutung des Wortes beruht nicht auf dem Fall (d. H. Unabhängig davon, ob die Wörter "DOG", "DoG" oder "DOG" noch bellen.) COMPUTER sehen Wörter als diskrete Taschen von Bits. Groß- und Kleinbuchstaben sind unterschiedliche Bitmuster und daher unterschiedlich.

Da die meisten Programmierer Menschen sind, scheint die Fallunempfindlichkeit eher an die Denkweise der Menschen angepasst zu sein. Bei der Fallempfindlichkeit geht es eher um Menschen, die ihre Denkweise an die Einschränkungen einer Maschine anpassen.

6
Andrew Neely

Dies ist Teil des von Ihnen verwendeten Editors. Sie verhalten sich möglicherweise anders, aber die Tatsache ist, dass Visual Basic wirklich ist die Groß- und Kleinschreibung nicht beachtet. ss und SS sind also gleich.

Weitere Informationen finden Sie im VB.NET Basics-Tutorial :)

5
Sarfraz

Ich bin nicht sicher, ob ich dich verstehe. VB unterscheidet nicht zwischen Groß- und Kleinschreibung, dh ss und SS sind die gleichen Variablen. Der Compiler beschwert sich daher zu Recht, dass Sie die Variable erneut deklariert haben.

Ich denke, dass Variablen nicht zwischen Groß- und Kleinschreibung unterscheiden, sondern Funktionsnamen.

3
Michael Stum

Ja, VB unterscheidet nicht zwischen Groß- und Kleinschreibung. Es wirft manchmal diejenigen, die es nicht gewohnt sind, für eine kleine Schleife.

1
Xorlev

Ich kann dies nur anbieten, was, wie ich mich an meine Programmierbücher in den frühen 80er Jahren erinnere, darin besteht, dass die Sprachversionen (damals) unbedingt dazu gedacht waren, Fehler bei der Kompilierung zu reduzieren. Das heißt, die "Strenge" sollte eine Kodierungsdisziplin mit größerer Genauigkeit entwickeln. Wie sich herausstellte, hat sich das Hinzufügen einer korrekten Kennzeichnung von Variablen, Klassen, Methoden, Funktionen und was auch immer Sie sonst noch einfügen wollen, weiterentwickelt. 

Ich erinnere mich daran, dass fast alle diese Bücher ein empfohlenes Muster für führende Kapitalisierung, Kleinbuchstaben usw. enthielten. Wie wir alle wissen, wurde ein großer Teil davon weggeworfen oder sollte ich sagen, in der Praxis außer in den High-End-Produktionshäusern ignoriert CASE-Lösungen oder für diejenigen, die ein höheres Qualifikationsniveau erreicht haben. Ich denke, jeder erlebt diese Lernkurve. 

Angesichts des Fortschritts dieser Sprachen und IDEs stellt sich die bessere Frage, welche Sprache meine Entwicklungszeit verbessert. Wenn Sie nicht mit den verschiedenen Langsignalen vertraut sind, sind Ihre Optionen natürlich begrenzt.

1
htm11h

In VB.NET muss man sich nicht allzu sehr bemühen, Code mit unterschiedlichen "Schreibweisen" in Groß-/Kleinschreibung eines Bezeichners zu erstellen. Wenn Sie das Gehäuse eines Bezeichners in der Datei ändern, in der es deklariert wurde, ohne die Funktion "Umbenennen" zu verwenden, wird der Name nicht in anderen Dateien aktualisiert. Wenn Sie jedoch eine Zeile bearbeiten, die den Namen enthält, wird die aktuelle Definition verwendet.

Auf diese Weise kann man feststellen, dass VB.NET die Groß- und Kleinschreibung nicht beachtet, aber es macht die CLR verfügbar, die diese Informationen für Groß- und Kleinschreibung verwenden kann.

1
supercat

Ich werde versuchen, deine zweite Frage zu beantworten.

"Ist das zwingend genug für mich, zu C # zu wechseln, wenn der Fall VB.NET irgendwie die Möglichkeiten für Code einschränkt?" 

Erstellen Sie einen WCF-WebService mit C #. Erstellen Sie einen DataContract (1 Klasse). Eine mit der Eigenschaft "String-E-Mail". Eine andere mit "String Email" als andere Eigenschaft. Ihre Wahl als persönliche E-Mail oder Büro-E-Mail zu verstehen. Oder es könnte sich um zwei verschiedene DataContracts handeln.

Für C # ist das in Ordnung. Der Webservice ist gut angelegt. Ein C # -Programm kann leicht eine WSDL erstellen und alles ist in Ordnung.

Versuchen Sie nun, eine WSDL mit VB (beliebige Version) zu erstellen. Es wird angezeigt, dass "E-Mail" bereits deklariert ist und die WSDL-Generierung fehlschlägt.

Wie jeder, den ich angenommen habe, ist dies ein Nachteil in der Sprache VB. Aber!!!

Verwenden Sie FxCOP und analysieren Sie den ursprünglichen C # -Code. Laut FxCOP ist die Verwendung von E-Mail/E-Mail ein Problem. Empfiehlt die Verwendung eines anderen Namens, der die Groß- und Kleinschreibung unterstützt. Das .NET-Framework verfügt über 106 Programmiersprachen und es gibt viele Sprachen, bei denen die Groß- und Kleinschreibung beachtet wird. Wir bewegen uns alle in Richtung Cloud und möchten, dass unsere Dienste für alle Programmierplattformen/-sprachen verfügbar sind.

Wenn Sie zwischen Groß- und Kleinschreibung unterscheiden, entscheiden Sie sich für Ihr Programm und wenn Sie ein C-Typ sind, möchten Sie dies. Wenn das Programm von anderen Nicht-C-Programmen verwendet wird/wird, müssen Sie die Groß-/Kleinschreibung berücksichtigen, aber Ihre Sprache ist Ihre Wahl.

http://en.wikipedia.org/wiki/Comparison_of_C_Sharp_and_Visual_Basic_.NEThttp://www.vbrad.com/article.aspx?id=65

1
Venkat

VB.NET unterscheidet zwischen Groß- und Kleinschreibung.

Beispiele:

1.

Dim a As Integer
Dim A as Integer

Sub b()
    'Some statement(s) here
End Sub
Sub B()
    'Some statement(s) here
End Sub

3.

Function c() As Integer
    'Some statement(s) here
End Function
Function C() As Integer
    'Some statement(s) here
End Function

Alle diese Codes werfen einen COMPILE-TIME-FEHLER .

Für das erste Beispiel wird ein Fehler angezeigt, der besagt, dass die lokale Variable 'A' bereits im aktuellen Block deklariert ist.

Während für das zweite und dritte Beispiel der Fehler angezeigt wird, dass "Public Sub b ()" mehrere Definitionen mit identischen Signaturen hat. " und "Public Function c() As Integer" hat mehrere Definitionen mit identischen Signaturen. ".

Beachten Sie bei diesen Fehlern, dass die Fehler für Variablen und Prozeduren/Funktionen an unterschiedlichen Positionen ausgegeben werden. Bei Variablen wird bei der 2. Deklaration ein Fehler ausgegeben, bei Prozeduren/Funktionen bei der 1. Deklaration/Definition eines identischen Codes.

Wie von einem Benutzer in einem Kommentar oben erwähnt, wird der VB.NET-Code kontinuierlich im Hintergrund überprüft und/oder korrigiert. Sie können diesen Fehler im Fenster "Fehlerliste" in VS IDE sehen. Und da dies ist ein Fehler und NOT A WARNING , wird der Code nicht kompiliert, bis der Fehler behoben ist.

0
Nikunj Bhatt

Das Ausblenden von Symbolen (z. B. lokales Ausblendungsfeld) ist unabhängig von der Groß- und Kleinschreibung.

Hier ist ein Beispiel :

Public Class C
    Public Name As String

    Public Function M(name As String) As Boolean
        Return String.Equals(name, Name) ' case differs
    End Function
End Class

Die Ausgabe des VB.NET-Compilers wird in das folgende C # dekompiliert (und entspricht daher diesem):

public class C
{
    public string Name;

    public bool M(string name)
    {
        return string.Equals(name, name); // both lowercase
    }
}

string.Equals wird das Feld zweimal übergeben. Das Lokal ist unabhängig vom Fall versteckt. Die Sprache unterscheidet nicht zwischen Groß- und Kleinschreibung.

Um explizit auf ein Element wie dieses Feld zu verweisen, müssen Sie das Mitglied über Me dereferenzieren:

Return String.Equals(name, Me.Name) ' differentiate field from local
0
Drew Noakes

Ich habe noch niemanden gesehen, der Ihre explizite zweite Frage am Ende kommentiert: "2: Ist dies zwingend genug, um einen Wechsel zu C # in Betracht zu ziehen, wenn der VB.NET-Fall irgendwie einschränkt, was ich mit Code tun könnte?"

ich bevorzuge den Ansatz mit mehr Optionen, bei dem der Programmierer in C # entscheiden kann, ob er die Optionen des Programmierers einschränkt oder nicht. Ich bevorzuge sehr C #, aber allein wegen der Groß- und Kleinschreibung würde ich nicht glauben, dass es dem Erlernen einer Sprache nahe kommt, nur weil die Groß- und Kleinschreibung beachtet wird. Auf alle Funktionen kommt es an, und wenn ich mir die Vorteile von C # und VB.NET anschaue, bevorzuge ich C #. Aber ich gebe Ihnen eine ausgewogene Perspektive, voreingenommen ja, weil ich eine Präferenz habe, aber ich werde ehrlich zu den Nachteilen 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 gemacht werden können, schwinden, da Microsoft glücklicherweise beide Sprachen verbessert, und sie scheinen keine unfaire Vorliebe für beide Sprachen zu zeigen.

als C # zum ersten Mal herauskam, hatte VB keine XML-Kommentare, die Sie vor Methoden setzen konnten, 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. (Dasselbe Team von MS-Entwicklern entwickelt sowohl C # als auch VB. Daher ist es sinnvoll, dass die Funktionen sich sehr ähnlich werden.)

aber Sie haben gefragt, was C # nicht hat VB. Hier sind einige, an die ich sofort denken kann:

1: C # ist prägnanter und erfordert auf VIELE Weisen weniger Eingaben. Ich habe sogar Dummheit beim Sprechen gesehen, als die gegenteilige Behauptung aufgestellt wurde, dass VB das Tippen erspart. Aber bitte hören Sie den Leuten zu, die Ihnen mitteilen, dass sie beide Sprachen verwenden und keine von ihnen selten verwendet wird. Ich verwende sowohl C # nd VB, C # zu Hause, weil es mir gefällt (und wenn ich mit C # bei der Arbeit arbeite), als auch meine neueren Jobanforderungen, die ich verwende VB und nicht C #. Daher verwende ich jetzt VB häufiger (seit ungefähr 10 Monaten), aber meiner persönlichen Aussage nach bevorzuge ich C #, und in Bezug auf die tatsächliche Eingabe ist VB erheblich typischer . Das einzige Beispiel, in dem ich gelesen habe, dass jemand tatsächlich versucht hat, VB als prägnanter zu bezeichnen, war das Geben eines 'mit ...' - Beispiels mit einer langen Variablen im mit, also könnte man in VB einfach 'verwenden. Eigentum'. Dies ist eine Dummheit, wenn man behauptet, dass VB weniger Tipparbeit benötigt. Es gibt ein paar Dinge (und nicht nur dieses Beispiel), bei denen VB kürzer ist, sondern 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 üblich sind. in c # gibt es kein 'dann' wort zum tippen! :) Auch bei allen 'end ...' - Anweisungen ist die Eingabe in c # normalerweise nur eine schließende Klammer '}' erforderlich. Ich habe gelesen, dass einige Leute behaupten, dass diese mehr Ausführlichkeit in VB.NET ein Vorteil für VB ist, da mehrere schließende Blockanweisungen/-symbole verschachtelt sein und unmittelbar nebeneinander enden können, aber ich stimme dem nicht zu. Eine Person kann fast immer ein Programm besser in C # oder VB schreiben als ein anderer Programmierer, da die nächste Coderevision besser gestaltet werden könnte. Dies gilt auch für die "Verwirrung zahlreicher schließender Klammern in C #". Wenn die verschachtelten Blöcke alle vom selben Typ sind wie mehrere verschachtelte IFs, hat VB das gleiche Problem wie in C #. Dies ist in VB kein Vorteil. genau aus diesem grund möchte ich kommentieren, wofür mein schließsymbol oder meine abschließende aussage in beiden sprachen steht. Ja, dies ist ausführlicher zu tun, aber in beiden Sprachen haben Sie die Möglichkeit, klar zu sein, was in urteilsbasierten, situationsspezifischen Fällen wichtig ist. ich denke, dass Code-Klarheit ziemlich wichtig ist.

2: VB enthält keine mehrzeiligen Kommentare. Als ich mit VB gearbeitet habe, hatte ich nichts dagegen. dann habe ich ein paar sprachen im c-stil besucht. Jetzt arbeite ich wieder hauptsächlich mit VB.NET und ich vermisse sie. Es ist nur etwas, das Sie für bequem halten und dann verlieren müssen. :(

3: VBs "andalso" und "orelse" ist ziemlich ärgerlich, all das zu tippen, wenn es in C # einfach "&&" und "||" ist. wieder weniger tippen. Dies ist in meinem Code sowohl in VB als auch in C # nicht selten. Wenn irgendetwas, für die Funktionalität, 'OR' gegen '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, dann 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 der nächsten Zeile umbrechen 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 VB.NET IDE als 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 ist möglicherweise eine Menge passiert, und ich möchte eine Variable in einem sehr kleinen Codeblock deklarieren, aber nicht, dass diese Variable außerhalb dieses Blocks in deklariert wird 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 größte Übereinstimmung besteht in einem unbedingten "Wenn wahr, dann" - und "End wenn" -Block. (Beachten Sie das 2-stellige C # gegen das 18-stellige VB.NET-Äquivalent. Weitere Eingabe in VB.)

6: Selbstinkrementierungs- und Dekrementierungsoperatoren: ++ und - wie in _myVariable++_ oder _++myVariable_ oder den entsprechenden Dekrementierungsversionen. das ist sehr praktisch ... manchmal. Hier ist ein Beispiel für den 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 nur ein SEHR gutes Beispiel für C # -Regeln zu geben: Dies ist 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([email protected], [email protected], [email protected]) 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([email protected], [email protected], [email protected]) 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 der Handaufwand ein Faktor, den ich schätze, und ich glaube, jeder kann sich daran gewöhnen, in beliebigen Symbolen zu denken, denn "if" und "then" sind Symbole eines Alphabets und die "if (condition)" - Anweisung von C #. Syntax sind auch Symbole. Eine ist der Syntax eines Nicht-Programmierers näher als die 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 anstatt 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 _":"c_ in VB verwenden, während es in C # _':'_ ist. . Ich denke, das ist ein Trottel.

Um fair zu sein, möchte ich sagen, dass es Vorteile gibt, die ich mag, wenn VB nach Methodenaufrufen keine leeren Klammern setzen muss, wie _Dim nameUpper$ = name.ToUpperInvariant_, wobei C # die leeren Klammern erfordert: string nameUpper = name.ToUpperInvariant(). Oder verdoppeln Sie dies, indem Sie es ebenfalls zuschneiden: _Dim nameUpper$ = name.Trim.ToUpperInvariant_ vs string nameUpper = name.Trim().ToUpperInvariant(). Ich mag es, wenn VB genau beschreibt, wie ich _$_ oben verwendet habe, um es als Zeichenfolge abzudunkeln, wobei C # diese Verknüpfungen nicht hat. VB hat diese Abkürzungen für die Typen String, Integer, Long, Decimal, Single und Double, aber der Nachteil ist, dass es weniger klar ist, also benutze ich es mit Vorsicht. Trotzdem bevorzuge ich prägnanten Code.

Nun, das sind nur ein paar Gedanken dieses erfahrenen Programmierers, und meiner Meinung nach ist dies mein Programmierzeugnis von C # gegen VB. beides sind meiner meinung nach nette sprachen. aber ja, ich bevorzuge immer noch C #.

p.s. 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 ungefähr ein Drittel des Aufwandes für die Eingabe von Englisch in Anspruch nimmt 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 die Effizienz Ihrer Arbeit zu bewerten. Das Dvorak Simplified Keyboard Layout und C # haben dies für mich erledigt. :)

P.S.S. Ich würde den Dvorak und C # mit der Metrik vergleichen, im Gegensatz zum QWERTY-Tastaturlayout und VB zu den empirischen Messungen. Dvorak, Metric und C # sind nur "sauber". ABER VB ist nicht wirklich weit dahinter. Es muss jedoch abwärtskompatibel zu altem VB6-Code und vor .NET-Code sein, z. B. 'Or' vs. 'OrElse' und 'IIF ()'.

Ich beende mit einer Vorsicht. Seien Sie bitte vorsichtiger, wenn Sie Leuten zuhören, die nicht wirklich wissen, wovon sie sprechen. Die Hälfte aller Nachteile sowohl gegen VB als auch gegen C # sind nicht, und die Leute schreiben immer noch darüber, dass sie nicht wissen, welche Nachteile in der Sprache tatsächlich noch existieren. Das beste Beispiel, an das ich denken kann, sind XML-Kommentare für Methoden, die Dreifach-Apostroph in VB oder Dreifach-Schrägstrich-Kommentarsymbole in C # verwenden. Aber bitte überlegen Sie selbst, ob jemand aus Unwissenheit oder aus Erfahrung spricht. Persönliches Zeugnis bedeutet, dass sie es aus ihrer realen Erfahrung wissen. Und nachdem jemand viel Erfahrung darin hat, dann mach deine 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 innerhalb von 5 Minuten nach dem Lesen des Codes sofort erkennen. Aber ja, bei anderen Merkmalen kann es Jahre dauern, bis ein Handicap gefunden ist. Und ein Handicap, das mir bewusst ist (in C #), kann ich mir nicht einmal vorstellen, in welcher realen Situation es nützlich wäre. Vielleicht ist es doch kein Handicap.

Viel Spaß beim Codieren!

0
Shawn Kovac