VB真的不区分大小写吗？

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 想知道...

1. Visual Basic 究竟如何 不区分大小写，因为每个 代码编辑器中的单个示例 变得区分大小写（意味着 案件得到纠正）无论我想要 无论是否。
2. 这足以让我信服吗 如果是 VB.NET，请考虑转向 C# 在某种程度上限制了我能做的事情 有代码吗？

Answer 1

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

正如 Jonathan 所说，在编程时，您可以将 VB.NET 视为除了字符串比较、XML 和其他一些情况之外，不区分大小写...

我认为您对幕后的内容感兴趣。好吧，.NET 公共语言运行时区分大小写，而 VB.NET 代码依赖于运行时，因此您可以看到它在运行时必须区分大小写，例如当它查找变量和方法。

VB.NET 编译器和编辑器允许您忽略这一点 - 因为它们更正代码中的大小写。

如果您尝试使用动态功能或后期绑定（Option Strict Off），您可以证明底层运行时是区分大小写的。另一种了解这一点的方法是认识到像 C# 这样区分大小写的语言使用相同的运行时，因此运行时显然支持区分大小写。

编辑如果您想将 IDE 排除在外，您可以随时 从命令行编译。在 记事本 中编辑代码，使其具有 ss 和SS 看看编译器做了什么。

编辑引用Jeffrey Richter在.NET Framework 设计指南第 45 页。

需要明确的是，CLR 实际上是
区分大小写。一些编程
语言，如 Visual Basic，是案例
不敏感。当 Visual Basic 编译器为
尝试解决对方法的调用
定义的类型区分大小写
像 C# 这样的语言，编译器（不是
CLR）找出实际情况
方法名称并将其嵌入
元数据。 CLR 一无所知
这。现在如果你使用反射
绑定到方法，反射
API 确实提供了以下功能：
不区分大小写的查找。这是
CLR 提供的程度
不区分大小写。

Answer 2

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

作为一种语言，VB.NET 对于标识符来说肯定​​是不区分大小写的。调用 DateTime.Parse 和 datetime.parse 将绑定到完全相同的代码。与 C# 等语言不同，不可能定义仅大小写不同的方法或类型。

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

不过，这种行为纯粹是为了增加用户价值。它不是核心语言的一部分。

Answer 3

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

Answer 4

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

对于要考虑的两个标识符
不同的，它们必须有更多的不同
不仅仅是他们的情况。

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

Answer 5

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

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

我见过一些情况，其中大小写没有自动更改以匹配声明，并且该语句的工作原理是一样的。您还可以使用任何文本编辑器编写在不同情况下都能正常编译的代码。

旁注：

大多数人们以不区分大小写的方式思考。当我们看到“狗”这个词时，这个词就会被翻译成我们心中的意思。该单词的含义不取决于大小写（即，无论是否将其拼写为“DOG”、“DoG”或“dOG”，仍然会吠叫。）计算机将单词视为离散的位包。大写和小写是不同的位模式，因此是不同的。

由于大多数程序员都是人类，因此不区分大小写似乎更适合人们的思维方式，而区分大小写则更多地是人类根据机器的限制调整他们的思维方式。

Answer 6

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

请查看 VB.NET 基础教程以获取更多信息:)

Answer 7

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

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

Answer 8

是的，VB 不区分大小写。有时它会让那些不习惯的人陷入困境。

Answer 9

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

通过这种方式，我们可以确定 VB.NET 大多不区分大小写，但它确实使标识符的大小写可供 CLR 使用，CLR 可以以区分大小写的方式使用该信息。

Answer 10

我将尝试回答你的第二个问题。

“如果 VB.NET 案例在某种程度上限制了我使用代码的能力，这是否足以让我考虑转向 C#？”

使用 C# 创建 WCF WebService。创建数据契约（1 类）。具有“字符串电子邮件”属性的一种。另一个以“字符串电子邮件”作为另一个属性。您选择将其理解为个人电子邮件或办公室电子邮件。或者它可能位于两个不同的数据合同中。

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

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

和大家一样，我认为这是 VB 语言的一个缺点。但！！！

