Действительно ли VB нечувствителен к регистру?

часть проблемы здесь заключается в том, что вам нужно разделить язык от опыта IDE.

как язык,VB.NET конечно, регистр нечувствителен по отношению к идентификаторам. Звоню DateTime.Parse и datetime.parse будет привязан к тому же самому коду. И в отличие от таких языков, как C#, невозможно определить методы или типы, которые отличаются только регистром.

как IDE, VB.NET пытается сохранить случай существующих идентификаторов, когда он довольно перечисляет блок из кодекса. Красивые списки возникают всякий раз, когда вы выходите из текущей логической строки кода. В этом случае вы переходите от второго объявления SS, симпатичный Листер замечает, что существует существующий идентификатор с этим именем и исправляет его, чтобы иметь соответствующий случай.

Это поведение, однако, чисто сделано как пользовательское значение add. Это не является частью основного языка.

VB это в основном регистр не учитывается, но есть исключения. Например, XML-литералы и понимание чувствительны к регистру. Сравнение строк обычно чувствительно к регистру, в отличие от say T-SQL, но есть переключатель компилятора, чтобы сделать сравнение строк нечувствительным к регистру. И, конечно же, есть крайние случаи, когда речь идет о наследовании, COM и динамической языковой среде выполнения.

да, VB.NET компилятор обрабатывает идентификаторы без учета регистра. И да, это может вызвать проблемы, когда он потребляет сборки, написанные на другом языке или использует COM-компоненты. Первый случай охватывается Спецификация Общего Языка. Соответствующее правило:

для двух идентификаторов различные, они должны отличаться больше чем только их дело.

в случае com-это довольно грубо взяли забота о построителе библиотеки типов, он заставляет корпус идентификаторов с тем же именем быть идентичными. Даже если эти идентификаторы имеют разные роли. Другими словами, параметр метода с именем "index" будет принудительно возвращать имя метода "Index" в "index". Это произвело довольно много царапин в голове, как вы можете себе представить:)

VB это случае сохранения (в IDE), но регистр. Это как файловая система Windows в некотором роде. Привет.TXT и привет.txt считаются одним и тем же именем файла.

IDE предполагает, что объявление переменной является "правильным" случаем для этой переменной и корректирует каждый экземпляр этой переменной в соответствии с объявлением. Он делает это по причинам глаз-конфеты и последовательности, но не для функциональности.

Я видел несколько случаи, когда обращение не было автоматически изменено в соответствии с объявлением, и оператор работает точно так же. Вы также можете использовать любой текстовый редактор для написания кода, который будет компилировать просто отлично в разных случаях.

сторона-Примечание:

большинство человек думайте без учета регистра. Когда мы видим слово "собака", это слово переводится в нашем сознании в смысл. Значение слова не основано на падеже (т. е. независимо от того, если по буквам это "собака", "собака", или "собака" все еще лает.)компьютеры см. слова как дискретные мешки битов. Верхний и нижний регистр-это разные битовые шаблоны, и поэтому они разные.

это часть редактора, который вы используете, они могут вести себя по-разному, но дело в том, что Visual Basic действительно язык без учета регистра. Итак,ss и SS такие же.

пожалуйста, взгляните на VB.NET основы учебник для получения дополнительной информации:)

Я не уверен, что понял вас? VB нечувствителен к регистру, поэтому ss и SS-это одна и та же переменная, поэтому компилятор правильно жалуется, что вы повторно объявили переменную.

Я думаю, что переменные не чувствительны к регистру, но имена функций.

да, VB нечувствителен к регистру. Он иногда бросает тех, кто не привык к немного петли.

никто не должен пытаться все это трудно в VB.NET для создания кода с разными прописными/строчными "написаниями" идентификатора. Изменение регистра идентификатора в файле, где он объявлен, без использования функции "переименовать" не приведет к обновлению имени в других файлах, хотя редактирование любой строки, содержащей имя, приведет к его соответствию настоящему определению.

таким образом, можно определить, что VB.NET в основном регистр не учитывается, но это сделайте регистр идентификаторов доступным для среды CLR,которая может использовать эту информацию с учетом регистра.

Я могу только предложить это, что, как я помню из моих учебников по программированию еще в начале 80-х годов, является тем, что case senstive languages были (в то время) строго предназначены для уменьшения ошибок времени компиляции. То есть," строгость " предназначалась для развития кодирующей дисциплины большей точности. Как оказалось, добавление правильной маркировки переменных, классов, методов, функций и всего остального, что вы хотите бросить туда, также эволюционировало.

Я помню почти все эти книги включали рекомендуемый шаблон для ведущей капитализации, нижнего регистра и т. д. Как мы все знаем, многое из этого было выброшено или, я бы сказал, проигнорировано на практике, за исключением высокопроизводительных производственных домов и решений для случаев или для тех, кто достиг более высокого уровня квалификации. Я думаю, что каждый испытывает эту кривую обучения.

