VB真的不区分大小写吗？

我不是要在这里开始争论，但是无论出于何种原因，通常都说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不区分大小写，这是不好的。我想知道...

1. Visual Basic不区分大小写的精确程度是多少，因为无论我是否愿意，代码编辑器中的每个示例都区分大小写（表示大小写已得到纠正）。
2. 如果VB.NET案例以某种方式限制了我对代码的处理能力，这是否足以让我考虑使用C＃？

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

就像乔纳森（Jonathan）所说的那样，在编程时，除了字符串比较，XML和其他一些情况外，您都可以认为VB.NET不区分大小写。

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

VB.NET编译器和编辑器使您可以忽略它-因为它们可以纠正代码中的大小写。

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

编辑如果您想将IDE排除在公式之外，则始终可以从命令行进行编译。编辑代码在记事本，因此具有ss和SS看编译器做什么。

编辑引用来自.NET Framework设计指南第45页中的Jeffrey Richter。

需要明确的是，CLR实际上是区分大小写的。某些编程语言（如Visual Basic）不区分大小写。当Visual Basic编译器尝试解析对以区分大小写的语言（如C＃）定义的类型的方法调用时，编译器（而非CLR）会找出方法名称的实际大小写，并将其嵌入元数据中。CLR对此一无所知。现在，如果您使用反射绑定到方法，则反射API确实可以进行不区分大小写的查找。这是CLR提供不区分大小写的程度。

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

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

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

但是，此行为纯粹是作为用户增值来完成的。它不是核心语言的一部分。

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

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

为了使两个标识符区别开来，它们的区别不仅限于大小写。

类型库生成器完全处理COM情况，它强制具有相同名称的标识符的大小写相同。即使这些标识符具有不同的角色。换句话说，名称为“ index”的方法参数将强制将方法名称“ Index”重新设置为“ index”。正如您可能想像的那样，这已经造成了很多头部刮伤：)

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

IDE假定声明变量是该变量的“正确”大小写，并调整该变量的每个实例以使其与声明匹配。这样做是出于令人眼花and乱和一致性的考虑，而不是出于功能性考虑。

我见过几个实例的大小写不会自动更改为与声明匹配的情况，并且该语句的工作原理相同。您还可以使用任何文本编辑器来编写可以在不同情况下正常编译的代码。

旁注：

多数人民认为，在不区分大小写的方式。当我们看到“狗”这个词时，这个词在我们的脑海中就会转化为含义。单词的含义不是基于大小写的（即，不管拼写为“ DOG”，“ DoG”还是“ dOG”仍然吠叫）。 计算机将单词视为离散的位袋。大写和小写是不同的位模式，因此是不同的。

由于大多数程序员都是人类，因此不区分大小写似乎更适合于人们的思维方式，而区分大小写则更适合于人类根据计算机的约束调整其思维方式。

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

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

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

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

是的，VB不区分大小写。有时它会将那些不习惯的东西抛出一个循环。

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

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

我只能提供这一点，正如我在80年代初的编程教科书中所回顾的那样，（当时）区分大小写的语言严格地旨在减少编译时错误。也就是说，“严格性”旨在发展更精确的编码规则。事实证明，对变量，类，方法，函数以及您希望在其中添加的任何其他内容进行适当标记的方法也在不断发展。

我记得几乎所有这些书都包含推荐的大写字母首字母大写，小写字母等模式。众所周知，除了高端制作公司，其中大部分已经被淘汰或者我应该说，在实践中应该被忽略。 CASE解决方案，或针对已达到较高技能水平的解决方案。我认为每个人都会经历这种学习曲线。

鉴于这些语言和IDE的发展，更好的问题是，哪种语言可以改善我的开发时间？当然，如果您不熟悉每种语言，那么您的选择将受到限制。

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

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

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

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

现在尝试使用VB（任何版本）创建WSDL。它将说“电子邮件”已经声明并且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

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

这是一个例子：

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

我没有看到任何人在最后对您明确的第二个问题发表评论：“ 2：如果VB.NET的情况以某种方式限制了我对代码的处理能力，这是否足以让我考虑使用C＃？”