使用 FxCOP 并分析原始 C# 代码。 FxCOP 表示使用电子邮件/电子邮件是一个问题。建议使用不同的名称，支持不区分大小写。另请注意，截至目前，.NET 框架有 106 种编程语言，并且许多语言都启用了区分大小写。我们都在向云迈进，并希望所有编程平台/语言都可以访问我们的服务。

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

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

Answer 11

我没有看到任何人对你最后明确的第二个问题发表评论：“2：如果 VB.NET 案例在某种程度上限制了我可以用代码做什么，这是否足以让我考虑转向 C#？”

我更喜欢 C# 让程序员选择是否提供更多选项的方法，而不是限制程序员的选项。我非常喜欢 C#，但仅就区分大小写而言，我什至不认为它与学习一门语言很接近，因为它区分大小写。所有功能都很重要，当我考虑 C# 和 VB.NET 的优点时，我非常喜欢 C#。但我会给你一个真正平衡的观点，有偏见是的，因为我有偏好，但我也会诚实地对待 C# 的缺点。

首先，两种语言都有优点和缺点。在一种语言中可以做到而在另一种语言中无法做到的差异正在缩小，值得庆幸的是，微软正在改进这两种语言，而且他们似乎并没有对任何一种语言表现出不公平的偏袒。

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

但是您询问 C# 有哪些 VB 没有的功能。以下是我立即能想到的一些内容：

1：C# 在很多方面都更加简洁，并且需要更少的打字！我什至看到过一些愚蠢的说法，即 VB 可以节省打字。但请听听那些告诉你他们使用这两种语言的人的意见，而且他们很少使用这两种语言。我在家里使用 C# 和 VB，因为我喜欢它（当我在工作中使用 C# 时），而且我最近的工作要求我使用 VB 而不是 C#。所以我现在更频繁地使用 VB（大约 10 个月了），但在我个人的见证中，我更喜欢 C#，并且就实际打字而言，VB 的打字要多得多。我读过的一个例子中，有人实际上试图说 VB 更简洁，给出了一个“with ...”示例，其中包含一个长变量，因此在 VB 中，您可以只使用“.property”。声称 VB 需要更少的打字是愚蠢的。在实际实践中，在某些情况下（不仅仅是这个例子）VB 更短，但更多时候 C# 更简洁。

但我认为 C# 更简洁的最大原因是 VB 冗长的“IF/THEN”语句。 if 语句很常见。在 C# 中，没有“then”这个词需要输入！ :) 另外，所有“end ...”语句都需要输入，在 C# 中，通常只是一个右大括号“}”。我读到，有些人声称 VB.NET 中的这种更详细的内容对 VB 来说是一个优势，因为多个结束块语句/符号可以嵌套并立即彼此相邻结束，但我非常不同意。一个人几乎总是可以比其他程序员更好地用 C# 或 VB 编写程序，因为下一个代码修订版可以设计得更好。这适用于“C# 中令人困惑的大量右大括号”，此外，如果嵌套块都是相同类型（如多个嵌套 IF），那么 VB 会遇到与 C# 中相同的问题。这在VB中是没有优势的。这种情况正是为什么我喜欢评论我的结束符号或结束语在两种语言中的搭配。是的，这样做比较冗长，但无论使用哪种语言，您都可以选择清晰，这在基于判断的具体情况下非常重要。我认为代码清晰性非常重要。

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

3: VB 的 'andalso' 和 'orelse' 是相当烦人的，而在 C# 中，它只是简单的 '&&' 和 '||'。再次，更少的打字。这在我的代码中并不罕见VB 和 C# 中，就功能而言，“OR”与“OrElse”通常并不重要，只是“OrElse”对于计算机来说速度更快，因此如果程序员在 VB 中只使用“Or”和“And”，那么它就可以了。对于喜欢代码清晰的人来说，“Or”比“OrElse”更容易浏览。4

：当一行很长并且您想将其换行时，C# 中的代码放置更加灵活。 ，我讨厌 VB.NET 对我的代码的“控制”重新调整，但我发现它在 C# 中更有用，而在 VB 中，它更具控制性，但这更多的是 VB.NET IDE。 C# IDE 而不是语言本身，但我不知道您是否想要两者或纯粹没有 IDE 差异的语言功能

