VB.NET compared with C#

[Silberzorn]

Hey all,

Just a question about something I have been wondering about.
In my VB.NET book I read that one of the aims for the new .NET
framework was to place all programming languages supporting the CLR on the same footing. The book also says that regardless if a program is written in C# or VB.NET it will be compiled to similar MSIL. So my question is, is there any advantage (as in speed, flexibility, access to low-level hardware etc) in learning C#, when VB.NET is such a user friendly programming language?

Thanks,

Silberzorn

 

[Volte]

I must admit, I quite dislike VB.NET. I prefer C style syntax I guess. There are other reasons, though:

• VB.NET provides all kinds of backwards compatability features with VB6 that allows you to do all kinds of messy stuff; C# doesnt have that (thats a good thing, it keeps your code clean )
• C# allows more control over your code structure. VB.NET removes all the excess whitespace from your code, doesnt have block comments and allows you to carry on code with blank lines, while in C# you can lay it out however you like
• The only thing I dont like about C# is adding events to classes; you need to define both a Handler delegate and a Args class to call an event with custom parameters, where in VB its a simple Event line.

If you are just starting out, or are converting to .NET from VB6, I would really recommend starting with C#; it forces you away from the VB syntax (so bad habits wont persist) and removes you from all those awful compatability functions .NET provides.

 

[PlausiblyDamp]

To add to VolteFaces list

• VB has poor bitwise manipulation
• VB doesnt automatically short circuit logic evaluation, you need to use the new keywords like orelse, andalso
• C# also has operator overloading (if you need it that is)

 

[AndreRyan]

You can circumvent Voltefaces point 1 by only using the .Net classes ie. String.Length instead of Len()
You can circumvent point 2 by disabling the Pretty Listing (reformating) of code option in the Tools>Options Dialog under Text Editor>Basic>VB Specific

VB supports very simple Bitwise ops using Or and AND and Im not sure what "operator overloading" is

 

[mutant]

Originally posted by VolteFace

If you are just starting out, or are converting to .NET from VB6, I would really recommend starting with C#; it forces you away from the VB syntax (so bad habits wont persist) and removes you from all those awful compatability functions .NET provides.

Are you saying coding in VB.NET is bad?

 

[PlausiblyDamp]

Although you can use Or and AND to do bitwise stuff the same keywords are used for boolean logic as well, if there is a situation where either bitwise or boolean could be applied there doesnt appear to be a way to force bitwise (try enums with the <flags> attribute for example)

 

[Divil]

VB gained >> and << bitwise operators in the latest version, although it still cant work with unsigned types so their usefulness is limited.

VB has optional parameters, C# doesnt
C# has operator overloading, VB doesnt
VB has late binding, C# doesnt
C# supports unsafe code (where you can work with pointers), VB doesnt

Although late binding is generally a bad idea, it has its uses. There is no CreateObject in C#, which makes working with unknown COM types impossible without heavy use of reflection.

 

[Nerseus]

And C# has some goofy syntax, just like VB.

For example (just found this the other day). Normally you use one pipe (|) to do bitwise compare, and two pipes for logical boolean compares. So:

bool a = true;
bool b = false;
if(a || b)
{
    // Do something...
}
else
{
    // Do something else...
}

But, we found out that in C# you can actually use one pipe for logical boolean compares (unlike C++):

bool a = true;
bool b = false;
if(a | b)
{
    // Do something...
}
else
{
    // Do something else...
}

Its not big, but its a little sloppy in that we had two different developers working on a form and each was using a different syntax for it. Good thing we do code reviews

-Nerseus

PS Yes, I know this has nothing to do with VB/C# differences. Just giving some fuel for the VB developers who get hit with (VB is sloppy, lets you do sloppy things, blah blah).

 

[wyrd]

Nerseus:
Im not to familiar with the inner workings of .NET, but isnt the value of true 1, and the value of false 0? So.. 1 OR 0 = 1, which is true. Thus the syntax (yet cryptic) looks correct (at least to me). It seems a little odd that C/C++ wouldnt act in a similar fasion.

 

