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

Ответ 1

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

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

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

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

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

EDIT Если вы хотите вывести IDE из уравнения, вы всегда можете скомпилировать из командной строки. Измените код Notepad, чтобы он имел ss и ss и посмотрел, что делает компилятор.

EDIT Цитата из Джеффри Рихтер в Рекомендации по разработке .NET Framework стр. 45.

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

Ответ 2

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

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

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

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

Ответ 3

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

Ответ 4

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

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

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

Ответ 5

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

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

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

Примечание:

Большинство PEOPLE считают нечувствительным к регистру. Когда мы видим слово "собака", слово переводится в смысл в наших умах. Значение слова не основано на случае (т.е. Независимо от того, заклинание "DOG", "DoG" или "DOG" все еще лает.) КОМПЬЮТЕРЫ видят слова как дискретные пакеты бит. Верхний и нижний регистры имеют разные битовые шаблоны и, следовательно, различны.

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

Ответ 6

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

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

Ответ 7

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

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

Ответ 8

Да, VB нечувствителен к регистру. Он иногда бросает те, которые не используются для него в течение некоторого цикла.

Ответ 9

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

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

Ответ 10

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

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

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

Ответ 11

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

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

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

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

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

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

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

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

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

Ответ 12

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

Вот пример:

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 декомпилируется (и, следовательно, эквивалентен) следующему С#:

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

Ответ 13

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

Все эти коды выдают ERILE .

В первом примере будет показана ошибка: "Локальная переменная" A "уже объявлена ​​в текущем блоке.".

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

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

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

Ответ 14

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

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

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

когда появился С#, у VB не было комментариев XML, которые вы могли бы поставить перед методами, которые я любил на С#. Я ненавидел это в VB.NET. но я видел на протяжении многих лет, что многие функции, которые не на одном языке, добавляются к другому. (одна и та же команда разработчиков MS разрабатывает как С#, так и VB, поэтому имеет смысл, что функции должны стать очень похожими.)

но вы спросили, что у С# нет, что у VB нет. здесь я могу сразу подумать:

1: С# является более кратким и требует меньше ввода.. МНОГИМИ способами! я даже видел глупость, когда речь идет о противоположном утверждении, что VB сохраняет печатание. но, пожалуйста, слушайте людей, которые говорят вам, что они используют оба языка, и они редко используются ими. Я использую как С#, так и VB, С# дома, потому что мне это нравится (и когда я работаю с С# на работе), и мои последние запросы на работу, которые я использую VB, а не С#. поэтому я все чаще использую VB сейчас (около 10 месяцев), но в моих личных свидетельствах я предпочитаю С#, и с точки зрения фактического набора текста VB значительно больше печатает. один пример, который я прочитал, где кто-то действительно пытался сказать, что VB был более кратким, давал пример с... с длинной переменной в с, поэтому в VB вы могли просто использовать ".property". это глупость в том, что VB нуждается в меньшем наборе текста. есть несколько вещей (и не только этот пример), где VB короче, но гораздо больше, когда С# является более кратким, в реальной практике.

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

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

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

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

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

6: операторы self increment and decment: ++ и - как в myVariable++ или ++myVariable, так и эквивалентные версии декремента. это очень удобно... иногда. вот пример фактического кода, когда я очень сильно пропустил С#:

// 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#
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([email protected], [email protected], [email protected]) 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([email protected], [email protected], [email protected]) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

Возможно, это доказательство того, что С# более кратким. Но не всем программистам нравится лаконичность. Некоторые предпочитают читать "если a < b then...", потому что это более естественно для их человеческого языка. И это просто отлично. Настройки прекрасны. Для меня ручное усилие является ценным фактором, и я думаю, что любой может привыкнуть к мышлению в любых символах, которые они предпочитают, поскольку "если" и "тогда" являются символами алфавита и С# "если (условие)"; Синтаксис также является символом. один ближе к синтаксису не-программиста, чем другой. я предпочитаю краткий.

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

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

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

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

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

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

Счастливое кодирование!