учитывая прогресс этих языков и IDE, лучше вопрос становится, какой язык улучшает мое время разработки? Конечно, если вы не знакомы с каждым из различных langs, ваши варианты ограничены.

Я постараюсь ответить на ваш второй вопрос.

" достаточно ли это убедительно для меня, чтобы рассмотреть возможность перехода на C#, если VB.NET case как-то ограничивает то, что я мог бы сделать с кодом?"

создайте веб-сервис WCF с помощью C#. Создайте DataContract (1 класс). Один с свойством "string email". Другой с "Строковой электронной почтой" в качестве другого свойства. Ваш выбор, чтобы понять, как личная электронная почта или офисная электронная почта. Или это может быть в двух разных DataContracts.

для C# это все нормально. Веб-служба создается нормально. Программа C# может легко создать WSDL, и все в порядке.

теперь попробуйте создать WSDL с VB (любая версия). Он скажет, что" электронная почта " уже объявлена, и генерация WSDL не выполняется.

Как и все, я предполагал, что это недостаток в языке VB. Но!!!

используйте FxCOP и проанализируйте исходный код C#. FxCOP говорит, что использование электронной почты / электронной почты является проблемой. Рекомендует использовать другое имя, поддерживающее нечувствительность к регистру. Также Примечание На сегодняшний день .NET framework имеет 106 языков программирования и есть много языков, имеющих чувствительность к регистру. Мы все движемся к облаку и хотим, чтобы наши услуги были доступны для всех платформ программирования/языков.

таким образом, чувствительный к регистру-это ваш выбор в вашей программе, и если вы C guy, вам это понравится. Если программа будет использоваться / доступна другими программами, отличными от C, вам нужно поддерживать нечувствительность к регистру, но ваш язык-это ваш выбор.

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

Я не видел, чтобы кто-нибудь прокомментировал ваш явный 2-й вопрос в конце: "2: достаточно ли это убедительно для меня, чтобы рассмотреть возможность перехода на C#, если VB.NET case как-то ограничивает то, что я мог бы сделать с кодом?"

Я предпочитаю более опционный подход, который C# позволяет программисту выбирать, чем ограничивать параметры программиста. я очень предпочитаю C#, но только для чувствительности к регистру я бы даже не подумал, что он близок к изучению языка только потому, что он чувствителен к регистру. все особенности-это то, что имеет значение, и когда я смотрю на преимущества обоих, C# и VB.NET, я очень предпочитаю C#. но я дам вам истинную сбалансированную перспективу, предвзятую да, потому что у меня есть предпочтение, но я буду честен и о недостатках C#.

во-первых, оба языка имеют свои преимущества и недостатки. различия, которые вы можете сделать на одном языке, который не может быть выполнен на другом, сокращаются, поскольку, к счастью, Microsoft улучшает оба языка, и они, похоже, не являются проявление несправедливой пристрастности к любому из языков.

когда 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, поэтому в VB вы можете просто использовать '.собственность'. это глупость, утверждая, что VB нужно меньше печатать. есть несколько вещей (и не только этот пример), где VB короче, но и многое другое времена, когда C# является более кратким, в реальной практике.

но самая большая причина, по которой я считаю, что C# более лаконичен, - это подробные заявления VB "IF/THEN". если заявления являются общими. в C# нет слова "тогда" для ввода! :) и все-конец ...'операторы принимают ввод, который в c#, как правило, является только одной закрывающей скобкой '}'. я читал, что некоторые люди утверждают, что это более многословно VB.NET является преимуществом для VB, так как несколько закрывающих блочных операторов / символов могут быть вложенными и заканчиваться сразу после этого друг с другом, но я совершенно не согласен. человек почти всегда может написать программу лучше в C# или VB, чем другой программист, потому что следующая редакция кода может быть разработана лучше. это относится к "запутанным многочисленным закрывающим фигурным скобкам в C#" плюс, если вложенные блоки все одного типа, как несколько вложенных IF, то VB страдает той же проблемой, что и в C#. это не является преимуществом в VB. эта ситуация именно поэтому мне нравится комментировать, что мой закрывающий символ или закрывающее заявление идет на обоих языках. да, это более подробно, но на любом языке у вас есть возможность быть ясным, что важно в конкретных ситуациях, основанных на суждениях. я думаю, что ясность кода очень важна.

