Programming C#

• The Microsoft Visual Studio
• Basic concepts and syntax
• The C# type system
• Arrays, Lists, Dictionaries
• Constants
• Function overloading and generic functions
• C# projects and debugging
• Writing and running console projects

• Multiple ways to write C#
• The most elegant and efficient is probably using VS
• CIP Pool has version 2010 (2012 would be better)
• Integrated project management, debugging, profiling, ...
• Most important: File, New Project, C#, Console project

• No GUI, just the plain Windows command line
• All possibilities given in the Console class
• Possible to pass arbitrary objects to Console.Write()
• Reason: Every class inherits from object and has ToString()
• Possibility of formatting strings with placeholders {0} etc.
• Use ReadLine() to read string until RETURN

• C# (out-of-the-box) is not native and not interpreted
• Programs are saved in an intermediate language
• That makes C# universal (same concept as Java)
• C# is also managed code, i.e. no control over memory
• C# is a strongly-typed language with a static type system
• This means that types must be identified at compilation
• Encapsulation required, i.e. every function is assigned to a class

• Just two datatypes: struct and class
• Structures are value types (only copies are passed)
• Classes are reference types (references are passed)
• The concept of a pointer is embedded in the language
• Passing structures by reference is possible with the ref keyword
• Another way is the out keyword (enforces assignment)
• Every object inherits at least from another object called object

• The syntax is quite close to C++ / Java
• Datatypes have to be specified
• Example: Due to encapsulation all console related functions can be found in the static class Console, which is located in the System namespace
• Why static class? Closest to C printf(), scanf(), ...
• Namespaces guarantee overview and unique naming

• Example is quite close to C++
• Differences: using for embedding namespaces
• The main method has to be specified differently
• We have static void Main(string[] args)
• Array datatype has already a field to specify the length
• No header files and macros
• if, else, for, ... as in C++
• Additionally we have foreach and lock

• The dot operator lets use access the members of an object
• Constants need to be defined using const and a type
• Only structures can be constants, otherwise use readonly
• Arrays are defined different than in C/C++
• However, accessing arrays is the same as in C/C++
• Several literals for creating types, like "hello" is a string type, 'C' is a new char, 4 a new integer and 4.0 a new double

• Some basic structures (size in bytes): char (2), short (2), int (4), long (8), float (4), double (8), decimal (16), bool (1)
• Some important classes: string, Array, ArrayList, Stack, Queue
• We have enum, struct, class, interface, delegate to create new data types
• An enumeration is a collection of constants
• A delegate is a managed function pointer

• C# supports the same standard operators as C++
• Overloading is only possible for certain operators
• The execution hierachy is determined by the operator
• Changing the hierachy is possible by using brackets
• A selection of operators: +, -, *, /, %, !, <, >, ==, !=, <<, >>, ...

• A simple array of integers: int[] myarray = new int[5];
• Initialization char[] arr = new char[] { 'a', 'b', 'c' }
• Modification arr[2] = 'd' (0-based !)
• More-dimensional: double[,] matrix = new double[5,5];
• Access Console.WriteLine("M_33 = " + matrix[2,2])
• It is also possible to use jagged arrays like so:

  double[][] matrix = new double[5][];
  matrix[0] = new double[5]; // ...
  

• The .NET-Framework contains a huge number of collections
• Collections go beyond the fixed limits of arrays
• With OOP it is easily possible to create own implementations
• Some collections are obvious (Dictionaries, Hashtables, Lists) others more specialized (Stack, Queue)
• The ArrayList object is one of the simplest implementations
• It takes only types of type object

• The basic datatypes have useful helper functions and members
• Examples are: double.TryParse(), int.MaxValue


• Functions can accept many input parameters by use of the params keyword


• Enumerations can be formatted with a nice string representation using the Flags attribute

• Functions are defined by their attributes and can be overloaded
• Alternatively: Generics is a way of reusing code
• For methods the compiler can (mostly) infer the type
• In the following example also note the use of ref

public static void Swap<T>(ref T l, ref T r) {
	T temp = r; r = l; l = temp;
}
int a = 3; int b = 4; Swap(ref a, ref b);

• Debugging is great with the VS
• Remember: F5 to start debugging
• CTRL+F5 to start the project
• Insert breakpoints to see what's going on
• While debugging: F10 to step over, F11 to step into
• Step out of the current function with SHIFT+F11
• More possibilites (watches, locals, interaction, ...)

• Never use a MessageBox or the Console for debugging
• Best options: Debug or Trace
• Here output will be send to the output window
• They are only used if certain definitions are active
• Also remember that we have the DEBUG definition in debug-mode
• Recommendation: Just use Debug.WriteLine()
• Also use breakpoints and (advanced) conditional breakpoints
• Use the stack-trace for navigation