Question

我不是试图在这里开始一个论点，但无论出于何种原因，通常会说Visual Basic不区分大小写，C语言不是（并且不知何故这是一件好事）。

但是这是我的问题：Visual Basic在哪里确实区分大小写？当我输入...

Dim ss As String
Dim SS As String

...进入Visual Studio 2008或Visual Studio 2010 IDE，第二个警告“局部变量SS已在当前块中声明 ”。在VBA VBE中，它不会立即引发错误，而只是自动更正案例。

我在这里错过了一些关于Visual Basic不区分大小写的论点吗？（另外，如果你知道或想要回答，为什么这会是一件坏事？）

为什么我甚至会问这个问题？

我在很多方面都使用过Visual Basic 多年来的方言，有时候是爱好者，有时候是小人物与企业有关的课程工作组。截至过去六个月，我一直在做一个大项目，比我预想的要大得多。许多那里的示例源代码在C＃中。我没有任何燃烧渴望学习C＃，但如果有的话我错过了C＃的东西提供Visual Basic没有（相反的将是VB.NET提供XML Literals），然后我想知道更多关于该功能。所以在这在这种情况下，人们常常认为C 语言区分大小写这很好，Visual Basic也是如此麻木不仁，这很糟糕。 ID 想知道...

Visual Basic到底是怎么回事因为每一个都不区分大小写代码编辑器中的单个示例变得区分大小写（意思是案件得到纠正）我是否想要是不是。
这对我来说是否足够引人注目考虑转向C＃，如果VB.NET案例在某种程度上限制了我能做的事情用代码？

Answer 1

VBA和VB.NET之间的区别仅仅是因为VB.NET在后台连续编译。编译VBA时会出错。

与Jonathan says一样，编程时除了字符串比较，XML和其他一些情况外，您可以将VB.NET视为不区分大小写......

我认为你对引擎盖下的内容感兴趣。那么，.NET公共语言运行时区分大小写，并且VB.NET代码依赖于运行时，因此您可以看到它在运行时必须区分大小写，例如当它在查找变量和方法时。

VB.NET编译器和编辑器允许您忽略它 - 因为它们更正了代码中的

。

如果您使用动态功能或后期绑定（Option Strict Off），您可以证明基础运行时区分大小写。另一种看待这种情况的方法是认识到像C＃这样的区分大小写的语言使用相同的运行时，因此运行时显然支持区分大小写。

编辑如果您想让IDE脱离等式，您可以随时compile from the command-line。在Notepad中修改代码，使其具有ss和SS，并查看编译器的功能。

编辑 Jeffrey Richter第45页的.NET Framework Design Guidelines引用。

要清楚，CLR实际上是区分大小写。一些编程语言，如Visual Basic，就是这种情况不敏感的。当Visual Basic编译器是试图解决方法调用在区分大小写中定义的类型语言就像C＃，编译器（不是 CLR）确定实际案例方法的名称并将其嵌入元数据。 CLR一无所知这个。现在，如果你正在使用反射绑定到方法，反射 API确实提供了这样做的能力不区分大小写的查找。这是 CLR提供的程度不区分大小写。

Answer 2

这里的部分问题是您需要将语言与IDE体验区分开来。

作为一种语言，VB.NET对标识符肯定不区分大小写。调用DateTime.Parse和datetime.parse将绑定到完全相同的代码。与C＃之类的语言不同，不可能只定义因大小写而异的方法或类型。

作为一个IDE，当VB.NET很好地列出一段代码时，它会尝试保留现有标识符的大小写。当你离开当前的逻辑代码行时，会出现漂亮的列表。在这种情况下，你离开SS的第二个声明，漂亮的lister注意到有一个带有该名称的现有标识符并将其更正为具有匹配的大小写。

但是，这种行为纯粹是作为用户值添加完成的。它不是核心语言的一部分。

Answer 3

VB 主要不区分大小写，但也有例外。例如，XML文字和理解区分大小写。字符串比较通常区分大小写，与T-SQL不同，但是有编译器切换使字符串比较不区分大小写。当然，在处理继承，COM和动态语言运行时时存在边缘情况。

Answer 4

是的，VB.NET编译器以不区分大小写的方式处理标识符。是的，当它使用用另一种语言编写的程序集或使用COM组件时会导致问题。前一案例由Common Language Specification涵盖。相关规则是：

要考虑两个标识符不同，它们必须有所不同而不只是他们的情况。

COM案例由类型库构建器粗略地处理，它强制具有相同名称的标识符的大小相同。即使这些标识符具有不同的角色。换句话说，名为“index”的方法参数将强制将方法名称“Index”重新设置为“index”。正如你可能想象的那样，这产生了相当多的头痛。）

Answer 5

VB 案例保留（在IDE中）但不区分大小写。它在某种程度上就像Windows文件系统。 Hello.txt和hello.txt被认为是相同的文件名。