2: VB не имеет многострочных комментариев. когда я работал с VB я не возражал. затем я перешел на несколько языков C-стиля. теперь я вернулся в основном с помощью VB.NET на работе, и я скучаю по ним. это просто то, что вы находите удобным, а затем должны потерять. : (

3: VB 'andalso' и 'orelse' довольно раздражает вводить все это, когда в C# это просто '&&' и '||'. опять же, меньше печатать. это не редкость в моем коде как в VB, так и в C#. во всяком случае, для функциональности " или " vs "OrElse" обычно не имеет значения, за исключением того, что "OrElse" быстрее для компьютера, поэтому, если программист просто использует " или " и " и " в VB, то он производит менее оптимальный код для тех, кто любит ясность кода. "Или" гораздо легче снять, чем "Орел".

4: больше гибкости в размещении кода в C#. когда строка длинная, и вы хотите обернуть ее на следующей строке, я ненавижу VB.NET ' s 'управление' корректировка моего кода. C# делает это немного, но я нахожу его более полезным в C#, где в VB он намного более контролируется. но это еще не все. VB.NET IDE vs C# IDE, а не сам язык. но я не знаю, хотите ли вы оба или чисто языковые функции без различий в IDE.

5: один я очень скучаю это просто создание нового блока кода в C#, у меня может быть много событий в методе, и я хочу объявить переменную в очень маленьком блоке кода, но не иметь эту переменную, объявленную вне этого блока во всем методе. в C# мы можем просто создать новый блок С '{' и '}'. VB не имеет такой функции, но самое близкое совпадение-это безусловный блок "if True Then" и "End If". (обратите внимание на 2 символа C# против 18 символов VB.NET опять эквивалент... больше набрав в ВБ.)

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# более лаконичен. Но не всем программистам нравится краткость. Некоторые предпочитают читать "если a

Я тоже думаю необходимость использовать 'c' после символьных литералов в VB, чтобы сделать его символьным литералом, а не строкой, раздражает. Мне нравится лаконичность C#с этим гораздо больше. когда метод требует символьного литерала, вам нужно предоставить символ, а не строку с длиной одного символа, поэтому иногда вы вынуждены использовать ":"c в VB в то время как в C# это ':'. я думаю, что это nit-picking tho.

чтобы быть справедливым, я скажу, что есть преимущества, которые мне нравятся VB, как не нужно ставить пустой скобки после вызова метода, например Dim nameUpper$ = name.ToUpperInvariant где C# требует пустых скобок:string nameUpper = name.ToUpperInvariant(). или удвоить это, как обрезка его тоже:Dim nameUpper$ = name.Trim.ToUpperInvariant vs string nameUpper = name.Trim().ToUpperInvariant(). Мне нравится краткое использование VB, как я только что использовал $ выше, чтобы затемнить его "как строку", где C# не имеет этих ярлыков. VB имеет эти ярлыки для строковых, целочисленных, длинных, десятичных, одиночных и двойных типов, но недостаток в том, что он менее понятен, поэтому я использую его с осторожностью. но тем не менее, я предпочитаю лаконичный код.

хорошо, это просто некоторые thots от этого опытного программиста, и, как я считаю, это мое программное "свидетельство" C# vs VB. на мой взгляд, оба языка хороши. Но да, я все еще предпочитаю C#.

P. S. S. Я бы сравнил Dvorak и C# с метрикой в отличие от раскладки клавиатуры Qwerty и VB с эмпирическими измерениями. Дворжак, Метрика и C# просто "чистые". Но VB не очень далеко позади. Но он страдает от необходимости обратной совместимости со старым кодом VB6 и предварительно .NET-кодом, например "или" против 'OrElse', и'IIF ()'.

Я заканчиваю с осторожностью. Пожалуйста, будьте более осмотрительны, что слушать людей, которые на самом деле не знают, о чем они говорят. Половина всех минусов против обоих VB и C# являются не любая проблема больше, и люди все еще публикуют о том, что они не знают о том, какие недостатки действительно все еще существуют в языке. Лучший пример, который я могу придумать, - это комментарии XML для методов, использующих тройной Апостроф в VB или тройные символы комментария Слэша в С.# Но, пожалуйста, поймите сами, говорит ли человек по неведению или по опыту. Личное свидетельство означает, что они знают из своего реального опыта. И после того, как кто-то имеет большой опыт в этом, а затем оживить ваши уши. У меня более 10 лет опыта в C# и VB. И это сводится к следующему: оба (очень) хорошие языки. И большинство отличий, вы можете увидеть сразу в течение 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

эти все код будет бросать ОШИБКА ВРЕМЕНИ КОМПИЛЯЦИИ.

для 1-го примера будет показана ошибка, говорящая, что "локальная переменная 'A' уже объявлена в текущем блоке.".

В то время как для 2-го и 3-го примера будет показана ошибка, говорящая, что "'Public Sub b ()' имеет несколько определений с одинаковые подписи."и "'публичная функция c() как целое число' имеет несколько определений с идентичными сигнатурами.", соответственно.

из этих ошибок, обратите внимание, что ошибки бросаются в разные позиции для переменных и процедур/функций. Для переменных ошибка возникает при 2-м объявлении, в то время как для процедур/функций она возникает при 1-м объявлении/определении идентичного кода.

как сказал пользователь в комментарии где-то выше, VB.NET код есть постоянно проверяется и / или исправляется в фоновом режиме; вы можете увидеть эту ошибку в окне "список ошибок" в VS IDE. И как это ошибка и НЕ ПРЕДУПРЕЖДЕНИЕ, код не будет компилироваться до тех пор, пока ошибка не будет решена.

скрытие символов (например. локальное поле скрывает) также чувствительны к регистру.

здесь пример:

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