1. C# for C++ Programmers 1

2. C#: the basics Lots of similarities with C++ Object Oriented
Classes, structs & enums
Familiar basic types: int, double, bool, …
Familiar keywords: for, while, if, else, …
Similar syntax: curly braces { }, dot notation, …
Exceptions: try and catch

3. C#: the basics More closely resembles Java
Everything lives in a class/struct (no globals)
No pointers! (so no ->, * or & notation)
Garbage collection: no delete
No header files
No multiple inheritance
Interfaces
Static members access with . (not ::)

4. C# Features Properties Interfaces The foreach keyword
The readonly keyword
Parameter modifiers: ref and out
Delegates and events
Instead of callbacks
Generics
Instead of templates

5. Properties Class members, alongside methods and fields
field is what C# calls a member variable
Properties “look like fields, behave like methods”
By convention, names are in UpperCamelCase

6. Properties: simple example
class Thing { // Private field private String _name; // Public property public String Name get return _name; } set // “value” is an automatic // variable inside the setter _name = value;
class Program {
static void Main (string[] args)
Thing t = new Thing ();
// Use the setter
t.Name = “Brutus”
// Use the getter
Console.WriteLine (t.Name); }

7. Properties: even simpler example
class Thing { // Private field (the “backing field”) private String _name; // Public property public String Name get return _name; } set name = value;
class Thing {
// If all you want is a simple getter/
// setter pair, no need for a backing
// field
public String Name { get; set; } }

8. Properties: advanced getter/setter
class Thing { // Private field private String _name; private static int refCount = 0; // Public property public String Name get return _name.ToUpper (); } set _name = value; refCounter++;
Can hide implementation detail inside a property
Hence “looks like a field, behaves like a method”

9. Properties: access modifiers
class Thing { // Private field private String _name; // Public property public String Name get return _name; } private set _name = value;
Now only the class itself can modify the value
Any object can get the value

10. Properties: getter only
class Thing { // Public property public int CurrentHour get return DateTime.Now.Hour; }
In this case it doesn’t make sense to offer a setter
Can also implement a setter but no getter
Notice that Now and Hour are both properties too (of DateTime) – and Now is static

11. Interfaces Very similar to Interfaces in Java
Like a class, but all its members are implicitly abstract
C++ - all methods pure virtual (= 0)
i.e. does not provide any method implementations, only method signatures
A class can only inherit from a single base class, but may implement multiple interfaces

12. Limitations of Interfaces
Interfaces cannot have data members
They cannot define constructors or destructors
Differences and similarities between an Interface and an abstract class
Differences
Interfaces cannot contain any implementation
Interfaces cannot declare non-public members
Interfaces cannot extend non-interfaces
Similarities
Neither can be instantiated

13. Syntax for declaring an Interface
interface InterfaceName {
refType methodName1 (param-list);
// … }
They are essentially abstract methods
Methods declared in an interface are implicitly public; no explicit access specifier is allowed

14. Syntax for implementing an Interface
class ClassName : InterfaceName {
// Class body }
When a class is implementing an interface it has to implement the entire interface
A class can implement more than one interface separated by a comma
A class can also inherit from a base class in combination with an interface; the name of the base class will be listed first

15. Simple Interface example
using System;
class Demo : Iabc {
public static void Main (string[] args)
Console.WriteLine (“Hello Interfaces”);
Demo refDemo = new Demo ();
refDemo.xyz (); }
public void xyz ()
Console.WriteLine (“In Demo :: xyz”);
interface Iabc
void xyz ();
Result:
> Hello Interfaces
> In Demo :: xyz

16. foreach Simplified for loop syntax
int[] myInts = new int[] { 1, 2, 3, 4, 5 };
foreach (int i in myInts) {
Console.WriteLine(i); }
Works with built-in arrays, collection classes and any class implementing IEnumerable interface

17. readonly For values that can only be assigned during construction
class Thing {
private readonly string name;
private readonly int age = 42; // OK;
public Thing ()
name = “Brutus”; // Also OK }
public void SomeMethod ()
name = “Buckeye”; // Error

18. readonly & const C# also has the const keyword
As in C++, used for constant values known at compile time
Not identical to C++ const though
Not used for method parameters
Not used for method signatures

19. Parameter modifiers: ref
No (explicit) pointers or references in C#
In effect, all parameters are passed by reference
But not quite
static void Main (string[] args) {
String message = “Brutus”;
MakeBuckeye(message);
Console.WriteLine(message); }
static void MakeBuckeye (string s)
s += “Buckeye”;
Result:
> Brutus

20. Parameter modifiers: ref
Although parameter passing is efficient as “by reference”, effect is more like “by const reference”
The ref keyword fixes this
static void Main (string[] args) {
String message = “Brutus”;
MakeBuckeye(ref message);
Console.WriteLine(message); }
static void MakeBuckeye (ref string s)
s += “ Buckeye”;
Result:
> Brutus Buckeye

21. Parameter modifiers: out
Like ref but must be assigned in the method
static void Main (string[] args) {
DateTime now;
if (isAfternoon(out now))
Console.WriteLine(“Good afternoon, it is now “ + now.TimeOfDay.ToString ()); }
else
Console.WriteLine(“Please come back this afternoon.”);
static bool isAfternoon (out DateTime currentTime)
currentTime = DateTime.Now;
return currentTime.Hour >= 12;

22. Delegates
Delegates are how C# defines a dynamic interface between two methods
Same goal as function pointers in C
Delegates are type-safe
Consists of two parts: a delegate type and a delegate instance

23. Delegates
A delegate type looks like an (abstract) method declaration, preceded with the delegate keyword
A delegate instance creates an instance of this type, supplying it with the name of a real method to attach to

24. Delegates Result: > 10
// Delegate type (looks like an abstract method)
delegate int Transform(int number);
static int DoubleIt (int number) {
return number * 2; }
static void Main (string[] args)
// Create a delegate instance
Transform transform;
// Attach it to a real method
Transform = DoubleIt;
// And now call it (via the delegate)
int result = transform(5)
Console.WriteLine(result.ToString());
Result:
> 10

25. Multicast delegates
A delegate instance can have more than one real method attached to it
Transform transform;
Transform += DoubleIt;
Transform += HalveIt;
// etc.
Now when we call transform(), all methods are called
Called in the order in which they were added

26. Multicast delegates
Methods can also be removed from a multicast delegate
Transform -= DoubleIt;

27. Events Events are just a special, restricted form of delegate
Core part of C# UI event handling
Controls have standard set of events you can attach handlers to
myButton.Click += OnButtonClicked;

28. Advanced C# and .NET Generics Assemblies
Look and behave pretty much like C++ templates
Assemblies
Basic unit of deployment in .NET
Typically a single .EXE or .DLL
Extra access modifier internal (in addition to public, protected, private) gives access to other classes within the same assembly

29. ?

30. References Whitaker, Mark. “C# for C++ Programmers”
MSDN. “C for C++ Developers”
Ikram, Aisha. “Quick C#”