我更喜欢C＃允许程序员选择是否使用更多选项的方法，而不是限制程序员的选择。我非常喜欢C＃，但仅就区分大小写而言，我什至不会认为仅仅因为它区分大小写而就接近学习一种语言。所有功能都很重要，当我同时看一下C＃和VB.NET的优点时，我非常喜欢C＃。但是我会给您一个真正平衡的观点，有偏见是的，因为我有一个偏爱，但是我也会诚实地对待C＃的缺点。

首先，两种语言都有优点和缺点。庆幸的是，Microsoft正在改进这两种语言，并且您在一种语言中无法用另一种语言无法完成的差异正在逐渐减少，并且似乎没有表现出对这两种语言的偏爱。

当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更简洁，它给出了一个with例子，with中有一个长变量，因此在VB中，您可以只使用'.property'。这是愚蠢的，声称VB需要较少的键入。在实际实践中，有一些事情（不仅是这个示例）的VB更短，而C＃更简洁的时候却更多。

但是我认为C＃更简洁的最大原因是VB冗长的“ IF / THEN”语句。如果语句是通用的。在C＃中，没有要键入的“然后”字！:)同样，所有的'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＃可以做到这一点，但是我发现它在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＃的简洁性。当方法需要字符文字时，您需要提供一个字符而不是一个字符长度的字符串，因此有时您不得不":"c在VB中使用，而在C＃中则必须使用':'。我认为这是挑剔的。

公平地说，我想说VB有很多优点，例如不必在方法调用后放置空括号，例如Dim nameUpper$ = name.ToUpperInvariantC＃需要空括号的地方string nameUpper = name.ToUpperInvariant()。或加倍喜欢修剪的效果：Dim nameUpper$ = name.Trim.ToUpperInvariantvs string nameUpper = name.Trim().ToUpperInvariant()。我喜欢VB的简洁用法，我只是在$上面用它来将其调暗为“ As String”，而C＃没有这些快捷方式。VB具有用于String，Integer，Long，Decimal，Single和Double类型的那些快捷方式，但是缺点是它不太清楚，因此我谨慎使用它。但是，尽管如此，我还是喜欢简洁的代码。

好吧，这只是这个经验丰富的程序员的一些建议，而且我认为，这是我对C＃和VB进行编程的“见证”。我认为，两者都是不错的语言。但是，是的，我仍然更喜欢C＃。

ps由于我打算一生中都要编程，所以我什至重新学习了使用最高效的键盘进行打字的方法：Dvorak键盘，与Qwerty键盘相比，它需要大约1/3的英文键入时间。查一下。也许您可能也要切换。;）使我的输入更加轻松67％！:)我鼓励任何人都跳脱思维，评估工作效率。Dvorak简化键盘布局和C＃为我完成了此任务。:)

PSS i会将Dvorak和C＃与公制进行比较，而不是Qwerty键盘布局，并将VB与Empirial进行比较。Dvorak，metric和C＃只是“干净”的。但是VB并没有真正落后。但是它确实需要向后兼容旧的VB6代码和pre.NET代码，例如“ Or”和“ OrElse”以及“ IIF（）”。

我谨慎行事。请谨慎行事，听不真正知道他们在说什么的人。针对VB和C＃的所有弊端中有一半不是不再存在任何问题，人们仍然对它们不了解该语言实际上仍然存在哪些不利之处发表了看法。我能想到的最好的例子是在VB中使用三撇号或在C＃中使用三斜杠注释符号的方法的XML注释。但是，请您自己分辨一个人是出于无知还是出于经验。个人证词意味着他们从实际经验中了解。等到某人有很多经验之后，再振作起来。我在C＃和VB方面都有10多年的经验。归结为：两者都是（非常）好的语言。和大多数差异一样，您在阅读代码后的5分钟内即可看到。但是，是的，要找到障碍，其他功能可能还需要数年时间。我知道的一个障碍（在C＃中），我可以 甚至不会想到一个有用的现实生活环境。所以也许这毕竟不是障碍。

编码愉快！

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（）作为整数”具有带有相同签名的多个定义。

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

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