VB真的不区分大小写？

我不是想在这里开始一个论点，但是无论出于什么原因，通常都声称Visual Basic不区分大小写，而C语言不是（也不过是一件好事）。

但是这里是我的问题：Visual Basic是不区分大小写的？ 当我input…

Dim ss As String Dim SS As String 

…到Visual Studio 2008或Visual Studio 2010 IDE中，第二个警告“ 本地variablesSS已在当前块中声明 ”。 在VBA VBE中，它不会立即踢出错误，而只是自动纠正这种情况。

我是否在这里错过了一些与Visual Basic不区分大小写的参数？ （另外，如果你知道还是很在意，那为什么会这样呢？）

我为什么问这个问题？

我已经在很多方言中使用了Visual Basic，有时候是作为一个业余爱好者，有时候也是在一个工作组中，与小型商业相关的程序。 截至过去六个月，我一直在做一个比我预期的要大得多的大项目。 大部分示例源代码都在C＃中。 我没有任何学习C＃的渴望，但是如果有什么东西我错过了C＃提供的Visual Basic没有（相反将是VB.NET提供XML文字 ），那么我想了解更多关于这个function。 所以在这种情况下，人们经常认为C语言是区分大小写的，这很好，而Visual Basic不区分大小写，这是不好的。 我想知道…

1. Visual Basic如何不区分大小写，因为代码编辑器中的每个示例都会变成大小写敏感的（意思是情况得到更正），无论是否需要
2. 如果VB.NET的情况是限制我可以用代码做什么，这是足够的引人注目，我考虑转移到C＃？

Answer 1

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

像Jonathan说的那样 ，在编程时，除了string比较，XML和其他一些情况之外，还可以把VB.NET看作是不区分大小写的。

我认为你对引擎盖下的东西感兴趣。 那么，.NET Common Language Runtime是区分大小写的 ，VB.NET代码依赖于运行时，所以你可以看到它在运行时必须是区分大小写的，比如当它查找variables和方法的时候。

VB.NET编译器和编辑器让你忽略 – 因为它们纠正了你的代码中的情况 。

如果您使用dynamicfunction或迟绑定（Option Strict Off），您可以certificate底层运行时区分大小写。 另一种看到这种情况的方法是意识到像C＃这样区分大小写的语言使用相同的运行时，所以运行时显然支持区分大小写。

编辑如果你想把IDE排除在外，你可以随时从命令行编译 。 在记事本中编辑代码，以便它具有ss和SS并查看编译器的function。

从Jeffrey Richter 编辑引用在.NET框架devise指南页45。

要清楚的是，CLR实际上是区分大小写的。 一些编程语言，如Visual Basic，不区分大小写。 当Visual Basic编译器试图parsing一个方法调用到像C＃这样的区分大小写的语言中定义的types时，编译器（而不是CLR）会计算出方法名称的实际情况并将其embedded到元数据中。 CLR对此一无所知。 现在，如果您使用reflection来绑定到方法，reflectionAPI确实提供了执行不区分大小写的查找的function。 这是CLR提供不区分大小写的程度。

Answer 2

这里的一部分问题是您需要从IDE体验中划分语言。

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

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

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

Answer 3

VB 大多不区分大小写，但也有例外。 例如，XML文字和理解是区分大小写的。 string比较通常是区分大小写的，与T-SQL不同，但是有编译器切换来使string比较不区分大小写。 当然，在处理inheritance，COM和dynamic语言运行时也有边缘情况。

Answer 4

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

两个标识符被认为是不同的，它们之间的区别不仅仅在于它们的情况。

COM案件由types库构build器相当粗暴地处理，迫使相同名称的标识符的shell是相同的。 即使这些标识符有不同的作用。 换句话说，一个名为“index”的方法参数将强制一个方法名称“Index”被重新索引到“index”。 这已经产生了相当多的头挠，你可能会想象:)

Answer 5

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

请参阅VB.NET基础教程了解更多信息:)

Answer 6

