VB 真的不区分大小写吗？

这是您正在使用的编辑器的一部分，它们的行为可能有所不同，但事实是 VisualBasic真的语言不区分大小写。所以 ss和 SS是相同的。

有关更多信息，请查看 VB.NET 基础教程:)

我不太明白你的意思？VB 是不区分大小写的，因此 SS 和 SS 是同一个变量，所以编译器正确地抱怨您重新声明了该变量。

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

是的，VB 是不区分大小写的。它有时会让那些不习惯它的人陷入一个循环。

VB 是 差不多吧不区分大小写的，但也有例外。例如，XML 文本和理解是区分大小写的。与 T-SQL 不同，字符串比较通常是区分大小写的，但是有编译器开关使得字符串比较不区分大小写。当然，在处理继承、 COM 和 Dynamic Language Runtime 时也存在一些边缘情况。

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

和 乔纳森说一样，在编程时，除了字符串比较、 XML 和其他一些情况之外，你可以认为 VB.NET 是不区分大小写的。

我觉得你对引擎盖下的东西感兴趣。那个。NET 的通用语言运行库是 case-sensitive，而 VB. NET 的代码依赖于运行时，所以你可以看到它在运行时必须区分大小写，例如当它查找变量和方法时。

NET 编译器和编辑器允许您忽略这一点——因为它们在您的代码中是 纠正这个案子。

如果使用动态特性或后期绑定(OptionStrictOff) ，则可以证明底层运行时区分大小写。另一种方法是认识到像 C # 这样区分大小写的语言使用相同的运行时，所以运行时显然支持区分大小写。

编辑 如果你想把 IDE 从方程式中去掉，你总是可以使用 从命令行编译。在 记事本中编辑代码，使其具有 ss和 SS，并查看编译器执行什么操作。

EDIT Quote from 杰弗里 · 里克特 in the .NET 框架设计指南 page 45.

To be clear, the CLR is actually 区分大小写，一些编程 languages, like Visual Basic, are case 当 VisualBasic 编译器处于 试图解析对 区分大小写的 像 C # 这样的语言，编译器(不 the CLR) figures out the actual case 方法的名称，并将其嵌入到 metadata. The CLR knows nothing about 现在，如果你使用反射 绑定到一个方法，即反射 API 确实提供了这样做的能力 不区分大小写的查找 extent to which the CLR offers 不区分大小写。

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

要考虑的两个标识符 distinct, they must differ by more 而不仅仅是他们的案子。

COM 大小写由类型库生成器粗略地处理，它强制具有相同名称的标识符的大小写相同。即使这些标识符有不同的角色。换句话说，名为“ Index”的方法参数将强制将方法名称“ Index”重写为“ Index”。正如你可能想象的那样，这已经引起了很多令人挠头的问题:)

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

作为一种语言，VB.NET对于标识符当然是不区分大小写的。调用 DateTime.Parse和 datetime.parse将绑定到完全相同的代码。而且不像 C # 这样的语言，它不可能定义只因大小写不同而不同的方法或类型。

作为一个 IDE，当 VB.NET 列出一个代码块时，它会尝试保留现有标识符的大小写。只要您离开当前的逻辑代码行，就会出现漂亮的列表。在这种情况下，不再使用 SS的第二个声明，漂亮列表会注意到有一个具有该名称的现有标识符，并将其更正为具有匹配的 case。

不过，这种行为纯粹是作为用户增值来完成的，而不是核心语言的一部分。

人们不必在 VB.NET 中费尽心思创建具有不同大小写“拼写”标识符的代码。在不使用“ Rename”函数的情况下更改文件中标识符的大小写，不会导致在其他文件中更新该名称，但是编辑包含该名称的任何行都会导致该名称符合目前的定义。

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

VB 是 案件保存(在 IDE 中) ，但是是 大小写不敏感。在某种程度上，它就像 Windows 文件系统。Txt 和 Hello.txt 被认为是相同的文件名。

IDE 假定变量的声明是该变量的“正确”大小写，并调整该变量的每个实例与该声明匹配。它这样做是为了美观和一致性的原因，但不是为了功能。

我见过几个实例，其中大小写没有自动更改以匹配声明，语句的工作原理也是一样的。您还可以使用任何文本编辑器编写代码，这些代码在不同的情况下都可以编译得很好。

附注:

大多数 人以不区分大小写的方式进行思考。当我们看到“狗”这个词的时候，这个词就在我们的脑海里转换成了意思。这个词的意思不是基于大小写的(也就是说，不管是拼写它“ DOG”，“ DoG”，还是“ dOG”仍然会叫)COMPUTERS把单词看作离散的比特袋。大写和小写是不同的位模式，因此是不同的。

由于大多数程序员都是人，所以不区分大小写似乎更适合人们的思维方式，而大小写敏感性则更适合人们根据机器的约束条件来调整自己的思维方式。

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

Examples:

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。

For the 1st example, error will be shown, saying "Local variable 'A' is already declared in the current block.".

对于第2个和第3个示例，将显示错误“‘ Public Sub b ()’有多个具有相同签名的定义”以及“‘ Public Function c () As Integer’有多个具有相同签名的定义。”，分别。

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

