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

Я не пытаюсь начать аргумент здесь, но по какой-то причине обычно утверждается, что Visual Basic нечувствителен к регистру, а языки C - нет (и как-то это хорошо).

Но вот мой вопрос: где именно Visual Basic не учитывает регистр? Когда я печатаю. , ,

Dim ss As String
Dim SS As String

. , , в среду IDE Visual Studio 2008 или Visual Studio 2010 , вторая содержит предупреждение « Локальная переменная SS уже объявлена ​​в текущем блоке ». В VBA VBE он не сразу выдает ошибку, а просто автоматически исправляет регистр.

Я что-то здесь упускаю с этим аргументом, что Visual Basic не чувствителен к регистру? (Кроме того, если вы знаете или хотите ответить, почему это плохо? )

Почему я даже задаю этот вопрос?

Я использовал Visual Basic во многих его диалекты в течение многих лет, иногда как любитель, иногда для маленьких связанные с бизнесом программы в рабочая группа. По состоянию на последние шесть месяцев, Я работал над большим проектом, намного больше, чем я ожидал. много образца исходного кода там находится в C #. У меня нет горения желание изучать C #, но если есть вещи, которые я пропускаю на этом C # предлагает, что Visual Basic не (противоположность будет VB. NET предлагает XML-литералов ), тогда я хотел бы знать подробнее об этой функции. Так что в этом случай, это часто утверждается, что C языки чувствительны к регистру и это хорошо, и Visual Basic имеет место нечувствителен и это плохо. Я бы нравится знать. , ,

  1. как именно Visual Basic без учета регистра, потому что каждый один пример в редакторе кода становится чувствительным к регистру (смысл дело исправляется) хочу ли я это или нет и
  2. это достаточно убедительно для меня, чтобы рассмотреть возможность перехода на C #, если VB. NET чехол как-то ограничивает то, что я мог сделать с кодом?
вопрос задан 20.02.2010
Todd Main
27401 репутация

