1. Introduction to C#

2. Why C#?

3. Develop on the Following Platforms ASP.NET Native Windows Windows 8 / 8.1 Windows Phone WPF Android (Xamarin) iOS (Xamarin)

4. How Windows and Windows Phone Applications are developed?

5. Tools Needed

6. Where to start?

7. The Basics of C# 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

8. The Basics of C# Everything lives in a class/struct (no globals) No pointers! (so no ->, * or & notation) Garbage collection: no delete! No header files Interfaces Static members accessed with. (not ::) In a nutshell: much easier than C++

9. C# Features Properties Interfaces The foreach keyword The readonly keyword Parameter modifiers: ref and out Delegates and events Generics (Instead of Templates)

10. 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

11. Properties class Person { // Private field (the "backing 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 ) { Person p = new Person(); // Use the setter p.Name = "Waseem"; // Use the getter Console.WriteLine( p.Name ); }

12. Properties Demo

13. Properties So far, looks like an over-complicated field So why bother?

14. Properties : Advanced Getter / Setter Can hide implementation detail inside property Hence “looks like a field, behaves like a method” class Person { // Private field (the "backing field") private String name; private static int refCount = 0; // Public property public String Name { get { return name.ToUpper(); } set { name = value; refCount++; }

15. Properties : Access Modifiers Now only the class itself can modify the value Any object can get the value class Person { // Private field (the "backing field") private String name; // Public property public String Name { get { return name; } private set { name = value; }

16. Properties : Getter only 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! class Thing { // Public property public int CurrentHour { get { return DateTime.Now.Hour; }

17. Properties : Even simpler example class Person { // If all you want is a simple // getter / setter pair, no need for a // backing field at all public String Name { get; set; } // As you might have guessed, access // modifiers can be used public bool IsWorking { get; private set; } }

18. Properties A really core feature of C# You’ll see them everywhere DateTime.Now String.Length Etc. Get into the habit of using a property whenever you need a getter and/or setter Preferred to using GetValue(), SetValue() methods Never use public fields!

19. Interfaces Like a class, but all its members are implicitly abstract i.e., it does not provide any method implementations, only method signatures A class can only inherit from a single base class, but may implement multiple interfaces interface ILog { void Log( string text ); }

20. Interfaces Demo

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

22. Foreach Demo

23. Parameter Modifiers: ref No (explicit) pointers or reference in C# In effect, all parameters are passed by reference But not quite… static void Main( string[] args ) { String message = "I'm Waseem"; Negate( message ); Console.WriteLine( message ); } static void Negate( String text ) { text += " NOT"; } Output

24. Parameter Modifiers: ref Although it looks like parameter passing is “by reference”, but it actually is “by const reference” The ref keyword fixes this Output static void Main( string[] args ) { String message = "I'm Waseem"; Negate( ref message ); Console.WriteLine( message ); } static void Negate( ref String text ) { text += " NOT"; }

25. Parameter Modifier: ref Demo

26. Parameter Modifier: 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; }

27. Parameter Modifier: out Demo

28. 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 2 parts: a delegate type and a delegate instance

29. 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 the real method to attach to Example on next slide

30. Delegates // Delegate type (looks like an abstract method) delegate int Transform( int number ); // The real method we're going to attach to the delegate 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 ); } I can never remember the syntax for either! Keep a handy reference book…

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

32. Multicast Delegates Methods can also be removed from a multicast delegate transform -= HalveIt;

33. Delegates Demo

34. Events Events are really just special instances of delegates By convention they have a specific declaration for the delegate: We declare an event like this We use an event just like a delegate except that only the += and -= can be used by classes delegate void GuestHandler( String name ); event GuestHandler EnterEvent;

35. Events Demo

36. using Statement Automatically disposes the object The object must implement IDisposable interface using ( TextWriter w = File.CreateText( "log.txt" ) ) { w.WriteLine( "This is line one" ); }

37. Questions?

38. References Microsoft Virtual Academy

39. Thank You