I figure it's best if I go ahead and make a sort-of walkthrough to learning C# code from VB.NET. Note that I am using Visual Studio 2010 Beta for my C#.NET code.
For the most part, the .NET portion of the languages are fairly similar. For example, Hello World in C# as compared to the same version of Hello World in VB.NET.
    Private Sub Btn_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Btn.Click
        MessageBox.Show("Hey, y'all!")
    End Sub

       private void btn1_Click(object sender, EventArgs e) {
            MessageBox.Show("Hey, y'all!");
        }  // End of btn click procedure.

The first line of each declares the subroutine: private void for C# in place of Private Sub in VB.NET. In both cases, the IDE generates this line of code automatically when you double-click on the button or call up the button click event in the code window. The last line ends the area of the subroutine: End Sub in VB and } in C#. The braces in C# match up nicely to box in the code, so that all of the code of the subroutine must lie between { and }.
However, Visual Studio tends to put the { and the } each on their own line. My eyes don't want to be that sensitive so I strive to put something else on the line with one character. So, I stuff the { immediately after the private void (or subroutine) declaration (you can have Visual Studio do this for you automatically by going into Tools->Options->Text Editor->C#->Formatting->New Lines along with other things to suit your needs). I place a comment on the end of the }, which serves two purposes: to make the line easier for me to read and to fully describe why this } is here. In C#, every block of code ends with }, so to keep tabs of what block of code is being closed by }, I add a comment to the end of it.
You'll note that comments in C# are // instead of '. C# also has a large-scale block comment feature that you can use to comment an enclosed area. Just place /* on the left and */ on the right.
/* A really large comment
that goes over multiple lines
and that has lots of content to read */

The other main difference - probably the most important, but definitely the easiest to miss - between the VB and C# examples above is the semicolon at the end of the call to MessageBox.Show. For coding purposes, the semicolon is to C# as the new line is to VB. You can actually split a simple piece of code into several lines without affecting the functionality: 
        private 
            void 
            btn1_Click
            (
            object sender, 
            EventArgs e) 
        {
            MessageBox.Show
                ("Hey, y'all!");
        }  
        // End of btn click procedure.
But why would you ever want to do that? I definitely will not be doing the above ever again! However, what is required is the semicolon. Delete as many new-lines as you want to and the code still works: 
        private void btn1_Click(object sender, EventArgs e) {MessageBox.Show("Hey, y'all!"); }// End of btn click procedure.
But delete that semicolon and you'll get a error " ; expected ". Despite VS.NET seeming to know where you want to put the semicolon it doesn't seem to have a feature that automatically adds it for you. But, I suppose that typing the ; is just the sign of a C programmer and having Visual Studio put it there robs you out of your C# experience. So, don't forget the semicolon. Put it on every object declaration, assignment code, or function call!
Again most of the .NET methods are identical between the two languages.

Variables and Math Operators in C#

The first difference I will go through are variable declarations: 
    Private Sub Btn_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Btn.Click
        Dim Bt As Byte, Sh As Short, It As Integer, Lg As Long, Sg As Single, Dbl As Double, Dc As Decimal
        Dbl = 1.0R 'R after a number makes it a 'real' number, better known as a double-precision floating point.
        Sg = 2.0F 'F after a number makes the number a float so that it works with other single-precision floating point.
        Dc = 3D 'D after a number makes the number a decimal so that it works with other decimal types (80-bit non-exponented number).
        Lg = 4L 'L after number makes number a long so that math works with other longs (64-bit integer)
        It = 5I     'I makes integers, but since Integer is the default for any number, omitting the I would still have 3 treated as an integer.
        Sh = 6S     'S after a number makes it a short so that math works with other shorts (16-bit integers)
        'S -> I -> L -> D -> F -> R
    End Sub

Adding a certain letter to the end of each number transforms that number into a different data type. This can be done in Visual Studio .NET. I typically use it so that I ensure that methods that accept multiple types of numbers use the right type of number. Example: BinaryWriter can write Integers and Shorts to a binary file - to differentiate when I want it to store a Short, I write BW.Write(6S) instead of BW.Write(6) so that a 16-bit version of 6 is written to the file instead of a 32-bit version). For most VB.NET apps, you won't have to write many of these letters, but you may find yourself using them more in C#. Also, notice that the Byte type has no letter shortcut. It couldn't even get a B. So, variables in C#. 
        private void btn2_Click(object sender, EventArgs e) {
            byte bt; short sh; int it; long lg; float sg; double dbl; decimal dc;
            dbl = 1D;  // Use d for doubles vice r for real number.  Lowercase d is accepted.
            sg = 2F;    // F and f are fine.
            dc = 3M;    // Use M or m for decimal vice d for doubles.
            lg = 4L;    // I and VS 2010 recommend using L vice l for clarity reasons.
            it = 5;          
            sh = 4;     // Apparently, there are no literals for a short.
        } // End of btn click procedure.