5：我真正怀念的是在 C# 中创建一个新的代码块，我可能会发生很多事情。在一个方法中，我想在一个非常小的代码块中声明一个变量，但不想在整个方法的该代码块之外声明该变量。在 C# 中，我们可以使用“{”创建一个新块并以“}”结束。 VB 没有这样的功能，但最接近的匹配是无条件“If True then”和“End If”块。 （请注意 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...”，因为这对他们的人类语言来说更自然。那很好。偏好很好。对我来说，手的努力是我看重的一个因素，我认为任何人都可以习惯用他们喜欢的任何符号来思考，因为“if”和“then”是字母表的符号，而C#的“if（条件）语句；”语法也是符号。一种比另一种更接近非程序员的语法。我更喜欢简洁的。

我还认为需要在 VB 中的字符文字后面使用“c”以使其成为字符文字而不是字符串，这很烦人。我更喜欢 C# 的简洁性。当方法需要字符文字时，您需要提供一个字符而不是一个字符长度的字符串，因此有时您被迫在 VB 中使用 ":"c 而在 C# 中则为 ':'。我认为这是挑剔的。

公平地说，我会说 VB 有一些优点，比如不必在方法调用后放置空括号，例如 Dim nameUpper$ = name.ToUpperInvariant，其中 C# 需要空括号：字符串 nameUpper = name.ToUpperInvariant()。或者加倍也喜欢修剪它：Dim nameUpper$ = name.Trim.ToUpperInvariant 与 string nameUpper = name.Trim().ToUpperInvariant()。我喜欢 VB 的简洁用法，即我刚刚使用上面的 $ 将其调暗为“作为字符串”，而 C# 没有这些快捷方式。 VB有String、Integer、Long、Decimal、Single、Double类型的快捷键，但缺点是不太清晰，所以我谨慎使用。但尽管如此，我还是更喜欢简洁的代码。

嗯，这只是这位经验丰富的程序员的一些想法，据我所知，这是我对 C# 与 VB 的编程“见证”。在我看来，这两种语言都是很好的语言。但是，是的，我仍然更喜欢 C#。

ps 由于我计划一生中的大部分时间都在编程，所以我什至重新学习了使用最高效的键盘打字：德沃夏克键盘，它比在 Qwerty 键盘上输入英语大约需要 1/3 的努力。查一下。也许你也想切换。 ;) 它让我的打字轻松了 67%！ :) 我鼓励任何人跳出框框思考并评估你的工作效率。 Dvorak 简化键盘布局和 C# 已经为我做到了这一点。 :)

PSS 我会将 Dvorak 和 C# 与公制进行比较，而不是 Qwerty 键盘布局，将 VB 与经验测量进行比较。 Dvorak、公制和 C# 都是“干净的”。但 VB 也不甘落后。但它确实需要向后兼容旧的 VB6 代码和 .NET 之前的代码，例如“Or”与“OrElse”以及“IIF()”。

我以谨慎结束。请更加谨慎，不要听那些并不真正知道自己在说什么的人。 VB 和 C# 的所有缺点中，有一半已经不再是问题了，人们仍然发帖称他们不知道该语言中仍然存在哪些缺点。我能想到的最好的例子是在 VB 中使用三重撇号或在 C# 中使用三重斜杠注释符号的方法的 XML 注释。但请你自己辨别一下，这个人的言论是出于无知，还是出于经验。个人见证意味着他们从自己的真实经历中得知。当某人拥有丰富的经验后，请竖起耳朵。我在 C# 和 VB 方面都有超过 10 年的经验。归结起来就是：两者都是（非常）好的语言。大多数差异，您可以在阅读代码后 5 分钟内立即看到。但是，是的，其他功能可能需要数年时间才能找到障碍。我意识到（在 C# 中）的一个障碍，我什至无法想象它在现实生活中有用的情况。所以也许这根本不是一个障碍。

快乐编码！

Answer 12

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

这是一个 示例：

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 两次传递该字段。无论大小写，本地都是隐藏的。该语言不区分大小写。

要显式引用 a 成员（例如此字段），您必须通过 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

这些所有代码都会抛出编译时错误。

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

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

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

正如用户在上面的评论中所说，VB.NET 代码在后台不断检查和/或更正；您可以在 VS IDE 的“错误列表”窗口中看到此错误。由于这是一个错误并且不是警告，因此在解决错误之前代码不会编译。