[Nerseus]

Technically, as far as C++ is defined, false is 0 but true is any number except 0 (usually 1 in C++ or -1 in VB). But the single pipe is supposed to do bitwise ORs, such as when using enums with flags:

[Flags]
public enum Seasons
{
   None = 0,
   Summer = 1,
   Autumn = 2,
   Winter = 4,
   Spring = 8,
   All = Summer | Autumn | Winter | Spring,
}

Seasons season = Seasons.Winter | Seasons.Spring;
if((season & Seasons.Winter) == Seasons.Winter)
{
    Debug.WriteLine("true");
}

But if you try the following, it wont even compile (as Id hope):

int a = 4;
int b = 7;
if(a | b) ...

-Nerseus

 

[wyrd]

But the single pipe is supposed to do bitwise ORs, such as when using enums with flags:

Perhaps my post wasnt clear, or perhaps Im not understanding what youre trying to say. Like I said I dont know the inner workings of .NET, so Im probably just being stupid and misunderstanding everything. I tend to do that.

Either way let me see if I can clear up what I said above;

bool a = true;
bool b = false;

Bits in both values;
a = 00000001
b = 00000000
You or these values and you get
= = 00000001

Is the result not the same as the value true?

if (a | b) should provide true as the result. I would think that this would be the same for if (00000001) or rather if (1).

This example;
int a = 4
int b = 7

a = 00000100
b = 00000111
Or the values..
= = 00000111

so if (a | b) is the same as saying if (00000111) or if (7). I would assume that this of course would give you a compile error, as 7 is neither true or false, which if () expects.

If this is correct (probably not, but this is what Im getting at) then the syntax if (a | b) is correct. In C++, if false is 0 and true is not 0, then I see no reason why this wouldnt work under C++ either. Except of course it would consider if (7) as true, which is probably a bad thing.

 

[Volte]

Originally posted by AndreRyan
You can circumvent Voltefaces point 1 by only using the .Net classes ie. String.Length instead of Len()

I know that, but C# doesnt even provide those options, so VB.NET can be confusing to newbies who dont know what is considered "correct".

I mean, theres nothing wrong with coding in VB.NET as long as you know what youre doing, otherwise you can get bogged down in the "extra" options VB provides you which should generally be avoided.

 

[Nerseus]

wyrd: Your example would (and should) work perfectly in C++, as the bool values are really ints (C++ has overloads for BOOL and values like TRUE and FALSE - there is no native Boolean datatype).

But in C#, its a bit "sloppy" to have the | operator be a bitwise OR in case and a logical OR in another, based on datatypes. C# was supposed to be more type safe but I consider the single pipe a "slip". Since C# doesnt define what int value a bool type has (0, 1, -1, etc.) internally, you shouldnt be able to use an operator that *normally* is used for bitwise operations (which only work on numbers, not abstract datatypes like a boolean). The fact that it does work is only a convenience in case you forget which to use (one pipe or two). Since most people would call this "sloppy" and choose to only use the two pipes, I thought it worth mentioning (since were on the topic of "sloppy" coding in VB.NET versus the "clean" coding of C#).

-Nerseus

 

[wyrd]

Ohhh.. I gotcha.

Originally posted by Nerseus
wyrd: Your example would (and should) work perfectly in C++, as the bool values are really ints (C++ has overloads for BOOL and values like TRUE and FALSE - there is no native Boolean datatype).

But in C#, its a bit "sloppy" to have the | operator be a bitwise OR in case and a logical OR in another, based on datatypes. C# was supposed to be more type safe but I consider the single pipe a "slip". Since C# doesnt define what int value a bool type has (0, 1, -1, etc.) internally, you shouldnt be able to use an operator that *normally* is used for bitwise operations (which only work on numbers, not abstract datatypes like a boolean). The fact that it does work is only a convenience in case you forget which to use (one pipe or two). Since most people would call this "sloppy" and choose to only use the two pipes, I thought it worth mentioning (since were on the topic of "sloppy" coding in VB.NET versus the "clean" coding of C#).

-Nerseus