IDE假定声明变量是该变量的“正确”大小写，并调整该变量的每个实例与声明匹配。它出于眼睛糖果和一致性的原因，但不是功能性。

我已经看过几个不会自动更改案例以匹配声明的实例，并且语句的工作原理相同。您还可以使用任何文本编辑器编写在不同情况下编译得很好的代码。

附注：

大多数 PEOPLE 以不区分大小写的方式思考。当我们看到“狗”这个词时，这个词在我们的脑海中被翻译成意义。这个词的意思不是基于案例（即不管它是否“DOG”，“DoG”或“dOG”仍然咆哮。）计算机将单词视为不连续的位。大写和小写是不同的位模式，因此是不同的。

由于大多数程序员都是人，因此案例不敏感似乎更适合人们的思维方式，而案例敏感性更多地是关于人们如何根据机器的约束条件进行思考。

Answer 6

这是您正在使用的编辑器的一部分，它们可能表现不同但事实是Visual Basic 确实是不区分大小写的语言。因此，ss和SS相同。

<强> Please have a look at VB.NET Basics tutorial for more information :)

Answer 7

我不确定我理解你？ VB不区分大小写，因此ss和SS是相同的变量，因此编译器会正确地抱怨您重新声明了变量。

我认为变量不区分大小写，但函数名称是。

Answer 8

是的，VB不区分大小写。它有时会抛弃那些不习惯的人进行一些循环。

Answer 9

人们不必在VB.NET中尝试所有那些难以创建具有标识符的不同大写/小写“拼写”的代码。在不使用“重命名”功能的情况下更改其声明文件中的标识符的大小写将不会导致在其他文件中更新名称，但编辑包含该名称的任何行将使其符合当前定义。 / p>

通过这种方式，可以确定VB.NET大多数情况下不区分大小写，但它确实使CLR可以使用标识符的情况，这些标识符可能以区分大小写的方式使用该信息。

Answer 10

我只能提供这个，正如我在80年代早期的编程课本中回忆的那样，感觉语言是（当时）严格意图减少编译时错误。也就是说，“严格性”旨在开发更高精度的编码规则。事实证明，添加了适当的变量，类，方法，函数以及其他任何你希望放在那里的标记，也在不断发展。

我记得几乎所有的这些书都包括推荐的大写字母，小写字母等模式。众所周知，除了高端制作之外，其中大部分已被抛弃或应该说，在实践中被忽略房屋和CASE解决方案，或者那些技能水平较高的人。我想每个人都会经历这种学习曲线。

鉴于这些语言和IDE的进步，更好的问题是，哪种语言可以改善我的开发时间？当然，如果你不熟悉各种语言，你的选择是有限的。

Answer 11

我会尽力回答你的第二个问题。

“如果VB.NET案例在某种程度上限制了我对代码的处理能力，那么这对我来说是否足够考虑转移到C＃？”

使用C＃创建WCF WebService。创建一个DataContract（1个类）。一个带有“字符串电子邮件”属性。另一个用“string Email”作为另一个属性。您选择理解为个人电子邮件或办公室电子邮件。或者它可以在两个不同的DataContracts中。

对于C＃这很好。 Web服务创建得很好。 C＃程序可以轻松创建WSDL，一切都很好。

现在尝试使用VB（任何版本）创建WSDL。它会说“email”已经声明，WSDL生成失败。

像所有人一样，我认为这是VB语言的一个缺点。但是!!!

使用FxCOP并分析原始C＃代码。 FxCOP说使用电子邮件/电子邮件是一个问题。建议使用不同名称支持不区分大小写。另请注意，到目前为止，.NET框架有106种编程语言，并且有许多语言具有区分大小写的ON。我们都在向云计算发展，并希望所有编程平台/语言都能访问我们的服务。

因此区分大小写是您在程序中的选择，如果您是C家伙，那么您会喜欢它。如果该程序将被其他非C程序使用/访问，则需要支持不区分大小写，但您的语言是您的选择。

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

Answer 12

符号的隐藏（例如，本地隐藏字段）也不区分大小写。

这里是example：

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

VB.NET编译器的输出反编译为（因此等同于）以下C＃：

