Introduction to C#

Why C#?

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

How Windows and Windows Phone Applications are developed?

Tools Needed

Where to start?

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

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++

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

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

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 ); }

Properties Demo

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

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++; }

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; }

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; }

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; } }

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!

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 ); }

Interfaces Demo

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 ); }

Foreach Demo

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

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"; }

Parameter Modifier: ref Demo

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; }

Parameter Modifier: out Demo

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

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

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…

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.

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

Delegates Demo

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;

Events Demo

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" ); }

Questions?

References Microsoft Virtual Academy

Thank You