正如用户在上面某处的评论中所说，VB.NET 代码在后台被不断地检查和/或更正; 您可以在 VS IDE 的“错误列表”窗口中看到这个错误。而作为 这是个错误和 不是警告，代码将不会编译，直到错误得到解决。

我只能提供这一点，正如我在80年代早期的编程教科书中回忆的那样，区分大小写的语言(在当时)严格意义上是为了减少编译时错误。也就是说，“严格性”的目的是发展一个更准确的编码规程。由于添加了适当的变量、类、方法、函数标签，以及您希望在其中添加的其他内容，因此也得到了发展。

我记得几乎所有的这些书都包括一个推荐的模式为领导大写，小写等。我们都知道，大部分这些都被抛弃了，或者我应该说，在实践中被忽视了，除了高端的生产厂家，和 CASE 解决方案，或者那些已经达到了更高的技能水平。我想每个人都经历过这种学习曲线。

考虑到这些语言和 IDE 的进步，更好的问题是，哪种语言可以提高我的开发时间？当然，如果您不熟悉每个不同的 lang，那么您的选择是有限的。

I'll try to answer your second question.

“如果 VB.NET 的情况限制了我使用代码的能力，这是否足以让我考虑迁移到 C # 呢?”

Create a WCF WebService using C#. Create a DataContract (1 Class). One with "string email" property. Another with "string Email" as another property. Your choice to understand as personal email or office email. Or it could be in two different 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

我还没有看到任何人在你最后的第二个问题上发表评论: “2: 如果 VB.NET 的情况在某种程度上限制了我使用代码的能力，这个问题是否足够引人注目，让我考虑转向 C # ?”

i prefer the more option approach that C# lets the programmer choose whether than limiting the programmer's options. i highly prefer C#, but for case sensitivity alone, i would not even think it close to learning a language just because it is case sensitive. all the features are what matter, and when i look at advantages of both, C# and VB.NET, i highly prefer C#. but i will give you a true balanced perspective, biased yes, because i have a preference, but i will be honest about the disadvantages of C# too.

首先，两种语言各有优缺点。你可以在一种语言中完成而在另一种语言中无法完成的差异正在减少，因为，谢天谢地，微软正在改进这两种语言，而且他们似乎没有对任何一种语言表现出不公平的偏爱。

当 C # 第一次出现的时候，VB 没有可以放在方法之前的 XML 注释，我喜欢 C # 。我讨厌 VB.NET。但是这些年来，我看到很多不是在一种语言中的特性被添加到了另一种语言中。(同一个 MS 开发团队同时开发 C # 和 VB，所以这些特性应该变得非常相似是有意义的。)

but you asked for what C# has that VB doesn't. here's some i can think of immediately:

1: C # 更简洁，更少的输入。.在很多方面！我甚至见过愚蠢的人说相反的话，说 VB 节省了输入。但是请听听那些告诉你他们使用两种语言的人，他们很少使用这两种语言。我在家里使用 C # 还有 VB 和 C # ，因为我喜欢它(当我在工作中使用 C # 时) ，而且我最近的工作要求我使用 VB 而不是 C # 。所以我现在越来越频繁地使用 VB (大约10个月了) ，但是在我个人的证词中，我更喜欢 C # ，而且就实际的输入而言，VB 的输入量要大得多。我读过一个例子，有人试图说 VB 更简洁，给出了一个‘ with...’的例子，里面有一个很长的变量，所以在 VB 中，你可以直接使用’。财产。声称 VB 需要更少的输入是愚蠢的。有一些东西(不仅仅是这个例子) ，VB 更短，但更多的时候，C # 更简洁，在实践中。

但我认为 C # 更简洁的最大原因是 VB 冗长的“ IF/THEN”语句。如果语句是常见的。在 C # 中没有可以键入的“ then”字！:)还有所有的‘ end...’语句都需要输入，在 c # 中，通常只是一个结束大括号’}’。我读到过一些人声称在 VB 中这种更加冗长的语句是 VB 的优势，因为几个结束语句/符号可以嵌套在一起并立即结束，但是我完全不同意。一个人几乎总是可以用 C # 或 VB 比其他程序员更好地编写程序，因为下一个代码修订版本可以设计得更好。这适用于“在 C # 中混淆大量的闭括号”，如果嵌套的块都是相同的类型，就像几个嵌套的 IF 一样，那么 VB 就会遇到与 C # 相同的问题。这在 VB 中没有优势。这种情况正是为什么我喜欢评论我的结束符号或结束语句与两种语言。是的，这样做更加冗长，但是在任何一种语言中，你都可以选择清晰，这在基于判断的特定情况下都很重要。我觉得代码清晰度很重要。