public class C
{
    public string Name;

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

string.Equals被两次传递给该字段。无论大小写如何，本地都是隐藏的。该语言不区分大小写。

要显式引用该成员，例如此字段，必须通过Me取消引用该成员：

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

Answer 13

VB.NET是不区分大小写的。

示例：

1

Dim a As Integer
Dim A as Integer

2。

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

这些所有代码都会抛出 COMPILE-TIME ERROR 。

对于第一个例子，将显示错误，说“已在当前块中声明了局部变量'A'。”。

对于第二和第三个例子，将显示错误，说“'Public Sub b（）'有多个具有相同签名的定义。”和''公共函数c（）As Integer'有多个具有相同签名的定义。“，分别。

从这些错误中，请注意错误会在变量和过程/函数的不同位置抛出。对于变量，在第二次声明时抛出错误，而对于过程/函数，它在相同代码的第一次声明/定义时抛出。

正如上面某处评论中的用户所说，VB.NET代码在后台持续检查和/或纠正;您可以在VS IDE的“错误列表”窗口中看到此错误。由于这是一个错误和不是警告，在解决错误之前代码将无法编译。

Answer 14

我最近没有看到有人对你明确的第二个问题发表评论：＆＃34; 2：如果VB.NET案例以某种方式限制我能做的事情，这对我来说是否足够考虑转移到C＃用代码？＆＃34;

我更喜欢C＃让程序员选择是否限制程序员选项的更多选项方法。我更喜欢C＃，但仅仅因为区分大小写，我甚至认为它只是因为区分大小写而接近学习语言。所有的功能都是重要的，当我看到C＃和VB.NET的优点时，我更喜欢C＃。但我会给你一个真正平衡的观点，偏见是的，因为我有偏好，但我也会诚实地说明C＃的缺点。

首先，两种语言都有优点和缺点。在一种语言中你可以用另一种语言做的差异正在减少，因为，幸好的是，微软正在改进这两种语言，而且他们似乎没有对这两种语言表现出不公平的偏袒。

当C＃第一次出现时，VB没有你可以放在方法之前的XML注释，我喜欢在C＃中。我讨厌在VB.NET中。但是我多年来看到，很多非一种语言的功能都会被添加到另一种语言中。（同一个MS开发团队同时开发C＃和VB，因此这些功能应该变得非常相似。）

但是你问过VB没有什么C＃。这是我能想到的一些事情：

1：C＃更简洁，打字更少......在很多方面！当我做出相反的主张时，我甚至看到愚蠢的说话，VB节省了打字。但请听那些告诉你他们使用这两种语言的人，他们也很少使用这两种语言。我在家里使用C＃和 VB，C＃，因为我喜欢它（当我在工作时使用C＃），而我最近的工作要求我使用VB而不是C＃。所以我现在更频繁地使用VB（现在大约10个月），但在我个人的证词中，我更喜欢C＃，而在实际打字方面，VB的打字要多得多。一个例子我已经读过有人真正试图说VB更简洁的地方，正在给出一个＆＃39;与...＆＃39;在with中使用long变量的示例，因此在VB中，您可以使用＆＃39; .property＆＃39;。声称VB需要更少打字是愚蠢的。有一些东西（而不仅仅是这个例子）VB更短，但在实际练习中C＃更简洁的时候还有很多次。

但我认为C＃更简洁的最大原因是VB的冗长＆＃34; IF / THEN＆＃34;声明。如果陈述很常见。在C＃中没有＆＃39;然后＆＃39;要输入的字！ :)也是所有＆＃39;结束......＆＃39;语句在c＃中打字，通常只是一个结束括号＆＃39;}＆＃39;。我读过有些人声称VB.NET中的这种冗长是VB的一个优点，因为几个结束的块语句/符号可以嵌套并紧接着彼此结束，但我完全不同意。一个人几乎总能在C＃或VB中编写程序比另一个程序员更好，因为下一个代码修订可以设计得更好。这适用于C＃＆＃39;中令人困惑的大量结束括号。如果嵌套块与几个嵌套的IF相同，那么VB会遇到与C＃中相同的问题。这在VB中没有优势。这种情况正是我想用两种语言评论我的结束符号或结束语的原因。是的，这更加冗长，但无论使用哪种语言，您都可以选择明确，这在基于判断的情境特定案例中非常重要。我认为代码清晰度非常重要。

2：VB没有多行注释。当我使用VB时，我并不介意。然后我去了一些C风格的语言。现在我回来时主要是在工作中使用VB.NET，我想念他们。它只是你觉得方便的东西，然后不得不输。：（

3：VB＆＃39;以及＆＃39;并且＆＃39; orelse＆＃39;在C＃中键入所有内容时，它简直就是烦人的＆＃39;＆amp;＆amp;＆＃39;和＆＃39; ||＆＃39;。再次，减少打字。这在我和VB和C＃的代码中并不罕见。如果有的话，为了功能，＆＃39;或者＆＃39; vs＆＃39; OrElse＆＃39;通常没关系，除了＆＃39; OrElse＆＃39;对于计算机来说速度更快，所以如果程序员只是使用＆＃39;或者＆＃39;和＆＃39;和＆＃39;在VB中，它会为喜欢清晰代码的人生成不太理想的代码。＆＃39;或＆＃39;比“OrElse”更容易撇去。