14 ответов


  • 97 рейтинг

    Разница между VBA и VB. NET только потому, что VB. NET компилируется постоянно в фоновом режиме. Вы получите ошибку при компиляции VBA.

    Как Джонатан говорит , при программировании вы можете думать о VB. NET как регистрозависимый, кроме сравнения строк, XML и некоторых других ситуаций. , ,

    Я думаю, вы заинтересованы в том, что под капотом. Ну, то. NET Common Language Runtime - с учетом регистра и VB. NET код зависит от времени выполнения, поэтому вы можете видеть, что он должен быть чувствительным к регистру во время выполнения, e. г. когда он ищет переменные и методы.

    В.Б. NET компилятор и редактор позволяют вам игнорировать это - потому что они исправляют регистр в вашем коде.

    Если вы играете с динамическими функциями или с поздним связыванием (Option Strict Off), вы можете доказать, что базовое время выполнения чувствительно к регистру. Еще один способ убедиться в этом - понять, что чувствительные к регистру языки, такие как C #, используют одну и ту же среду выполнения, поэтому среда выполнения, очевидно, поддерживает чувствительность к регистру.

    РЕДАКТИРОВАТЬ Если вы хотите вывести IDE из уравнения, вы всегда можете скомпилировать из командной строки . Отредактируйте ваш код в блокноте , чтобы он имел ss и SS, и посмотрите, что делает компилятор.

    РЕДАКТИРОВАТЬ Цитата из Джеффри Рихтера в . Руководство по проектированию NET Framework стр. 45.

    Чтобы было ясно, CLR на самом деле с учетом регистра. Немного программирования языки, такие как Visual Basic, являются регистром нечувствительны. Когда компилятор Visual Basic пытаясь разрешить вызов метода к тип определяется с учетом регистра язык как C #, компилятор (не CLR) выясняет фактический случай имени метода и встраивает его в метаданные. CLR ничего не знает о этот. Теперь, если вы используете отражение привязать к методу, отражению API-интерфейсы предлагают возможность сделать поиск без учета регистра. Это степень, в которой CLR предлагает случай-нечувствительность.

    ответ дан MarkJ, с репутацией 27128, 20.02.2010
  • 21 рейтинг

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

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

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

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

    ответ дан JaredPar, с репутацией 555649, 20.02.2010
  • 16 рейтинг

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

    ответ дан Jonathan Allen, с репутацией 38545, 20.02.2010
  • 9 рейтинг

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

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

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

    ответ дан Hans Passant, с репутацией 772347, 20.02.2010
  • 6 рейтинг

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

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

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

    Примечание:

    Большинство ЛЮДИ думают без учета регистра. Когда мы видим слово «собака», это слово переводится в значение в наших умах. Значение слова не основано на падеже (т.е. е. независимо от того, произнесено ли оно по буквам "СОБАКА", "ДОГ" или "СОБАКА", все равно лает. ) КОМПЬЮТЕРЫ рассматривают слова как отдельные пакеты с битами. Прописные и строчные буквы - это разные битовые комбинации, поэтому они разные.

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

    ответ дан Andrew Neely, с репутацией 708, 29.07.2011
  • 5 рейтинг

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

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

    ответ дан Sarfraz, с репутацией 291935, 20.02.2010
  • 3 рейтинг

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

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

    ответ дан Michael Stum, с репутацией 114054, 20.02.2010
  • 1 рейтинг

    Да, VB не чувствителен к регистру. Иногда это бросает тех, кто не привык к этому, для некоторого цикла.

    ответ дан Xorlev, с репутацией 7385, 20.02.2010
  • 1 рейтинг

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

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

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

    ответ дан htm11h, с репутацией 1011, 17.05.2013
  • 1 рейтинг

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

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

    ответ дан supercat, с репутацией 54774, 14.07.2010
  • 1 рейтинг

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

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

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

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

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

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

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

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

    http: // en. википедия. орг / вики / Comparison_of_C_Sharp_and_Visual_Basic_. NET http: // www. vbrad. ком / статьи. ASPX? id = 65

    ответ дан Venkat, с репутацией 1041, 27.09.2013
  • 0 рейтинг

    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 () As Integer» имеет несколько определений с одинаковыми сигнатурами. соответственно.

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

    Как сказал пользователь в комментарии где-то выше, VB. NET-код постоянно проверяется и / или корректируется в фоновом режиме; Вы можете увидеть эту ошибку в окне «Список ошибок» в VS IDE. И поскольку - это ОШИБКА , а - НЕ ПРЕДУПРЕЖДЕНИЕ , код не будет компилироваться, пока ошибка не будет устранена.

    ответ дан Nikunj Bhatt, с репутацией 120, 5.10.2012
  • 0 рейтинг

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

    Вот пример :

    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
    

    В.Б. Вывод компилятора 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
    
    ответ дан Drew Noakes, с репутацией 178444, 10.09.2018
  • 0 рейтинг

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

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

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

    , когда впервые вышел C #, у VB не было своих комментариев XML, которые вы могли бы поместить перед методами, которые я любил в C #. Я ненавидел это в VB. СЕТЬ. но я видел за эти годы, что многие функции, которые не на одном языке, добавляются к другому. (Одна и та же команда разработчиков 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, я не возражал. Затем я перешел на несколько языков в стиле Си. теперь я вернулся в основном с помощью VB. NET на работе, и я скучаю по ним. это просто то, что вы считаете удобным, а потом должны потерять. :(

    3: VB 'andalso' и 'orelse' довольно раздражает, печатая все это, когда в C # это просто '& amp; & amp;' и '||'. опять же меньше печатать. это не редкость в моем коде как в VB, так и в C #. во всяком случае, для функциональности «ИЛИ» против «OrElse» обычно не имеет значения, за исключением того, что «OrElse» быстрее для компьютера, поэтому, если программист просто использует «И» и «И» в 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. Чистый эквивалент снова. , , больше печатать на 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:
    
    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
    
    
    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
    
    
    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.
    
    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.
    
    Public Function IsNotWithin(v&, value1&, value2&) As Boolean
        Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
    End Function
    
    
    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
    
    
    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
    
    
    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.
    
    Public Function IsNotWithin(v@, value1@, value2@) As Boolean
        Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
    End Function
    
    
    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
    
    
    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
    
    
    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.
    
    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.
    
    Public Function IsWithin(v&, value1&, value2&) As Boolean
        Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
    End Function
    
    
    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
    
    
    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
    
    
    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.
    
    Public Function IsWithin(v@, value1@, value2@) As Boolean
        Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
    End Function
    

    Возможно, это свидетельство того, что C # более лаконичен. Но не всем программистам нравится краткость. Некоторые предпочитают читать «если a & lt; b, то. , , «потому что это более естественно для их человеческого языка. И это просто отлично. Предпочтения в порядке. Для меня ручное усилие - это фактор, который я ценю, и я думаю, что любой может привыкнуть мыслить любыми символами, которые они предпочитают, так как «если» и «тогда» являются символами алфавита, а C # «оператором if (условие);» синтаксис тоже символы. один из них ближе к синтаксису непрограммиста, чем другой. Я предпочитаю краткий.

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

    Чтобы быть справедливым, я скажу, что есть преимущества, которые мне нравятся в VB, такие как отсутствие необходимости ставить пустые скобки после вызовов методов, например Dim nameUpper$ = name.ToUpperInvariant, где C # требует пустых скобок: string nameUpper = name.ToUpperInvariant(). или вдвое больше, чем при обрезке: Dim nameUpper$ = name.Trim.ToUpperInvariant против string nameUpper = name.Trim().ToUpperInvariant(). Мне нравится сжатое использование VB того, как я только что использовал $ выше, чтобы затемнить его «As String», где C # не имеет этих ярлыков. В VB есть такие сочетания клавиш для типов String, Integer, Long, Decimal, Single и Double, но недостатком является то, что он менее понятен, поэтому я использую его с осторожностью. но тем не менее я предпочитаю лаконичный код.

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

    р. s. Поскольку я планирую программировать большую часть своей жизни, я даже заново научился печатать, используя самую эффективную клавиатуру: клавиатуру Dvorak, которая требует примерно 1/3 усилий для ввода английского, чем на клавиатуре Qwerty. поищи это. может быть, вы тоже захотите переключиться. ;) это облегчило мой набор текста на 67%! :) Я призываю всех мыслить нестандартно и оценивать эффективность своей работы. Dvorak Упрощенная раскладка клавиатуры и C # сделали это для меня. :)

    П. С. С. Я бы сравнил Dvorak и C # с метрикой, в отличие от раскладки клавиатуры Qwerty, а VB - с эмпирическими измерениями. Дворак, метрика и C # просто «чистые». НО VB не сильно отстает. Но он страдает от необходимости быть обратно совместимым со старым кодом VB6 и pre. NET-код, такой как 'Or' против 'OrElse' и 'IIF ()'.

    Я заканчиваю с осторожностью. Пожалуйста, будьте осторожнее, слушая людей, которые не знают, о чем говорят. Половина всех минусов против обоих VB и C # - это , а не , больше никаких проблем, и люди до сих пор пишут о том, что они не знают о том, какие на самом деле недостатки существуют в языке. Лучший пример, который я могу придумать, это комментарии XML для методов, использующих тройной апостроф в VB или символы комментария тройной косой черты в C #. Но, пожалуйста, убедитесь сами, говорит ли человек по невежеству или по опыту. Личное свидетельство означает, что они знают из своего реального опыта. И после того, как у кого-то есть большой опыт в этом, тогда оживите свои уши. У меня более 10 лет опыта работы в C # и VB. И это сводится к следующему: оба (очень) хорошие языки. И большинство различий вы можете увидеть сразу через 5 минут после прочтения кода. Но да, другие функции могут занять годы, чтобы найти препятствие. И один недостаток, который я знаю (в C #), я даже не могу вспомнить ситуацию в реальной жизни, где это было бы полезно. Так что, возможно, это не помеха в конце концов.

    Удачного кодирования!

    ответ дан Shawn Kovac, с репутацией 1010, 24.01.2014