No he visto a nadie comentar sobre su segunda pregunta explícita al final: "2: ¿es esto lo suficientemente convincente como para considerar pasar a C # si el caso de VB.NET limita de alguna manera lo que podría hacer con el código?"
prefiero el enfoque de más opciones que C # le permite al programador elegir si limitar las opciones del programador. prefiero C #, pero solo por mayúsculas y minúsculas, ni siquiera lo pensaría cerca de aprender un idioma solo porque distingue entre mayúsculas y minúsculas. todas las características son lo que importa, y cuando miro las ventajas de ambos, C # y VB.NET, prefiero C #. pero le daré una perspectiva verdaderamente equilibrada, sesgada, sí, porque tengo preferencia, pero también seré honesto acerca de las desventajas de C #.
En primer lugar, ambos idiomas tienen ventajas y desventajas. Las diferencias que puede hacer en un idioma que no se pueden hacer en el otro están disminuyendo ya que, afortunadamente, Microsoft está mejorando ambos idiomas, y parece que no muestran parcialidad injusta hacia ninguno de los dos idiomas.
cuando salió C # por primera vez, VB no tenía sus comentarios XML que podía poner antes de los métodos, lo que me encantó en C #. Odiaba eso en VB.NET. pero he visto a lo largo de los años, que muchas características que no están en un idioma se agregan al otro. (el mismo equipo de desarrolladores de MS desarrolla tanto C # como VB, por lo que tiene sentido que las características se vuelvan bastante similares).
pero usted preguntó qué tiene C # que VB no tiene. Aquí hay algunos que puedo pensar de inmediato:
1: C # es más conciso y requiere menos escritura ... ¡de MUCHAS maneras! Incluso he visto estupidez al hablar cuando se hace la afirmación opuesta, que VB guarda la escritura. pero por favor escuche a las personas que le dicen que usan ambos idiomas, y que rara vez usan ninguno de ellos. Yo uso C # yVB, C # en casa porque me gusta (y cuando trabajo con C # en el trabajo), y mi trabajo más reciente solicita que use VB y no C #. así que ahora uso VB con más frecuencia (desde hace aproximadamente 10 meses), pero en mi testimonio personal, prefiero C #, y en términos de mecanografía real, VB es mucho más mecanografía. El único ejemplo que he leído en el que alguien realmente trató de decir que VB era más conciso, fue dar un ejemplo 'con ...' con una variable larga en el, así que en VB, podría usar '.property'. Esto es una estupidez al afirmar que VB necesita menos tipeo. Hay algunas cosas (y no solo este ejemplo) donde VB es más corto, pero muchas veces más cuando C # es más conciso, en la práctica real.
pero la razón más importante por la que creo que C # es más conciso es la declaración detallada de IF / THEN de VB. Si las declaraciones son comunes. en C # no hay una palabra 'entonces' para escribir. :) también todas las declaraciones 'end ...' toman el tipo de letra que en c #, generalmente es solo una llave de cierre '}'. He leído que algunas personas afirman que esto es más detallado en VB.NET es una ventaja para VB ya que varias declaraciones / símbolos de bloque de cierre pueden anidarse y terminar inmediatamente uno al lado del otro, pero no estoy de acuerdo. una persona casi siempre puede escribir un programa mejor en C # o VB que otro programador porque la próxima revisión de código podría diseñarse mejor. esto se aplica a los 'confusos numerosos corchetes de cierre en C #' más si los bloques anidados son todos del mismo tipo que varios IF anidados, entonces VB sufre el mismo problema que tiene en C #. Esto no es una ventaja en VB. Esta situación es precisamente la razón por la que me gusta comentar con qué se corresponde mi símbolo de cierre o declaración de cierre en ambos idiomas. Sí, esto es más detallado, pero en cualquier idioma, tiene la opción de ser claro, lo cual es importante en casos específicos basados en el juicio y la situación. Creo que la claridad del código es bastante importante.
2: VB no tiene comentarios de varias líneas. cuando trabajé con VB no me importó. luego fui a algunos lenguajes de estilo C. ahora estoy de vuelta principalmente usando VB.NET en el trabajo, y los extraño. es algo que le parece conveniente y luego tiene que perder. :(
3: 'andalso' y 'orelse' de VB es bastante molesto escribir todo eso cuando en C # es simplemente '&&' y '||'. de nuevo, menos mecanografía. Esto no es raro en mi código tanto en VB como en C #. en todo caso, para la funcionalidad, 'OR' frente a 'OrElse' generalmente no importa, excepto que 'OrElse' es más rápido para la computadora, por lo que si un programador solo usa 'O' y 'Y' en VB, entonces produce un código menos óptimo para Alguien a quien le gusta la claridad del código. 'O' es mucho más fácil de leer que 'OrElse'.
4: más flexibilidad en la colocación de código en C #. cuando una línea es larga y desea ajustarla en la siguiente línea, odio el reajuste 'control' de VB.NET de mi código. C # lo hace un poco, pero lo encuentro más útil en C #, donde en VB, es mucho más controlador. pero esto es más del VB.NET IDE vs C # IDE en lugar del lenguaje en sí. pero no sé si quieres ambas o las características del lenguaje sin diferencias IDE.
5: uno que realmente extraño es simplemente crear un nuevo bloque de código en C #, es posible que suceda muchas cosas en un método y quiero declarar una variable en un bloque de código muy pequeño, pero no tener esa variable declarada fuera de ese bloque en Todo el método. en C #, podemos crear un nuevo bloque con '{' y finalizarlo con '}'. VB no tiene tal característica, pero su coincidencia más cercana es un bloque incondicional 'If True Then' y 'End If'. (tenga en cuenta el equivalente de 2 caracteres C # frente a 18 caracteres VB.NET de nuevo ... más escribir en VB.)
6: operadores de auto incremento y decremento: ++ y - como en myVariable++o en ++myVariablelas versiones de decremento equivalentes. Esto es muy útil ... a veces. Aquí hay un ejemplo de código real cuando perdí C # en gran medida:
// 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
Y solo para dar un MUY buen ejemplo donde C # gobierna, este es más código que personalmente escribí recientemente:
// 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
Quizás esto sea evidencia suficiente de que C # es más conciso. Pero no a todos los programadores les gusta la concisión. Algunos prefieren leer "si a <b entonces ..." porque es más natural para su lenguaje humano. Y eso está bien. Las preferencias están bien. Para mí, el esfuerzo manual es un factor que valoro, y creo que cualquiera puede acostumbrarse a pensar en cualquier símbolo que prefiera, ya que "if" y "then" son símbolos de un alfabeto y C # 's "declaración if (condición)"; la sintaxis también son símbolos. uno está más cerca de la sintaxis del no programador que el otro. Prefiero el conciso.
También creo que la necesidad de usar 'c' después de los literales de caracteres en VB para convertirlo en un literal de caracteres en lugar de una cadena es molesto. Me gusta la concisión de C # con eso mucho más. cuando un método requiere un carácter literal, debe proporcionar un carácter, no una cadena, con una longitud de carácter, por lo que a veces se ve obligado a usarlo ":"cen VB mientras está en C # ':'. Creo que esto es muy difícil.
Para ser justos, he de decir que hay ventajas me gusta a VB como no tener que poner paréntesis vacíos después de las llamadas de método, al igual Dim nameUpper$ = name.ToUpperInvariantque C # requiere los paréntesis vacíos: string nameUpper = name.ToUpperInvariant(). o el doble que al igual que el recorte también: Dim nameUpper$ = name.Trim.ToUpperInvariantvs string nameUpper = name.Trim().ToUpperInvariant(). Me gusta el uso conciso de VB de cómo acabo de usar $arriba para atenuarlo 'Como cadena' donde C # no tiene esos accesos directos. VB tiene esos accesos directos para String, Integer, Long, Decimal, Single y Double, pero la desventaja es que es menos claro, así que lo uso con precaución. pero sin embargo, prefiero un código conciso.
Bueno, eso es solo algunas de las cosas de este programador experimentado, y como considero, este es mi 'testimonio' de programación de C # vs VB. ambos son buenos idiomas, en mi opinión. pero sí, todavía prefiero C #.
ps Como planeo programar la mayor parte de mi vida, incluso aprendí a escribir con el teclado más eficiente: el teclado Dvorak, que requiere aproximadamente 1/3 del esfuerzo para escribir en inglés que en un teclado Qwerty. búscalo tal vez también quieras cambiar. ;) ¡me facilitó la escritura un 67%! :) Animo a cualquiera a pensar fuera de la caja y evaluar una mejor eficiencia en su trabajo. El diseño de teclado simplificado de Dvorak y C # lo han hecho por mí. :)
PSS compararía el Dvorak y C # con la métrica en lugar de la distribución del teclado Qwerty y el VB con las medidas empíricas. Dvorak, métrica y C # son simplemente 'limpios'. PERO VB no está muy lejos. Pero sufre la necesidad de ser compatible con versiones anteriores del antiguo código VB6 y el código pre .NET, como 'Or' vs 'OrElse' y 'IIF ()'.
Termino con precaución. Sea más prudente que escuchar a las personas que realmente no saben de qué están hablando. La mitad de todas las desventajas contra VB y C # no soncualquier problema, y la gente todavía publica acerca de que ignoran qué desventajas realmente existen en el idioma. El mejor ejemplo que se me ocurre son los comentarios XML para los métodos que utilizan el triple apóstrofe en VB o los símbolos de comentario de triple barra en C #. Pero discierna por sí mismo si una persona está hablando por ignorancia o por experiencia. Testimonio personal significa que saben de su experiencia real. Y después de que alguien tenga mucha experiencia en él, entonces levanta tus oídos. Tengo más de 10 años de experiencia en C # y VB. Y se reduce a esto: ambos son (muy) buenos idiomas. Y la mayoría de las diferencias, puede ver inmediatamente dentro de los 5 minutos de leer el código. Pero sí, otras características pueden llevar años para encontrar una discapacidad. Y una desventaja que conozco (en C #), puedo ' Incluso piense en una situación de la vida real en la que sería útil. Entonces, tal vez no sea una desventaja después de todo.
¡Feliz codificación!