关于vb.net：vb真的不区分大小写吗？


Is VB really case insensitive?

我不想在这里开始讨论，但不管出于什么原因，它通常都说VisualBasic不区分大小写，而C语言不区分大小写(不知何故，这是一件好事)。

但我的问题是：VisualBasic不区分大小写到底在哪里？当我打字…

1
2
Dim ss As String
Dim SS As String

…在Visual Studio 2008或Visual Studio 2010 IDE中，第二个警告为"局部变量SS已在当前块中声明"。在vba vbe中，它不会立即触发错误，而是自动更正情况。

我是否遗漏了这样一个论点：VisualBasic不区分大小写？(另外，如果你知道或愿意回答，那为什么是件坏事？)

为什么我还要问这个问题？

我在很多方面都使用了Visual Basic多年来的方言，有时是业余爱好者，有时对小人物A中与业务相关的程序工作组。在过去的六个月里，我一直在做一个大项目，比我预想的要大得多。多在那里的示例源代码中在C中。我没有烧灼感希望学习C，但如果有我错过的东西#提供了Visual Basic所没有的(相反是vb.net提供的XML文本)，那么我想知道关于该功能的更多信息。所以在这事实上，人们经常认为语言区分大小写很好，Visual Basic就是这样。感觉迟钝，这很糟糕。我想要想知道…

  • Visual Basic有多精确不区分大小写因为代码编辑器中的单个示例变得区分大小写(意思是案件得到纠正)我是否需要它与否
  • 这足以让我信服吗？如果vb.net大小写为在某种程度上限制了我的能力用代码？
    • 相关讨论

    vba和vb.net的区别仅仅是因为vb.net在后台连续编译。编译VBA时会出错。

    就像乔纳森所说，在编程时，除了字符串比较、XML和其他一些情况外，你可以把vb.net看作是不区分大小写的…

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

    VB.NET编译器和编辑器允许您忽略这一点，因为它们纠正了代码中的情况。

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

    如果要将IDE从公式中去掉，则可以始终从命令行编译。在记事本中编辑代码，使其具有ss和ss，并查看编译器的功能。

    在.NET框架设计指南第45页中编辑Jeffrey Richter的引用。

    To be clear, the CLR is actually
    case-sensitive. Some programming
    languages, like Visual Basic, are case
    insensitive. When the Visual Basic compiler is
    trying to resolve a method call to a
    type defined in a case-sensitive
    language like C#, the compiler (not
    the CLR) figures out the actual case
    of the method's name and embeds it in
    metadata. The CLR knows nothing about
    this. Now if you are using reflection
    to bind to a method, the reflection
    APIs do offer the ability to do
    case-insensitive lookups. This is the
    extent to which the CLR offers
    case-insensitivity.

    相关讨论

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

    作为一种语言，vb.net对于标识符是不区分大小写的。调用DateTime.Parse和DateTime.Parse将绑定到完全相同的代码。与C等语言不同，不可能定义仅因大小写而不同的方法或类型。

    作为一个IDE，当VB.NET漂亮地列出一块代码时，它试图保留现有标识符的大小写。每当您离开当前的逻辑代码行时，都会出现漂亮的列表。在本例中，您将不再使用EDOCX1的第二个声明(0)，漂亮的列表器会注意到有一个具有该名称的现有标识符，并将其更正为具有匹配的大小写。

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

    相关讨论

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

    相关讨论

    是的，vb.net编译器以不区分大小写的方式处理标识符。是的，当它使用用另一种语言编写的程序集或使用COM组件时，可能会导致问题。前一种情况包含在通用语言规范中。相关规则是：

    For two identifiers to be considered
    distinct, they must differ by more
    than just their case.

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

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

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

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

    旁注：

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

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

    相关讨论

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

    有关详细信息，请参阅vb.net基础教程：)

    相关讨论

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

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

    相关讨论

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

    下面是一个例子：

    1
    2
    3
    4
    5
    6
    7
    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_：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class C
    {
        public string Name;

        public bool M(string name)
        {
            return string.Equals(name, name); // both lowercase
        }
    }

    string.Equals两次通过字段。不管情况如何，本地是隐藏的。该语言不区分大小写。

    要显式引用a成员(如此字段)，必须通过Me取消引用该成员：

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

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

    "如果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_c_Sharp_和_Visual_Basic_.nethttp://www.vbrad.com/article.aspx？ID＝65

    相关讨论

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

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

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

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

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

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

    我还没有看到任何人对你最后明确的第二个问题发表评论："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代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    // 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代码规则，更多我个人最近写道：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    // 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的证据更简明。但不是所有的程序员conciseness样。我更愿意去读一些"if＜b，然后……"因为它是更自然的人对他们的语言。那只是罚款。偏好是精细。这是我的手是我的智囊团和因子i的值，可以得到任何人的想法，他们用在任何符号的选择，"如果"和"如果"是一个符号的字母表，和(C #"if(条件语句的语法是也；"符号。一个非程序员只是接近一比其他的语法。我宁愿一个简明。

    我也认为需要使用的"C"字literals后使它在VB中的字符串文字字符，而不是一annoying。我喜欢#’s C conciseness这样的多。当你需要文字字符的方法，提供不需要的字符一个字符长度的字符串进行，所以有时你":"c被迫使用VB中的C大调':'#在它。我认为这是一个吹毛求疵的芹苴。

    是公平的，我会说我喜欢VB的优点，有不一样的方法把空parentheses调用后，在C类的要求Dim nameUpper$ = name.ToUpperInvariant# parentheses：string nameUpper = name.ToUpperInvariant()空。它也认为，像修剪或双string nameUpper = name.Trim().ToUpperInvariant()：Dim nameUpper$ = name.Trim.ToUpperInvariantVS。我喜欢使用简洁的VB的知识我使用到它上面的$暗柱不在C #有那些快捷键。VB中有那些快捷键为字符串，整数，小数，和长的单，双类型，但缺点是，它是不明确的，所以我用它与大家见面。但我仍然更喜欢简单，简洁的代码。

    好的，这只是一些thots seasoned程序员从这样的考虑，和我，这是我的’#证言C编程和VB。虽然都是漂亮的语言，在我的意见。但是，是的，我宁愿# C还多。

    另外，因为我计划计划是我生活的一大部分，甚至重新学习到最有效的利用类型的键盘：Dvorak键盘，这发生在约1 / 3的对英语的努力比在QWERTY型键盘。它的外观。也许你可能想切换了。它使我的打字)；67 %更容易！我鼓励任何人想："盒子外和你的工作效率进行了评价。德沃夏克键盘布局和简化的蛛网膜下腔出血(SAH)C #我做这。的：)

    我会把p.s.s.《德沃夏克和C #到度量的QWERTY键盘布局和喷嘴对置的VB的实证分析。德沃夏克；米制的；和c #是‘清洁’。VB是不是真的，但远落后。但它也遭受到来自需要被向后兼容旧的VB6代码和相应的代码前，与"喜欢"或"否则"和"法"()。

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

    快乐编码！好的。好啊。

    相关讨论

    vb.net不区分大小写。

    实例：

    1。

    1
    2
    Dim a As Integer
    Dim A as Integer

    2。

    1
    2
    3
    4
    5
    6
    Sub b()
        'Some statement(s) here
    End Sub
    Sub B()
        'Some statement(s) here
    End Sub

    三。

    1
    2
    3
    4
    5
    6
    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的"错误列表"窗口中看到这个错误。由于这是一个错误而不是一个警告，所以在解决错误之前，代码不会编译。