After fiddling through all of the letters and special characters, I did not find a character literal for a short. Notice the semicolons are still required. Interesting differences: D is a double instead of a decimal in C#... leaving M to be used as the character literal for making decimal types. Also, there are fewer character literals: specifically none for integers and shorts. Although, to be fair, no one really uses short integers anymore now that 32-bit integers are the norm. But, in my earlier case, if I wanted to write a 16-bit integer to a binary file, I'd have to use a cast or the Convert.ToInt16 function to do the job.
Also notice the differences: C# does not automatically append .0 to the end of a number when you put an F at the end. VB.NET automatically does this by default and C++ will raise an error if you don't add the .0, but C# doesn't really mind what you do - at the end of the day, it realizes that 2F is a floating point constant that is equal to 2.0.
In Visual Studio .NET 2010, each variable currently has a green underlining, which means that these variables are not used in any meaningful way. I am currently assigning values to the variables and then leaving the function, causing all of these variables to be dumped because they are out of scope.
        private void btn2_Click(object sender, EventArgs e) {
            float inch, cm;
            inch = 5;
            cm = inch * 2.54;
        } // End of btn 2's click procedure.
If you place that code in your program, you should get a big error right there on the line that says 5 * 2.54. You may be confused if you look over the code with the untrained eye! The error listed for this is that you cannot implicitly convert a double into a float. VB.NET programmers who turn on Option Strict like good programmers would also get this error. But, ultimately, the goal is to be able to fix the error, which you can if you look up at the previous code block. In order to fix this error, we should ensure both values that are to be multiplied are both float type. We can turn 2.54 into a float by putting F at the end of it. 
        private void btn2_Click(object sender, EventArgs e) {
            float inch, cm;
            inch = 5F;
            cm = inch * 2.54F;
            // Converts a number of inches to a number of centimeters (centimetres)
            MessageBox.Show(cm.ToString());
        } // End of btn 2's click procedure.
Disaster averted. Don't forget your helpful character literals. Now for one case that is specific to C#. 
        private void btn2_Click(object sender, EventArgs e) {
            float fahr, cels;
            cels = 99.98f; // You get an error if you try to assign 99.98 to 'cels' without the F.
            fahr = cels * (9 / 5) + 32f;
            // Converts a number of inches to a number of centimeters (centimetres)
            MessageBox.Show(fahr.ToString());
        } // End of btn 2's click procedure.
Put this code in your project and you will not get an error. But, you won't get the right answer either. First, notice that I've already got rid of the error that you get by assigning 99.98 to cels. You actually assign 99.98f to cels to circumvent the error. But, when you run the program, the program will tell you that 99.98 degrees Celsius is about 131.98 degrees Fahrenheit, which is wrong. It should be very close to 212, seeing as how 100 degrees Celsius is 212 degrees Fahrenheit. So, what's wrong here? Our safest bet here is to ensure that all of the numbers that we are working with are floats. Making the change to floats solves our problem. 
        private void btn2_Click(object sender, EventArgs e) {
            float fahr, cels;
            cels = 99.98f; // You get an error if you try to assign 99.98 to 'cels' without the F.
            fahr = cels * (9f / 5f) + 32f;
            // Converts a number of inches to a number of centimeters (centimetres)
            MessageBox.Show(fahr.ToString());
        } // End of btn 2's click procedure.
So, what happened here? This is another important thing to note. VB has a forward slash for normal division and a back slash for integer division. C# has the forward slash for normal and integer division. How does C# know when to use integer division and when to use normal division? If both of the numbers used for division are integers, then C# uses integer division. If either of the numbers are floating point, then C# uses regular division. Ensure that whenever you want to do division, you ensure that the arguments are not both integers if you want to do floating point division (which includes multiplying by a fraction like we tried to do above).
        private void btn3_Click(object sender, EventArgs e) {
            int cents = 546;
            int dollars, pennies;
            dollars = cents / 100;  // Integer division - cents and 100 are both integers
            pennies = cents % 100;  // % is the modulus in C#
            MessageBox.Show(String.Format("{0} cents is {1} dollars and {2} pennies.", cents, dollars, pennies));
        } // End of btn 2's click procedure.
Above is an example of integer division and modulus in C#. Again, C# uses forward slash for integer and normal division. In this case, both sides of the division are integer, so C# uses integer division. The modulus operator in C# is the percent sign. It works the same as it did in VB.NET: takes the remainder from the division of both sides of the number.
The remainder of the math operators are unchanged: + still adds, - still subtracts or makes a number negative, and * still does multiplication. The important rule is to make sure you are converting your numbers to the right type.

If Statements and Conditional Operators

Suppose we wanted to show the first two characters in a textbox. We'd do something like this: 
        private void btn4_Click(object sender, EventArgs e) {
            string S = tb1.Text.Substring(0, 2);  // Returns the first two characters in the textbox.
            MessageBox.Show(S);  // And show them in a messagebox.
        } // End of btn 3's click procedure.
Yes, string is valid in C# and you don't have to create a character array to function as a string. But you may ask, "What if there were less than two characters in the textbox?". Then, we'd get an exception thrown at us. We can prevent that exception from appearing by using an if statement to verify that the length of the text in the textbox is greater than or equal to two. 
        private void btn4_Click(object sender, EventArgs e) {
            string S;
            if (tb1.TextLength >= 2) {
                S = tb1.Text.Substring(0, 2);  // Returns the first two characters in the textbox.
                MessageBox.Show(S);  // And show them in a messagebox.
            }  // End of if statement for text length of at least 2.
        } // End of btn 4's click procedure.
The C# if statement uses a lowercase if. In Visual Studio, the overdrive intellisense pops up a lowercase if and fixes it probably before you even realized a window popped up while you were typing "if ". Anyway, the if is a block of code, so it comes with its { and }. Also, the condition for the if is within parentheses. It may get hairy if you're calling functions several times in the if statement, but you should be able to keep track of parentheses very well with Visual Studio's excellent parenthesis tracking tool, highlighting the opening parenthesis that matches the closing parenthesis that you type. Don't put semicolons after the if block. If you do, it won't affect anything ... yet! So, that's an if block. What about the else block? 
        private void btn4_Click(object sender, EventArgs e) {
            string S;
            if (tb1.TextLength >= 2) {
                S = tb1.Text.Substring(0, 2);  // Returns the first two characters in the textbox.
                MessageBox.Show(S);  // And show them in a messagebox.
            } else {
                MessageBox.Show("Text is too short to display first two characters.");
            } // End of if statement for text length of at least 2.
        } // End of btn 4's click procedure.
Be very careful with the format for the if else block. The format goes:
if (condition) { code; } else { code; }
Don't try to put the else inside of any set of the { and } - it doesn't go there. It must be after the } closing brace for the if block, and before the { opening brace for the else block, outside of both blocks. Also, don't try to slap a semicolon on the end of the if blocks: you'll get a bunch of errors. Don't put a semicolon after the else either! Use the format above. So, how about an else if block? 
        private void btn4_Click(object sender, EventArgs e) {
            string S;
            if (tb1.TextLength >= 2) {
                S = tb1.Text.Substring(0, 2);  // Returns the first two characters in the textbox.
                MessageBox.Show(S);  // And show them in a messagebox.
            } else if (tb1.TextLength == 2) {
                MessageBox.Show(tb1.Text);
            } else {
                MessageBox.Show("Text is too short to display first two characters.");
            } // End of if statement for text length of at least 2.
        } // End of btn 2's click procedure.
So, if you need to make an else if block out of an else block, just go right after the else and type your next block (remember to put a space between else and if, because elseif is not a keyword in C#). Don't forget: no semicolons outside of the if blocks.
if (condition) { code; } else if (condition) { code; } else { code; }. If you needed to have more than two conditions, you simply go to the beginning of the lone "else" and type your next block "else if (condition) { code; }".
So, you may wonder about the two equals signs used for the second condition. This is another important distinction between VB.NET and C#. In C#, the single equals sign is only used for setting values (e.g. x = 3). The double equals sign is used for logical operations or comparisons. In general, single equal signs are outside of if conditions and double equal signs are inside of if conditions. In VB.NET, the equal sign did double duty with assigning values to variables and comparing two values. Omitting the second equal sign in C# will generally net you an error stating that you cannot implicitly convert from some type to bool and possibly an error stating that you cannot assign a value to the expression on the left. Don't forget to put two equal signs when checking conditions.
Another handy thing to note is the operator for checking if two things are not equal: 
        private void btn4_Click(object sender, EventArgs e) {
            string S;
            if (tb1.TextLength >= 2) {
                S = tb1.Text.Substring(0, 2);  // Returns the first two characters in the textbox.
                MessageBox.Show(S);  // And show them in a messagebox.
            } else if (tb1.TextLength == 2) {
                MessageBox.Show(tb1.Text);
            } else if (tb1.Text != "") {
                MessageBox.Show("Help me out.  Put some text in the textbox!");
            } else {
                MessageBox.Show("Text is too short to display first two characters.");
            } // End of if statement for text length of at least 2.
        } // End of btn 4's click procedure.
So if the textbox does not have exactly one character in it, then you'll get the third message. Do not use <> for non-equivalency in C#. You'll get an error and then you'll say "Oh, yeah." The other inequality operators are unchanged: <, >, <=, >=. Remember that, if you need an equals sign, it is always last.