vb真的不区分大小写吗?

vba与 VB.NET 仅仅是因为vb.net在后台连续编译。编译VBA时会出错。

喜欢 Jonathan says ,在编程时,除了字符串比较、XML和其他一些情况外,您可以将vb.net视为不区分大小写…

我想你对引擎盖下面的东西感兴趣。嗯,.NET公共语言运行库是 区分大小写 和vb.net代码依赖于运行时,因此您可以看到它在运行时必须区分大小写,例如在查找变量和方法时。

vb.net编译器和编辑器允许您忽略这一点-因为它们 纠正这个问题 在您的代码中。

如果使用动态特性或延迟绑定(选项strict off),则可以证明基础运行时区分大小写。另一种方法是认识到区分大小写的语言(如C)使用相同的运行时,因此运行时显然支持区分大小写。

编辑 如果你想从等式中去掉ide,你可以 compile from the command-line . 在中编辑代码 Notepad 所以它有 ss 和 SS 看看编译器做了什么。

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

很明显,clr实际上是 区分大小写。一些程序设计 与VisualBasic一样,语言也是如此 不敏感。当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组件时,可能会导致问题。前一个案件由 Common Language Specification .相关规则是:

考虑两个标识符 不同的是,它们之间的差别必须更大 不仅仅是他们的案子。

类型库生成器相当粗略地处理了COM案例,它强制具有相同名称的标识符的大小写保持一致。即使这些标识符具有不同的角色。换句话说,名为“index”的方法参数将强制将方法名“index”改为“index”。就像你想象的那样,这已经产生了相当多的头部抓伤。

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

IDE假定变量的声明是该变量的“正确”情况,并调整该变量的每个实例与声明匹配。它之所以这样做是因为眼糖和一致性的原因,但不是为了功能。

我看到过一些实例,其中案例没有自动更改以匹配声明,并且语句的工作原理也完全相同。您还可以使用任何文本编辑器来编写代码,这些代码在不同的情况下都可以很好地编译。

旁注:

大多数 人 以不区分大小写的方式思考。当我们看到“狗”这个词时,这个词在我们的头脑中就被翻译成了意义。这个词的意思不是基于大小写的(也就是说,不管拼写成“dog”、“dog”还是“dog”都会叫)。 计算机 把单词看成是一袋离散的比特。大小写是不同的位模式,因此是不同的。

由于大多数程序员都是人,因此不区分大小写似乎更适合人们的思维方式,而区分大小写更多的是关于人类如何适应机器的约束条件。

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

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

我不确定我理解你?vb不区分大小写,所以ss和ss是同一个变量,所以编译器会正确地抱怨您重新声明了变量。

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

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

人们不必在vb.net中千方百计地创建具有不同大小写“拼写”的标识符的代码。不使用“rename”函数更改声明的文件中标识符的大小写不会导致在其他文件中更新该名称,但编辑包含该名称的任何行将使其符合当前定义。

通过这种方式,我们可以确定vb.net主要是不区分大小写的,但它确实使标识符的大小写对clr可用,clr可以以区分大小写的方式使用这些信息。

我只能提供这一点,正如我在80年代早期的编程课本中回忆的那样,感觉语言(当时)严格是为了减少编译时错误。也就是说,“严格性”是为了开发一种更精确的编码规则。正如它所证明的那样,对变量、类、方法、函数以及您希望在其中添加的其他内容添加了适当的标签,这也是进化的。

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

鉴于这些语言和IDE的进步,更好的问题是,哪种语言可以提高我的开发时间?当然,如果你不熟悉每种语言,你的选择是有限的。

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

“如果vb.net case以某种方式限制了我对代码的处理,那么这是否足以让我考虑转到C语言?”

使用c_创建WCF Web服务。创建一个DataContract(1类)。一个具有“字符串电子邮件”属性。另一个属性是“字符串电子邮件”。您可以选择将其理解为个人电子邮件或办公室电子邮件。或者它可能在两个不同的数据合同中。

对于C这很好。Web服务创建得很好。C程序可以轻松地创建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

我还没有看到任何人对你最后明确的第二个问题发表评论:“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在家是因为我喜欢它(当我和c在工作时),而且我最近的工作要求我使用vb而不是c。所以我现在越来越频繁地使用vb(现在大约10个月),但在我的个人证词中,我更喜欢c,而且就实际的打字而言,vb的打字次数要多得多。我读过的一个例子,有人试图说vb更简洁,给出了一个“with…”的例子,其中with中有一个长变量,所以在vb中,您可以只使用“.property”。这是愚蠢的宣称,vb需要较少的打字。在VB较短的地方有一些东西(不仅仅是这个例子),但在实际操作中,当C更简洁时,会出现更多的情况。