VB 保存 （在IDE中）但不区分大小写 。 这就像Windows文件系统一样。 Hello.txt和hello.txt被认为是相同的文件名。

IDE假定声明variables是该variables的“正确”情况，并调整该variables的每个实例匹配声明。 它是为了眼睛和一致性的原因，而不是function。

我已经看到几个案例不会自动更改为与声明相匹配的情况，并且声明也是一样的。 你也可以使用任何文本编辑器编写代码，在不同的情况下编译得很好。

附注：

大多数人以不区分大小写的方式思考。 当我们看到“狗”这个词时，这个词在我们的脑海中被翻译成意义。 这个词的意思并不是基于大小写（也就是说，不pipe它是“DOG”，“DoG”还是“dOG”仍然咆哮）。 计算机将单词视为离散的数据包。 大写和小写是不同的位模式，因此是不同的。

由于大多数程序员都是人，大小写敏感性似乎更适合人们思考的方式，而大小写敏感性更多的是人类如何适应机器的限制。

Answer 7

我不确定我了解你吗？ VB不区分大小写，所以ss和SS是同一个variables，所以编译器正确地抱怨你重新声明了variables。

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

Answer 8

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

Answer 9

一个人不必在VB.NET中尝试所有的努力来创build一个标识符不同的大写/小写“拼写”的代码。 在不使用“Rename”函数的情况下更改声明文件中的标识符的shell不会导致在其他文件中更新名称，但编辑包含该名称的任何行都将使其符合当前定义。

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

Answer 10

我只能提出这个问题，就像我在80年代初从我的编程教科书中回想起来的那样，当时的感性语言是严格意图减less编译时错误的。 也就是说，“严格”是为了开发一个更精确的编码学科。 事实certificate，variables，类，方法，函数，以及其他任何你想抛出的东西的标签的增加也是演变而来的。

我记得几乎所有这些书中都包含了一个推荐的大写字母，小写字母等的模式。众所周知，大部分这些书已经被抛出去了，或者应该说在实践中被忽视了，除了高端生产厂家， CASE解决scheme，或者那些已经达到较高技能水平的解决scheme。 我想每个人都会经历这种学习曲线。

鉴于这些语言和IDE的进步，更好的问题是，哪种语言提高了我的开发时间？ 当然，如果你不熟悉各种语言，你的select是有限的。

Answer 11

我会试着回答你的第二个问题。

“如果VB.NET的情况在某种程度上限制了我能用代码做什么，那么这足以让我考虑转向C＃吗？

使用C＃创build一个WCF WebService。 创build一个DataContract（1类）。 一个具有“string电子邮件”属性。 另一个以“string电子邮件”为另一个属性。 您select理解为个人电子邮件或办公室电子邮件。 或者它可能在两个不同的DataContracts中。

对于C＃这很好。 Web服务创build正常。 AC＃程序可以很容易地创build一个WSDL，一切都很好。

现在尝试用VB（任何版本）创build一个WSDL。 它会说“电子邮件”已经宣布和WSDL生成失败。

就像我认为这是VB语言的一个缺点。 但！！！

使用FxCOP并分析原始的C＃代码。 FxCOP说使用电子邮件/电子邮件是一个问题。 build议使用不同的名称支持不区分大小写。 也注意到.NET框架中有106种编程语言，并且有大量的区分大小写的语言。 我们都在向云计算，希望我们的服务能够被所有的编程平台/语言访问。

所以区分大小写是你的select，如果你是C的人，你会喜欢它。 如果程序将被其他非C程序使用/访问，您需要支持不区分大小写，但是您的语言是您的select。

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

Answer 12

我还没有看到任何人在最后的第二个问题上发表评论：“2：如果VB.NET的情况在某种程度上限制了我可以用代码做什么，这足以让我考虑转向C＃吗？

