Wieso wird ein immer von VB.Net abgeraten?

Wenn ErfinderDesRades sich tatsächlich nur auf VB beschränkt und möglicherweise auch auf den Author, so kann ich das nicht beurteilen. Ob und in welchem Umfang es dort bildungsinhaltliche oder leserliche Abweichungen gibt, weiß ich nicht. Bisher habe ich nur VB von Löffelmann und C# von Galileo gelesen. Ich war der Meinung, dass er generell von Galileo Computing Books abraten wollte. Dann lege eine klare Verfehlung vor...

Edit: Ah super, dann haben wir das auch geklärt!

Es wäre auch absurd einen kompletten Verlag als schlecht abzustempeln nur weil er ein etwas schlechteres Buch verlegt hat .

@thefiloe
Also so siehts mit diesen Operatoren aus:
1 und 2: haste recht.
3 und 4: braucht man eigentlich schon, 3 z.B. für das Kombinieren von Hashcodes, 4. vor allem bei Flags-Enums (die sind sogar sehr wichtig).
5: haste recht.
6: haste eigentlich auch recht, aber das kommt wohl einfach daher, dass es in VB gar keine Pointer gibt.
7: haste recht.
8: gibts so gesehen schon, die Lambda-Syntax ist in VB halt ganz anders.
9: gibts, ist einfach "Not", also das selbe wie für logische Negierung (imo unvorteilhaft, genauso wie bei = und == vs. = und =).
10. braucht man nicht, ist einfach der normale Punkt-Operator (das hingegen finde ich in C# nicht so toll).
11: haste recht.

Und die Schlüsselwörter beziehen sich ja alle auf Unsicheren Kontext, den es in VB ja nicht gibt, von daher fällt das eigentlich unter "in VB gibts kein unsafe", und was anderes, was es nicht kann, gibts afaik nicht.

1. volatile - geht in vb auch - bisserl umständlicher
   
2. fixed - kenn ich nicht - bin nicht sicher - geht aber glaub mit einem Attribut
   
3. stackalloc - kenn ich nicht - hängt das mit unsafe zusammen?
   
4. unsafe - hamwa nich
   
5. checked, unchecked - kenn ich nicht - aber es gibt eine Kompilier-Option in den Projekt-Eigenschaften - "arraygrenzen (nicht) überprüfen" - ist das sowas?
   
6. ...
   
7. %= bisserl umständlicher, aber mittm Mod-Operator durchaus zu bewältigen
   
8. &= dito - der And-Operator
   
9. ^= Xor ?
   
10. |= Or
    
11. ++ gibts +=1
    
12. Pointer - jaja - unsafe halt
    
13. sizeof - geht mitte Marshal-Klasse
    
14. => Function/Sub - Lambda-Formulierung
    
15. ~ kenn ich nich, sorry
    
16. :: dito
    
17. ?? If(Expression, nullPart)
    
18. ... gibt sicher noch paar
    

also alles bisserl umständlicher, aber noch zu handeln.
Dafür kann Vb Klassenvariablen besser initialisieren, hat die Handles-Klausel, RaiseEvent-Schlüsselwort, besseres Select Case, und mit ByRef habichmir mal einen Hack ausgedacht, den c# nicht kann - flexible Settings

Also ich finde wirklich kein Grund, einen Glaubenskrieg für vom Zaun zu brechen

@ErfinderDesRades
Also fixed, stackalloc, checked und unchecked stehen alle in Verbindung mit unsafe, es gibt dazu also keine VB-Pendants.
Was thefiloe vermutlich mit den %= usw. Operatoren meinte, ist, dass es in VB halt nicht diese Kurzform gibt. Klar lässt sich das in der langen Schreibweise auch bewerkstelligen, aber wir Programmierer sind halt grundsätzlich faul (das meine ich auch, als ich sagte, die C#-Syntax wäre mehr auf Effizienz getrimmt). Gleiches dann auch für ++ und --, klar gehts, ist aber länger.
Marshal.SizeOf macht soweit ich weiß nicht das gleiche wie der sizeof-Operator aus C# (frag mich nicht, was der Unterschied jetzt genau ist, @thefiloe: weiß es bestimmt).
Der ~-Operator ist Bitwise Not, also jedes Bit wird rumgedreht. Ist in VB einfach "Not" (so wie das logische Not). Der ::-Operator kommt afaik nur an einer Stelle vor, nämlich bei global, also global::namespace1.namespace2.somethingsomething, in VB steht da einfach der normale Punkt-Operator.

1. Ist dann halt so:

Was ich doch sehr umständlich finde.
5. haste nicht recht. Checked hat mit Überläufen zu tun und nichts mit Arrays. Genaueres nachzulesen hier: msdn.microsoft.com/en-us/library/vstudio/a569z7k8.aspx
11. += ist nicht ++. Denn du kannst mit += nicht sowas machen: Read(++i) <- etwas sinnlos aber naja.
13. Nö geht nicht. Hier machst du einen klassischen und fatalen Anfängerfehler. sizeof gibt an wie viele managed bytes für einen Typ reserviert werden. Marshal.SizeOf gibt an wie viele unmanaged bytes für einen Typ reserviert werden.

14. Natürlich geht es, doch auch hier ist wieder der bekannte overhead von Syntax welcher mir schon wieder die Freunde an Lambdaexpressions nimmt.
17. Ist auch nicht das gleiche. Wie meistens ist es auch hier wesentlich komplizierter z.B. in c#: return foo??(new Foo()); und in VB Return (foo = (foo = Nothing, New Foo()))

Klassenvariabeln kann ich nicht beurteilen(nachfragen trau ich mich :P), Handles mag manchmal recht hilfreich sein, wobei ich hier nie weiß wann jetzt ein Eventhandler angelegt wird..., RaiseEvent ist wiedermal nichts als unnötiger Syntaxoverhead, ByRef-Hack... naja keine Ahnung was das schon wieder sein soll(bin mir nicht sicher ob ich es wissen will).

Alles in allem mag man mit beiden Sprachen das meiste hinbekommen, nur hat VB bei 90% der Sachen einfach nen enormen Syntaxoverhead und einige doch recht bedeutende Sachen wie z.B. unsafe fehlen komplett, was für mich ein sehr wichtiger Teil von C# ist.