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

Propertiesclass Person{

// Private field (the "backing field")private String name;

// Public propertypublic String Name{

get{ return name;}

set{

// "value" is an automatic// variable inside the settername = value;

}}

}

class Program{

static void Main( string[] args ){

Person p = new Person();

// Use the setterp.Name = "Waseem";

// Use the getterConsole.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 propertypublic 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 valueclass Person{

// Private field (the "backing field")private String name;

// Public propertypublic 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 propertypublic 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 allpublic String Name { get; set; }

// As you might have guessed, access// modifiers can be usedpublic 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 interfacesinterface 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<char>

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

> I’m Waseem

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

> I’m Waseem NOT

Outputstatic 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 delegatestatic int DoubleIt( int number ){ return number * 2;}

static void Main( string[] args ){

// Create a delegate instanceTransform transform;// Attach it to a real methodtransform = 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