我更喜欢C＃让程序员select的更多select方法，而不是限制程序员的select。 我非常喜欢C＃，但是仅仅是区分大小写，我甚至不认为它接近于学习语言，只是因为区分大小写。 所有的function都是重要的，当我看着C＃和VB.NET的优点时，我非常喜欢C＃。 但我会给你一个真正的平衡的观点，是有偏见的，因为我有一个偏好，但我会诚实地谈论C＃的弊端。

首先，两种语言都有优点和缺点。 在另一种语言中可以做到的另一种语言的差异正在缩小，谢天谢地，微软正在改进这两种语言，而且他们似乎不会对两种语言performance出不公正的偏见。

当C＃第一次出来时，VB没有它可以放在方法之前的XML注释，我喜欢用C＃。 我讨厌在VB.NET中。 但是多年来我看到，许多不是一种语言的function都被添加到另一种语言中。 （同样的MS开发团队同时开发C＃和VB，所以这些特性应该变得非常相似。）

但是你问了什么C＃有，VB不。 这里有一些我可以立即想到的：

1：C＃更简洁，用更less的打字方式！ 我甚至看到相反的主张时，愚蠢的发言，VB保存打字。 但请听那些告诉你他们使用两种语言的人，而他们也很less使用他们。 我在家里使用C＃ 和 VB，C＃，因为我喜欢它（当我在工作中与C＃工作），和我最近的工作要求，我使用VB而不是C＃。 所以我越来越频繁地使用VB现在（大约10个月），但在我个人的证词中，我更喜欢C＃，并且在实际的打字方面，VB的input相当多。 我已经读过一个例子，其中有人实际上试图说VB是更简洁，是在一个与长的variables在一个“与…”的例子，所以在VB中，你可以只使用'.property'。 这是愚蠢的声称VB需要更less的打字。 有一些事情（而不仅仅是这个例子）在VB更短，但更多的时候，当C＃更简洁，在实际操作中。

但我认为C＃更简洁的最大原因是VB的详细“IF / THEN”语句。 如果陈述是共同的。 在C＃中没有“然后”单词input！ :)所有的'结束…'语句在C＃中input，通常只是一个右括号'}'。 我读过一些人声称在VB.NET中这更加冗长是VB的优势，因为几个结束块语句/符号可以嵌套，并立即结束彼此，但我完全不同意。 一个人几乎总是可以比另一个程序员更好地在C＃或VB中编写程序，因为下一个代码版本可以devise得更好。 这适用于'混淆C＃中的众多闭括号'，如果嵌套块像几个嵌套的IF那样都是相同的types，那么VB会遇到和C＃中一样的问题。 这在VB中是没有优势的。 这种情况正是我为什么要评论我的结束语符号或结尾语句在两种语言中都适用的原因。 是的，这是比较冗长的做法，但是在任何一种语言中，你都可以select清楚，这对于基于判断的具体案例来说很重要。 我认为代码清晰度是相当重要的。

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

3：VB的'andalso'和'orelse'是相当烦人的types，所有在C＃中它只是'&&'和'||'。 再次，less打字。 在VB和C＃中，这在我的代码中并不罕见。 如果有的话，对于function来说，“OR”与“OrElse”通常无关紧要，除了“OrElse”对于计算机来说更快，所以如果程序员只是使用VB中的“Or”和“And”喜欢清晰的代码的人。 “Or”比“OrElse”要容易得多。

4：在C＃中的代码布局更灵活。 当一行很长，你想把它包装在下一行，我讨厌VB.NET的“控制”重新调整我的代码。 C＃做了一些，但我发现它在C＃中更有用，在VB中，它更加控制。 但是这更多的是VB.NET IDE与C＃IDE而不是语言本身。 但是我不知道你是否想要没有IDE差异，或者纯粹的语言function。

5：我真的很想念的只是在C＃中创build一个新的代码块，我可能在一个方法中发生了很多事情，我想在一个非常小的代码块中声明一个variables，但是没有在该块之外声明该variables整个方法。 在C＃中，我们可以用'{'来创build一个新块，然后用'}'结束。 VB没有这样的function，但最接近的匹配是无条件的“If True Then”和“End If”块。 （注意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 

Perhaps this is enuf evidence that C# is more concise. But not all programmers like conciseness. Some prefer to read "if a < b then … " because it is more natural to their human language. And that's just fine. Preferences are fine. For me, hand effort is a factor i value, and i think anyone can get used to thinking in any symbols they prefer, for "if" and "then" are symbols of an alphabet, and C#'s "if (condition) statement;" syntax are symbols too. one is just closer to non-programmer's syntax than the other. i prefer the concise one.

I also think needing to use 'c' after character literals in VB to make it a character literal rather than a string is annoying. I like C#'s conciseness with that much more. when a method requires a character literal, you need to provide a character not a string with one character length, so sometimes you are forced to use ":"c in VB while in C# it is ':' . i think this is nit-picking tho.

To be fair, i will say there are advantages i like to VB like not having to put empty parentheses after method calls, like Dim nameUpper$ = name.ToUpperInvariant where C# requires the empty parentheses: string nameUpper = name.ToUpperInvariant() . or double that like trimming it too: Dim nameUpper$ = name.Trim.ToUpperInvariant vs string nameUpper = name.Trim().ToUpperInvariant() . I like VB's concise use of how i just used $ above to dim it ' As String' where C# does not have those shortcuts. VB has those shortcuts for String, Integer, Long, Decimal, Single, and Double types, but the disadvantage is it is less clear, so i use it with caution. but nevertheless, i prefer concise code.

Well, that's just some thots from this seasoned programmer, and as i consider, this is my programming 'testimony' of C# vs VB. both are nice languages tho, in my opinion. but yes, i still much prefer C#.

ps Since i plan to program for most of my life, i even re-learned to type using the most efficient keyboard: the Dvorak keyboard, which takes about 1/3 the effort to type English than on a Qwerty keyboard. look it up. maybe you might want to switch too. 😉 it made my typing 67% easier! 🙂 I encourage anyone to think outside the box and evaluate better efficiency in your work. The Dvorak Simplified Keyboard Layout and C# has done this for me. 🙂

PSS i would compare the Dvorak and C# to metric as opposed to the Qwerty keyboard layout and VB to the Empirial measurements. Dvorak, metric, and C# are just 'clean'. BUT VB is not really far behind. But it does suffer from needing to be backward compatible to old VB6 code and pre .NET code, like the 'Or' vs 'OrElse', and 'IIF()'.

I finish with a caution. Please be more prudent that listening to people who do not really know what they are talking about. Half of all the cons against both VB and C# are not any issue anymore, and people still post about them being ignorant about what disadvantages really still do exist in the language. The best example i can think of is XML comments for methods using triple apostrophe in VB or triple slash comment symbols in C#. But please discern for yourself whether a person is speaking from ignorance, or from experience. Personal testimony means they know from their real experience. And after someone has lots of experience in it, then perk up your ears. I have more than 10 years experience in both C# and VB. And it boils down to this: both are (very) good languages. And most the differences, you can see immediately within 5 minutes of reading code. But yes, other features it may take years to find a handicap. And one handicap that i'm aware of (in C#), I can't even think of a real life situation where it would be useful. So perhaps it isn't a handicap after all.

快乐的编码！

Answer 13

VB.NET is case-INsensitive.

例子：

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 

These all code will throw a COMPILE-TIME ERROR .

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

While for the 2nd and 3rd example, error will be shown saying "'Public Sub b()' has multiple definitions with identical signatures." and "'Public Function c() As Integer' has multiple definitions with identical signatures.", respectively.

From these errors, note that the errors are thrown at different positions for variables and procedures/functions. For variables, error is thrown at 2nd declaration while for procedures/functions it is thrown at 1st declaration/definition of identical code.

As said by a user in a comment somewhere above, the VB.NET code is continuously checked and/or corrected in background; you can see this error in "Error List" window in VS IDE. And as this is AN ERROR and NOT A WARNING , the code will not compile until error is resolved.