但我认为C更简洁的最大原因是VB的冗长的“if/then”语句。if语句很常见。在C中没有“then”字可输入!:)此外,所有“end…”语句都采用C中的类型,通常只有一个右大括号“”。我已经读到一些人声称在vb.net中更详细是vb的一个优势,因为几个封闭块语句/符号可以嵌套,并立即在彼此旁边结束,但我非常不同意。与其他程序员相比,一个人几乎总是可以用C或VB编写一个更好的程序,因为下一个代码修订版可以设计得更好。这适用于“在C中混淆许多右大括号”加上如果嵌套块都是同一类型,就像几个嵌套的if's一样,那么vb会遇到与在C中相同的问题。这在VB中没有优势。这种情况正是我喜欢评论两种语言的结束符号或结束语句的原因。是的,这样做更为冗长,但是在任何一种语言中,您都可以选择清楚,这在基于判断的特定情况下都很重要。我认为代码清晰性非常重要。

2:vb没有多行注释。当我使用VB时,我不介意。然后我学习了一些C语言。现在我回来的时候大部分时间都在使用vb.net,我很想念它们。这只是一些你觉得方便的事情,然后不得不失去。:。(

3:vb的“andalso”和“orelse”在c中简单地是“&&”和“”时,输入所有这些内容相当烦人。同样,减少打字。这在我的VB和C代码中并不少见。如果对于功能性,或者“vs”orelse“通常不重要,除了“orelse”对计算机来说更快,所以如果程序员只使用“or”、“and”和“in vb”,那么它会为喜欢清晰代码的人生成不太理想的代码。或者“比”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

也许这是Enuf证据,证明c更简洁。但并非所有的程序员都喜欢简洁。有些人喜欢读“如果A<B那么…”因为这对他们的人类语言来说更自然。很好。偏好很好。对我来说,努力是我的价值所在,我认为任何人都可以习惯于用他们喜欢的任何符号来思考,因为“如果”和“那么”是字母表的符号,而“c”是“如果(条件)语句”;语法也是符号。一个比另一个更接近非程序员的语法。我喜欢简明扼要的。

我还认为,在VB中,需要在字符文本后面使用“c”,使其成为字符文本而不是字符串,这很烦人。我更喜欢C的简洁。当一个方法需要一个字符文字时,您需要提供一个字符而不是一个长度为一个字符的字符串,因此有时您必须使用 ":"c 在vb中,而在c中 ':' . 我觉得这是个吹毛求疵的家伙。

公平地说,我喜欢vb有一些优点,比如不必在方法调用后放空括号,比如 Dim nameUpper$ = name.ToUpperInvariant 其中c需要空括号: string nameUpper = name.ToUpperInvariant() . 或者加倍,就像修剪它一样: Dim nameUpper$ = name.Trim.ToUpperInvariant VS string nameUpper = name.Trim().ToUpperInvariant() . 我喜欢vb的简洁用法 $ 上面将其变暗为“字符串”,其中c没有这些快捷方式。vb有字符串、整型、长型、小数型、单型和双型的快捷方式,但缺点是不太清楚,所以我谨慎使用。但是,我更喜欢简洁的代码。

嗯,这只是这个经验丰富的程序员的一些想法,我认为,这是我对C与VB编程的“证词”。在我看来,这两种语言都很好。但是的,我还是更喜欢C。

另外,由于我计划大部分时间编程,我甚至重新学会了用最有效的键盘打字:dvorak键盘,它比QWERTY键盘要花大约1/3的时间来打字。查一查。也许你也想换一个。;)它使我的打字容易了67%!:)我鼓励任何人跳出框框思考,评估你工作的效率。dvorak简化了键盘布局,C为我做了这些。:)

P.S.S.I会将dvorak和c_与公制进行比较,而不是将qwerty键盘布局和vb与经验性测量进行比较。dvorak、metric和c只是“干净”。但vb并不落后。但它确实需要与旧的vb6代码和.NET之前的代码向后兼容,比如“或”vs“orelse”和“iif()”。

我谨慎地完成了任务。请更加谨慎地倾听那些不知道自己在说什么的人。反对vb和c的一半是 不 任何问题都不再存在了,人们仍然在发帖说他们对语言中真正存在的缺点一无所知。我能想到的最好的例子是在VB中使用三撇号的方法的XML注释,或者在C_中使用三斜杠注释符号。但请你自己辨别一个人是出于无知,还是出于经验。个人证词意味着他们从实际经验中了解。当有人有丰富的经验后,振作你的耳朵。我在C和VB方面都有10年以上的经验。归根结底,这两种语言都是(非常)好的语言。大多数的差异,你可以在5分钟内立即看到代码的阅读。但是的,其他的功能可能需要数年才能找到一个障碍。我意识到的一个障碍(在C中),我甚至想不出一个现实生活中有用的情况。所以也许这并不是一个障碍。

快乐编码!

vb.net不区分大小写。

实例:

1。

Dim a As Integer
Dim A as Integer

2.第2条。

Sub b()
    'Some statement(s) here
End Sub
Sub B()
    'Some statement(s) here
End Sub

三。

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的“错误列表”窗口中看到这个错误。作为 这是一个错误 和 不是警告 ,在解决错误之前不会编译代码。

隐藏符号(如本地隐藏字段)也不区分大小写。

这里是一个 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 两次通过该字段。不管情况如何,本地是隐藏的。该语言不区分大小写。

若要显式引用a成员(如此字段),必须通过 Me :

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