4：C＃中代码放置的灵活性更高。当一行很长并且你想把它包装在下一行时，我讨厌VB.NET控制＆＃39;重新调整我的代码。 C＃做了一点，但我发现它在C＃中更有用，在VB中，它更具控制性。但这更像是VB.NET IDE与C＃IDE而不是语言本身。但是，如果没有IDE的差异，我不知道你是想要两者还是纯粹的语言功能。

5：我真的很想念的只是在C＃中创建一个新的代码块，我可能在一个方法中发生了很多事情，我想在一个非常小的代码块中声明一个变量但是没有在外面声明该变量整个方法中的那个块。在C＃中，我们可以使用＆＃39; {＆＃39;创建一个新块。最后用＆＃39;}＆＃39;结束。 VB没有这样的功能，但它最接近的匹配是无条件的＆＃39;如果是真则那么＆＃39;并且＆＃39;结束如果＆＃39;块。（注意2个字符C＃vs 18个字符VB.NET等效...更多在VB中输入。）

6：自增和递减运算符：++和 - 如myVariable++或++myVariable或等效的减量版本。这非常方便......有时候。这是我错过C＃的实际代码示例：

// 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

只是为了给C＃规则提供一个非常好的例子，这是我个人最近写的更多代码：

// 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

也许这是证明C＃更简洁的证据。但并非所有程序员都喜欢简洁。有些人喜欢阅读＆＃34;如果a＆lt;那么......＆＃34;因为他们的人类语言更自然。这很好。偏好很好。对我而言，手工努力是我的价值因素，我认为任何人都可以习惯于用他们喜欢的任何符号思考，因为＆＃34;如果＆＃34;然后＆＃34;然后＆＃34;是字母表的符号，C＃＆＃34;＆＃34; if（条件）语句;＆＃34;语法也是符号。一个更接近非程序员的语法而不是另一个。我更喜欢简洁的。

我还认为需要使用＆＃39; c＆＃39;在VB中的字符文字之后使其成为字符文字而不是字符串是令人讨厌的。我更喜欢C＃的简洁性。当一个方法需要一个字符文字时，你需要提供一个字符而不是一个字符长度的字符串，所以有时你被迫在VB中使用":"c而在C＃中它是':'。我认为这是挑剔的事。

公平地说，我喜欢VB喜欢不喜欢在方法调用之后放空括号，比如Dim nameUpper$ = name.ToUpperInvariant，其中C＃需要空括号：string nameUpper = name.ToUpperInvariant()。也可以加倍修剪它：Dim nameUpper$ = name.Trim.ToUpperInvariant vs string nameUpper = name.Trim().ToUpperInvariant()。我喜欢VB简洁地使用我如何使用上面的$来调暗它＆＃39;作为String＆＃39;其中C＃没有这些快捷方式。 VB有String，Integer，Long，Decimal，Single和Double类型的快捷方式，但缺点是它不太清楚，所以我谨慎使用它。但是，我更喜欢简洁的代码。

嗯，这只是这位经验丰富的程序员的一些提示，而且正如我所想，这是我的编程和见证＆＃39; C＃vs VB。在我看来，这两种语言都很好。但是，我还是更喜欢C＃。

P.S。由于我计划在我生命中的大部分时间进行编程，我甚至重新学会使用最有效的键盘进行打字：Dvorak键盘，其输入英语的成本比Qwerty键盘高出1/3。查一查也许你可能也想转换。 ;）它使我的打字容易67％！ :)我鼓励任何人开箱即用，并评估你的工作效率。 Dvorak Simplified Keyboard Layout和C＃为我做了这个。：）

P.S.S。我会将Dvorak和C＃与公制进行比较，而不是Qwerty键盘布局和VB进行Empirial测量。 Dvorak，metric和C＃只是干净的＃39;但VB并不是很落后。但它确实需要向后兼容旧的VB6代码和.NET代码，例如＆＃39;或者＆＃39; vs＆＃39; OrElse＆＃39;和＆＃39; IIF（）＆＃39;。

我谨慎行事。听听那些不知道他们在说什么的人会更加谨慎。对VB和C＃的所有缺点中有一半是而不是任何问题，人们仍然发布他们对该语言中确实存在的缺点一无所知。我能想到的最好的例子是在VB中使用三个撇号或在C＃中使用三个斜杠注释符号的方法的XML注释。但请自己辨别一个人是从无知或经验中说出来的。个人见证意味着他们从真实的经历中知道。在有人有很多经验之后，你就会振作起来。我在C＃和VB方面都有超过10年的经验。它归结为：两者都是（非常）好的语言。而且大多数差异，您可以在阅读代码后的5分钟内立即看到。但是，其他功能可能需要数年才能找到障碍。我知道的一个障碍（在C＃中），我甚至无法想到它会有用的现实生活情况。所以也许它毕竟不是一个障碍。

快乐的编码！

VB真的不区分大小写吗？

14 个答案: