Introduction to the C# Programming Language for the VB Programmer

1. Introduction to the C# Programming Language for the VB Programmer

2. Lecture Overview • Some key terms • Introduce the C# programming language for the VB developer • Mention some important features of the Visual Studio .NET environment • Pass along some editing tips and tricks

3. Key Terms (1) • Constructor – A special method that is called when an object is created from its class • Class – A template from which objects are created • Inheritance – The concept that one class can be created based on another class • Method – An action that the object can perform. • Property – The data stored in object. The Text property of a text box, for example

4. Key Terms (2) • Object – A class instance. Once an object has been created from its class, it’s possible to call methods and read and write properties • Objects are created when a class’ constructor is called

5. Project Structure • Everything is the same as VB • Solution file, project file, program files • Modules have a file suffix of .cs instead of .vb

6. THE BIG DIFFERENCE C# IS CASE SENSITIVE

7. Statements • In C#, all statements end with a semicolon ; • Statements can span multiple lines • There is no need for a continuation character as in VB • Example C# System.Console.WriteLine( “This is a line of text”); • Example VB System.Console.WriteLine( _ “This is a line of text”);

8. Comments • XMLSummary comments begin with /// • Single line comments are marked with // • Multi-line comments start with /* and end with */ // A comment. /* This is Also a comment */

9. Variable Declarations • Variable declarations work the same way in both C# and VB • Local variables are declared inside of a procedure • Module-level variables are declared outside of a procedure • In C#, the declaration syntax is reversed from VB

10. Data Types

11. Variable Declaration (Examples) • VB Dim Count As Integer Dim MyName As String = “Ekedahl” • C# int count; string MyName = “Ekedahl”;

12. Variable Declarations (Examples) • VB syntax to declare a module-level variable • Private Counter As Integer • C# syntax to declare the same variable • private int Counter;

13. Strings • Use the System.String data type as in VB; • The C# string type maps to System.String • the string concatenation operator is + instead of & • The members are the same between C# and VB

14. Type Conversion (Introduction) • In IS 350, you used val to convert strings to numbers • In C#, val is used to declare implicitly typed variables • We will use a much different strategy here • Each primary data type supports a method named TryParse • The method accepts 2 arguments • The string to parse • The output result

15. TryParse (Example) • Try to parse the string arg and store the result in out string arg = "123"; double result; if (System.Double.TryParse(arg, out result) == true) { return true; } return false;

16. Using System.Convert • Members of System.Convert class also convert one type to another • System.Convert.ToInt32 • System.Convert.ToDouble • System.Convert.ToDateTime • …

17. Constants • Constants are just variables whose value does not ever change • Declare with the const statement • Constants can only be initialized when they are declared

18. Constants (Example) • Declare and initialize constants const int x = 0; public const double gravitationalConstant = 6.673e-11; private const string productName = "Visual C#";

19. Scope • Access modifiers control the scope of a procedure or variable • The keywords are the same between VB and C# • private – scope is the class containing the procedure or variable • public – scope is global

20. C# Blocks • In VB, blocks are marked with keywords • Sub – End Sub • If – End If • Do Loop • While End While • In C#, blocks are all marked with {} as in Java or C++

21. C# Blocks (Example) namespace Validate { public static class ValidateNumbers { public static boolIsInteger( string arg) { } } }

22. Procedures • Visual Basic has Function and Sub procedures • C# works a bit differently • Procedures that don’t return a value have a data type of void • Procedures that do return a value have an explicitly defined data type

23. Procedures (Example 1) • The following procedure does not return a value private voidInitializeLocal() { // Statements }

24. Procedures (Example 2) • The following procedure returns a value having a data type of bool (Boolean) public static boolIsInteger(string arg, out int result) { if (System.Int32.TryParse(arg, out result) == true) { return true; } return false; }

25. Calling Procedures • To call a procedure, use it’s name • If the argument list is empty, the () are required • Call the procedure foo without arguments foo();

26. Operators (Arithmetic) • Mathematical operators are the same for both VB and C# with a few exceptions • % is the modulus operator (Mod) • ++ and -- are post and pre increment and decrement operators • Increment Count (Example) Count++;

27. Operators (Logical) • They are pretty much the same from VB and C# • Inequality (<>) in VB is (!=) in C# • Equality (=) in VB is (==) in C# • In C#, the single (=) is always used for assignment statements

28. Relational Operators • These are quite different

29. Decision-Making Statements (if) • if statements take a boolean expression as an argument • Note the parentheses are required if (i >= 0) { // do something if i is // greater than 0 }

30. Decision-Making Statements ( 2-way if) • Use the else keyword to create a 2-way if statement if ( i >= 0) { // Do something if i is // greater than 0. } else { // Do something else. }

31. Decision-Making Statements ( multi-way if) • Use else if to create multi-way decisions if (i > 0) { // Do something if i is // greater than 0. } else if (i < 0) { // Do something else. } else { // i must be equal to 0. }

32. Decision-Making Statements (switch) • C# uses the switch statement instead of Select Case • Both work the same way • The break keyword must appear at the end of each case

33. switchstatement (Example) switch (day) { case 0: DayOfWeek = “Sunday”; break; case 1: DayOfWeek = “Monday”; break; }

34. Loops (Introduction) • while is used to create a pre-test loop (Do While) • do is used to create a post-test loop (Do Until) • for loops are used when the iteration count is known in advance

35. while Loops • While loops take a boolean expression enclosed in parenthesis • The loop executes while the condition is true • {} mark the while block instead of End While

36. while Loops (Example) inti; while (i < 10) { System.Console.WriteLine(i); i++; }

37. do Loops • Do loops test the condition after the loop has executed once • Example: do { System.Console.WriteLine(x); x++; // Post increment operator } while (x < 5);

38. for Loops • Like VB, for loops can be used when the number of loop iterations is known in advance • The syntax is quite different though

39. for Loops (Syntax) for ( init-expr; cond-expr; loop-expr ) { // statement block } • int-expr contains the expression’s initial value • cond-expr contains the condition • loop-expr updates the expression

40. for Loops (Example) • Print the counting numbers from 1 to 10 for (inti = 0; i < 10; i++) { System.Console.WriteLine(i); }

41. foreach loops • foreach loops are used to enumerate arrays and collections • We will talk about collections more later • When using a foreach loop you need not explicitly increment or decrement the counter

42. foreach loops (Example) • Declare and enumerate a one-dimensional array named fibarray int[] fibarray = new int[] { 0, 1, 2, 3, 5, 8, 13 }; foreach (inti in fibarray) { System.Console.WriteLine(i); }

43. Exiting a Loop Prematurely • Use the break statement to exit a loop • Use the continue statement to jump to the loop’s condition • The condition is tested immediately • There is a goto statement to jump to a named label but we will NEVER use it

44. Importing and Using Namespaces • By default, you must fully qualify class and method names • System.IO.StreamReader for example • In VB, the Imports statement allows unqualified references • Imports System.IO • In C#, it’s the using statement • using System.IO;