VB 没有多行注释。当我和 VB 一起工作时，我并不介意。然后我学了一些 C 风格的语言。现在我回来了，大部分时间在工作中使用 VB.NET，我很想念他们。这只是你觉得方便，然后必须失去的东西。:(

3: VB 中的‘ andalso’和‘ orelse’在 C # 中只输入‘ & &’和‘ | |’是相当烦人的。再说一次，少打字。这在我的 VB 和 C # 代码中并不罕见。如果有的话，对于功能来说，“ OR”和“ OrElse”通常并不重要，除非“ OrElse”对于计算机来说更快，所以如果一个程序员只是在 VB 中使用“ OR”和“ And”，那么对于喜欢代码清晰度的人来说，它产生的代码就不是最优的。“或者”比“其他”更容易跳过。

4: 在 C # 中代码放置更加灵活。当一行很长，你想把它换到下一行时，我讨厌 VB.NET 对我的代码进行“控制性”的重新调整。C # 有一点，但是我发现它在 C # 中更有用，在 VB 中，它的控制性更强。但这更多的是 VB.NET IDE 与 C # IDE 的对抗，而不是语言本身。但是我不知道您是想要两者兼备还是纯粹的语言特性而没有 IDE 的差异。

5: 我真正想念的是在 C # 中创建一个新的代码块，我可能在一个方法中发生了很多事情，我想在一个非常小的代码块中声明一个变量，但是在整个方法中没有在这个代码块之外声明这个变量。在 C # 中，我们可以用“{”创建一个新块，用“}”结束它。VB 没有这样的功能，但它最接近的匹配是一个无条件的“如果为真”和“结束如果”块。(注意2个字符的 C # 与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 # 更简洁。但并非所有程序员都喜欢简洁。有些人喜欢读“ if a < b then...”，因为这对他们的人类语言来说更自然。没关系。喜好没问题。对我来说，手的努力是一个因素 i 的价值，我认为任何人都可以习惯于思考任何符号他们喜欢，因为“如果”和“然后”是一个字母表的符号，和 C # 的“如果(条件)语句;”语法也是符号。一个只是比另一个更接近非程序员的语法。我更喜欢简洁的。

我还认为在 VB 中需要在字符文字之后使用‘ c’来使它成为字符文字而不是字符串是令人讨厌的。我更喜欢 C # 的简洁。当一个方法需要一个字符文字时，你需要提供一个字符而不是一个字符长度的字符串，所以有时你不得不在 VB 使用 ":"c，而在 C # 中它是 ':'。我觉得这太挑剔了。

为了公平起见，我想说我喜欢 VB 的一些优点，比如不必在方法调用后放空括号，比如 Dim nameUpper$ = name.ToUpperInvariant，C # 需要空括号: string nameUpper = name.ToUpperInvariant()。或者像修剪它一样加倍: Dim nameUpper$ = name.Trim.ToUpperInvariant和 string nameUpper = name.Trim().ToUpperInvariant()。我喜欢 VB 的简洁使用，我只是用 $上面的模糊它’作为字符串’，其中 C # 没有这些快捷方式。VB 对 String、 Integer、 Long、 Decimal、 Single 和 Double 类型都有这些快捷方式，但缺点是不太清楚，所以我使用时要小心。尽管如此，我还是更喜欢简洁的代码。

好吧，这只是这位经验丰富的程序员的一些想法，正如我所考虑的，这是我的 C # VS VB 的编程“见证”。在我看来，这两种语言都是很好的语言。但是，是的，我还是更喜欢 C # 。

附言。由于我计划用我的大部分生命来编程，我甚至重新学习使用最有效的键盘: DVORAK 键盘，它比 Qwerty 键盘花费大约1/3的努力来打英语。查一下。也许你也想换一下。;)它使我打字容易67% ！我鼓励任何人跳出思维定势，评估工作效率。德沃夏克键盘的布局和 C # 已经为我做到了这一点。:)

另外，我会将 DVORAK 和 C # 与 Qwerty 键盘布局相比较，将 VB 与经验测量相比较。DVORAK、米制和 C # 只是“干净的”。但是 VB 并没有落后太多。但是它确实需要向后兼容旧的 VB6代码和 pre。NET 代码，比如‘ Or’vs‘ OrElse’和‘ IIF ()’。

我以警告结束。请更谨慎地倾听那些不知道自己在说什么的人。所有针对 VB 和 C # 的缺点中有一半都是 没有的问题，人们仍然发帖说他们不知道在这门语言中到底还存在哪些缺点。我能想到的最好的例子是在 VB 中使用三重撇号或在 C # 中使用三重斜杠注释符号的方法的 XML 注释。但是请你自己辨别一个人说话是出于无知，还是出于经验。个人证词意味着他们从自己的真实经历中得知。在某人有丰富的经验之后，再竖起你的耳朵。我有超过10年的 C # 和 VB 经验。归结起来就是: 两种语言都是(非常)好的语言。而最大的差异，你可以在5分钟内立即看到阅读代码。但是，是的，其他特征可能需要数年才能发现缺陷。还有一个我知道的缺点(在 C # 中) ，我甚至想不出在现实生活中哪种情况下它是有用的。所以也许这根本不是一个障碍。

编程愉快！

隐藏符号(例如，local hide 字段)也是不区分大小写的。

Here is an 例子:

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

The VB.NET compiler's output is decompiled to (and therefore equivalent to) the following 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