Part 1 - C# Tutorial - Introduction

In this session
1. We will learn the basic structure of a c# program. The program we used in this video is shown
below.

// Namespace Declaration
using System;

class Pragim
{
public static void Main()
{
// Write to console
Console.WriteLine ("Welcome to PRAGIM Technologies!");
}
}

2. Understand the purpose of using System declaration - The namespace declaration, using
System, indicates that you are using the System namespace. If you omit the using System,
declaration, then you have to use the fully qualified name of the Console class. A namespace is
used to organize your code and is collection of classes, interfaces, structs, enums and
delegates. We will discuss about namespaces in detail in a later session.

3. Purpose of Main() method - Main method is the entry point into your application.

Part 2 - C# Tutorial - Reading and writing to a console

In this video, we will discuss
1. Reading from the console
2. Writing to the console
3. Two ways to write to console
a) Concatenation
b) Place holder syntax – Most preferred
Code samples used in the demo
using System;
class Program
{
static void Main()
{
// Prompt the user for his name
Console.WriteLine("Please enter your name");
 // Read the name from console
string UserName = Console.ReadLine();
// Concatenate name with hello word and print
Console.WriteLine("Hello " + UserName);

//Placeholder syntax to print name with hello word

//Console.WriteLine("Hello {0}", UserName);
}
}

Please note that C# is case sensitive language.

Part 3 - C# Tutorial - Built-in types

In this video, we will discuss the different built-in types that are available in c#.
Built-in types in C#
1. Boolean type – Only true or false
2. Integral Types - sbyte, byte, short, ushort, int, uint, long, ulong, char
3. Floating Types – float and double
4. Decimal Types
5. String Type
Escape Sequences in C#
http://msdn.microsoft.com/en-us/library/h21280bw.aspx

Verbatim Literal is a string with an @ symbol prefix, as in @“Hello".

Verbatim literals make escape sequences translate as normal printable characters to enhance
readability.

Practical Example:
Without Verbatim Literal : “C:\\Pragim\\DotNet\\Training\\Csharp” – Less Readable
With Verbatim Literal : @“C:\Pragim\DotNet\Training\Csharp” – Better Readable

Part 4 - C# Tutorial - String type

Verbatim Literal is a string with an @ symbol prefix, as in @“Hello”. Verbatim literals make
escape sequences translate as normal printable characters to enhance readability.
Practical Example:
Without Verbatim Literal : "C:\\Pragim\\DotNet\\Training\\Csharp"; // Less Readable
With Verbatim Literal : @"C:\Pragim\DotNet\Training\Csharp"; // Better Readable

C# example program used in the demo

using System;
namespace ConsoleApplication1
{
class Program
{
public static void Main()
{
// Displaying double quotes in c#
string Name = "\"Pragim\"";
Console.WriteLine(Name);

// Displaying new line character in c#

Name = "One\nTwo\nThree";
Console.WriteLine(Name);

// Displaying new line character in c#

Name = "c:\\Pragim\\DotNet\\Training\\Csharp";
Console.WriteLine(Name);

// C# verbatim literal
Name = @"c:\Pragim\DotNet\Training\Csharp";
Console.WriteLine(Name);
}
}
}

Part 5 - C# Tutorial - Common Operators

In this video, we will discuss the common operators that are available in c# programming
language.
Assignment Operator =
Arithmetic Operators like +,-,*,/,%
Comparison Operators like ==, !=,>, >=, <, <=
Conditional Operators like &&, ||
Ternary Operator ?:
Null Coalescing Operator ??
Examples used in the demo
using System;
namespace ConsoleApplication1
{
class Program
{
public static void Main()
{
// Assignment Operator example
// Single = is the assignment operator
 int i = 10;
bool b = true;

// For dividing 2 numbers we can use either

// % or / operators
int numerator = 10;
int denominator = 2;

// Arithmentic operator / returns quotient

int quotient = numerator / denominator;
Console.WriteLine("Quotient = {0}", quotient);

// Arithmentic operator % returns remainder

int remainder = numerator % denominator;
Console.WriteLine("Remainder = {0}", remainder);

// To compare if 2 numbers are

// equal use comparison operator ==
int number = 10;
if (number == 10)
{
Console.WriteLine("Number is equal to 10");
}

// To compare if 2 numbers are not

// equal use comparison operator !=
if (number != 5)
{
Console.WriteLine("Number is not equal to 5");
}

// When && operator is used all the conditions must

// be true for the code in the "if" block to be executed
int number1 = 10;
int number2 = 20;

if (number1 == 10 && number2 == 20)

{
Console.WriteLine("Both conditions are true");
}

// When || operator is used the code in the "if" block

// is excuted if any one of the condition is true
number1 = 10;
number2 = 21;

if (number1 == 10 || number2 == 20)

{
Console.WriteLine("Atleast one of the condition is true");
}
}
 }
}

The example below is not using the ternary operator. Look at the amount of code we have
to write to check if a number is equal to 10, and then initialise a boolean variable to true or false
depending on whether the number is equal to 10 or not.

using System;
namespace ConsoleApplication1
{
class Program
{
public static void Main()
{
int number = 10;

bool isNumber10;

if (number == 10)
{
isNumber10 = true;
}
else
{
isNumber10 = false;
}

Console.WriteLine("Number == 10 is {0}", isNumber10);

}
}

Ternary operator example : We have rewritten the above program using ternary operator.
Notice the amount of code we have to write is greatly reduced.

using System;
namespace ConsoleApplication1
{
class Program
{
public static void Main()
{
int number = 10;

// Ternary operator example

bool isNumber10 = number == 10 ? true : false;

Console.WriteLine("Number == 10 is {0}", isNumber10);

}
}
}

Part 6 - C# Tutorial - Nullable Types

In this video, we will discuss
1. Nullable types in C#
2. Null Coalescing Operator ??
In C# types are divided into 2 broad categories.
Value Types - int, float, double, structs, enums etc
Reference Types – Interface, Class, delegates, arrays etc
By default value types are non nullable. To make them nullable use ?
int i = 0 (i is non nullable, so "i" cannot be set to null, i = null will generate compiler error)
int? j = 0 (j is nullable int, so j=null is legal)

Nullable types bridge the differences between C# types and Database types

Program without using NULL coalescing operator

using System;
class Program
{
static void Main()
{
int AvailableTickets;
int? TicketsOnSale = null;

if (TicketsOnSale == null)
{
AvailableTickets = 0;
}
else
{
AvailableTickets = (int)TicketsOnSale;
}

Console.WriteLine("Available Tickets={0}", AvailableTickets);

}
}

The above program is re-written using NULL coalescing operator

using System;
class Program
{
static void Main()
{
 int AvailableTickets;
int? TicketsOnSale = null;

//Using null coalesce operator ??

AvailableTickets = TicketsOnSale ?? 0;

Console.WriteLine("Available Tickets={0}", AvailableTickets);

}
}

Part 7 - C# Tutorial - Datatype conversions

In this video, we will discuss
1. Implicit conversions
2. Explicit Conversions
3. Difference between Parse() and TryParse()
Implicit conversion is done by the compiler:
1. When there is no loss of information if the conversion is done
2. If there is no possibility of throwing exceptions during the conversion
Example: Converting an int to a float will not loose any data and no exception will be thrown,
hence an implicit conversion can be done.

Where as when converting a float to an int, we loose the fractional part and also a possibility of
overflow exception. Hence, in this case an explicit conversion is required. For explicit
conversion we can use cast operator or the convert class in c#.

Implicit Conversion Example

using System;
class Program
{
public static void Main()
{
int i = 100;

// float is bigger datatype than int. So, no loss of

// data and exceptions. Hence implicit conversion
float f = i;

Console.WriteLine(f);
}
}

Explicit Conversion Example

using System;
class Program
{
public static void Main()
{
float f = 100.25F;

// Cannot implicitly convert float to int.

// Fractional part will be lost. Float is a
// bigger datatype than int, so there is
// also a possiblity of overflow exception
// int i = f;

// Use explicit conversion using cast () operator

int i = (int)f;

// OR use Convert class

// int i = Convert.ToInt32(f);

Console.WriteLine(i);
}
}

Difference between Parse and TryParse

1. If the number is in a string format you have 2 options - Parse() and TryParse()
2. Parse() method throws an exception if it cannot parse the value, whereas TryParse() returns
a bool indicating whether it succeeded or failed.
3. Use Parse() if you are sure the value will be valid, otherwise use TryParse()

Part 8 - C# Tutorial - Arrays in C#

In this video, we will discuss
1. Arrays
2. Advantages and dis-advantages of arrays
An array is a collection of similar data types.

using System;
class Program
{
public static void Main()
{
// Initialize and assign values in different lines
int[] EvenNumbers = new int[3];
EvenNumbers[0] = 0;
EvenNumbers[1] = 2;
EvenNumbers[2] = 4;
 // Initialize and assign values in the same line
int[] OddNumbers = { 1, 3, 5};

Console.WriteLine("Printing EVEN Numbers");

// Retrieve and print even numbers from the array

for (int i = 0; i < EvenNumbers.Length; i++)
{
Console.WriteLine(EvenNumbers[i]);
}

Console.WriteLine("Printing ODD Numbers");

// Retrieve and print odd numbers from the array

for (int i = 0; i < OddNumbers.Length; i++)
{
Console.WriteLine(OddNumbers[i]);
}
}
}
Advantages: Arrays are strongly typed.

Disadvantages: Arrays cannot grow in size once initialized. Have to rely on integral indices to
store or retrieve items from the array.

Part 9 - C# Tutorial - Comments

In this video, we will discuss
1. Single line comments
2. Multi line comments
3. Introduction to XML documentation comments
Single line Comments - //
Multi line Comments - /* */
XML Documentation Comments - ///
Comments are used to document what the program does and what specific blocks or lines of
code do. C# compiler ignores comments.

To Comment and Uncomment, there are 2 ways

1. Use the designer
2. Keyboard Shortcut: Ctrl+K, Ctrl+C and Ctrl+K, Ctrl+U

Note: Don't try to comment every line of code. Use comments only for blocks or lines of code
that are difficult to understand
Part 10 - C# Tutorial - If statement

Part 11 - C# Tutorial - switch statement

Part 12 - C# Tutorial - Switch statement continued

Part 13 - C# Tutorial - While loop in c#

Part 14 - C# Tutorial - Do While loop in c#

Part 15 - C# Tutorial - for and foreach loops in c#

Part 16 - C# Tutorial - Methods in c#

Part 17 - C# Tutorial - Method parameters

Part 18 - C# Tutorial - Namespaces in C#

Part 19 - C# Tutorial - Introduction to classes

Part 20 - C# Tutorial - Static and instance class members

Part 21 - C# Tutorial - Inheritance in C#

Part 22 - C# Tutorial - Method hiding in C#

Part 23 - C# Tutorial – Polymorphism

Part 24 - C# Tutorial - Difference between method overriding and method
hiding

Part 25 - C# Tutorial - Method overloading

Part 26 - C# Tutorial - Why Properties

Part 27 - C# Tutorial - Properties in C#

Part 28 - C# Tutorial - Structs in C#
Part 29 - C# Tutorial - Difference between classes and structs in C#

Part 30 - C# Tutorial - Interfaces in C#

Part 31 - C# Tutorial - Explicit interface implementation

Part 32 - C# Tutorial - Abstract classes

Part 33 - C# Tutorial - Difference between abstract classes and

interfaces

Part 34 - C# Tutorial - Problems of multiple class inheritance

Part 35 - C# Tutorial - Multiple class inheritance using interfaces

Part 36 - C# Tutorial - Delegates

A delegate is a type safe function pointer.That is, they hold reference(Pointer) to a function.

The signature of the delegate must match the signature of the function, the delegate points to,
otherwise you get a compiler error. This is the reason delegates are called as type safe function
pointers.

A Delegate is similar to a class. You can create an instance of it, and when you do so, you pass
in the function name as a parameter to the delegate constructor, and it is to this function the
delegate will point to.

Tip to remember delegate syntax: Delegates syntax look very much similar to a method with a
delegate keyword.

Sample Delegate Program:

using System;

// Delegate Declaration.
public delegate void HelloFunctionDelegate(string Message);

class Pragim
{
 public static void Main()
{
// Create the instance of the delegate and pass in the function
// name as the parameter to the constructor. The passed in
// function signature must match the signature of the delegate
HelloFunctionDelegate del = new HelloFunctionDelegate(Hello);
// Invoke the delegate, which will invoke the method
del("Hello from Delegte");
}

public static void Hello(string strMessge)

{
Console.WriteLine(strMessge);
}
}

Part 37 - C# Tutorial - Delegates Example – I

Part 38 - C# Tutorial - Delegates Example – II

Part 39 - C# Tutorial - Multicast Delegates

A Multicast delegate is a delegate that has references to more than one function. When
you invoke a multicast delegate, all the functions the delegate is pointing to, are invoked.

There are 2 approaches to create a multicast delegate.

Approach 1:
using System;
namespace Sample
{
public delegate void SampleDelegate();

public class Sample

{
static void Main()
{
SampleDelegate del1 = new SampleDelegate(SampleMethodOne);
SampleDelegate del2 = new SampleDelegate(SampleMethodTwo);
SampleDelegate del3 = new SampleDelegate(SampleMethodThree);
// In this example del4 is a multicast delegate. You use +(plus)
// operator to chain delegates together and -(minus) operator to remove.
SampleDelegate del4 = del1 + del2 + del3 - del2;
 del4();
}

public static void SampleMethodOne()

{
Console.WriteLine("SampleMethodOne Invoked");
}

public static void SampleMethodTwo()

{
Console.WriteLine("SampleMethodTwo Invoked");
}

public static void SampleMethodThree()

{
Console.WriteLine("SampleMethodThree Invoked");
}
}
}

Approach 2:
using System;
namespace Sample
{
public delegate void SampleDelegate();

public class Sample

{
static void Main()
{
// In this example del is a multicast delegate. You use += operator
// to chain delegates together and -= operator to remove.
SampleDelegate del = new SampleDelegate(SampleMethodOne);
del += SampleMethodTwo;
del += SampleMethodThree;
del -= SampleMethodTwo;

del();
}

public static void SampleMethodOne()

 {
Console.WriteLine("SampleMethodOne Invoked");
}

public static void SampleMethodTwo()

{
Console.WriteLine("SampleMethodTwo Invoked");
}

public static void SampleMethodThree()

{
Console.WriteLine("SampleMethodThree Invoked");
}
}
}

Note: A multicast delegate, invokes the methods in the invocation list, in the same order in
which they are added.

If the delegate has a return type other than void and if the delegate is a multicast
delegate, only the value of the last invoked method will be returned. Along the same
lines, if the delegate has an out parameter, the value of the output parameter, will be the
value assigned by the last method.

Example: Multicast delegate with an int return type

using System;
namespace Sample
{
// Deletegate's return type is int
public delegate int SampleDelegate();

public class Sample

{
static void Main()
{
SampleDelegate del = new SampleDelegate(SampleMethodOne);
del += SampleMethodTwo;

// The ValueReturnedByDelegate will be 2, returned by the SampleMethodTwo(),

// as it is the last method in the invocation list.
int ValueReturnedByDelegate = del();
 Console.WriteLine("Returned Value = {0}", ValueReturnedByDelegate);
}

// This method returns one

public static int SampleMethodOne()
{
return 1;
}

// This method returns two

public static int SampleMethodTwo()
{
return 2;
}
}
}

Example: Multicast delegate with an integer output parameter.

using System;
namespace Sample
{
// Deletegate has an int output parameter
public delegate void SampleDelegate(out int Integer);

public class Sample

{
static void Main()
{
SampleDelegate del = new SampleDelegate(SampleMethodOne);
del += SampleMethodTwo;

// The ValueFromOutPutParameter will be 2, initialized by SampleMethodTwo(),

// as it is the last method in the invocation list.
int ValueFromOutPutParameter = -1;
del(out ValueFromOutPutParameter);

Console.WriteLine("Returned Value = {0}", ValueFromOutPutParameter);

}
 // This method sets ouput parameter Number to 1
public static void SampleMethodOne(out int Number)
{
Number = 1;
}

// This method sets ouput parameter Number to 2

public static void SampleMethodTwo(out int Number)
{
Number = 2;
}
}
}

Where do you use multicast delegates? This is a very common interview question.
Answer: Multicast delegate makes implementation of observer design pattern very simple.
Observer pattern is also called as publish/subscribe pattern.

Part 40 - C# Tutorial - Exception Handling

What is an exception?
An exception is an unforeseen error that occurs when a program is running.

Examples:
Trying to read from a file that does not exist, throws FileNotFoundException.
Trying to read from a database table that does not exist, throws a SqlException.

Program without exception handling

using System;
using System.IO;
class ExceptionHandling
{
public static void Main()
{
//This line will throw FileNotFoundException
StreamReader streamReader = new StreamReader("C:\\NonExistingFile.txt");
Console.WriteLine(streamReader.ReadToEnd());
//Closes the underlying stream and releases the system resources.
//If there is an exception before this line, the below line will never
//be executed and the resources are not relased
streamReader.Close();
 }
}

Showing actual unhandled exceptions to the end user is bad for two reasons
1. Users will be annoyed as they are cryptic and does not make much sense to the end users.
2. Exceptions contain information, that can be used for hacking into your application

using System;
using System.IO;
class ExceptionHandling
{
public static void Main()
{
StreamReader streamReader = null;
try
{
// This line will throw FileNotFoundException
streamReader = new StreamReader("C:\\NonExistingFile.txt");
Console.WriteLine(streamReader.ReadToEnd());
}
// This catch block handles only FileNotFoundException
catch (FileNotFoundException fileNotFoundException)
{
// Log or email the exception
// Code to log or email exception details

// Display meaningful error message to the end user

Console.WriteLine("Please check if the file \"{0}\" is present",
fileNotFoundException.FileName);
}
// This catch block handles all the other exceptions
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
finally
{
if (streamReader != null)
{
streamReader.Close();
}
}
}
}
An exception is actually a class that derives from System.Exception class. The
System.Exception class has several useful properties, that provide valuable information
about the exception.
Message: Gets a message that describes the current exception
Stack Trace: Provides the call stack to the line number in the method where the exception
occurred.

We use try, catch and finally blocks for exception handling.

try - The code that can possibly cause an exception will be in the try block.
catch - Handles the exception.
finally - Clean and free resources that the class was holding onto during the program execution.

Specific exceptions will be caught before the base general exception, so specific exception
blocks should always be on top of the base exception block. Otherwise, you will encounter a
compiler error.

Note: It is a good practice to always release resources in the finally block, because finally block
is guarenteed to execute, irrespective of whether there is an exception or not.

Bad way of cleaning resources.

using System;
using System.IO;
class ExceptionHandling
{
public static void Main()
{
StreamReader streamReader = null;
try
{
streamReader = new StreamReader("C:\\NonExistingFile.txt");
Console.WriteLine(streamReader.ReadToEnd());
}
catch (Exception)
{
throw new Exception("Intentional Exception");
}
//This code will never be executed, hence it is always a good
//practice to release resources in the finally block
streamReader.Close();
}
}
Part 41 - C# Tutorial - Inner Exceptions
The InnerException property returns the Exception instance that caused the current
exception.

To look at the inner exception, you have to make this program cuase an exception fail. To do
that you have 3 options
1. Enter a Character instead of a number (Causes Format Exception)
2. Or Enter a very big number that an interger cannot hold (Causes Over Flow Exception)
3. Or Enter Zero for Second Number (Causes Divide By Zero Exception)
using System;
using System.IO;
class ExceptionHandling
{
public static void Main()
{
try
{
try
{
Console.WriteLine("Enter First Number");
int FN = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("Enter Second Number");

int SN = Convert.ToInt32(Console.ReadLine());

int Result = FN / SN;

Console.WriteLine("Result = {0}", Result);
}
catch (Exception ex)
{
string filePath = @"C:\Sample Files\Log.txt";
if (File.Exists(filePath))
{
StreamWriter sw = new StreamWriter(filePath);
sw.Write(ex.GetType().Name + ex.Message + ex.StackTrace);
sw.Close();
Console.WriteLine("There is a problem! Plese try later");
}
else
{
//To retain the original exception pass it as a parameter
//to the constructor, of the current exception
throw new FileNotFoundException(filePath + " Does not Exist", ex);
}
 }
}
catch (Exception ex)
{
//ex.Message will give the current exception message
Console.WriteLine("Current or Outer Exception = " + ex.Message);

//Check if inner exception is not null before accessing Message property

//else, you may get Null Reference Excception
if(ex.InnerException != null)
{
Console.WriteLine("Inner Exception = ", ex.InnerException.Message);
}
}
}
}

Part 42 - C# Tutorial - Custom Exceptions

In this part we will learn
1. When to create custom exceptions
2. Creating a custom exception from the scratch
3. Throwing and catching the custom exception

To understand custom exceptions, you should have good understanding of

Part 21 - Inheritance
Part 40 - Exception Handling Basics
Part 41 - Inner Exceptions

When do you usually go for creating your own custom exceptions?

If none of the already existing dotnet exceptions adequately describes the problem.

Consider that
1. I have an asp.net web application.
2. The application should allow the user to have only one logged in session.
3. If the user is already logged in, and if he opens another browser window and tries to login
again, the application should throw an error stating he is already logged in another browser
window.

With in the .NET framework we donot have any exception, that adequately describes this
problem. So this scenario is one of the examples where you want to create a custom exception.
We know that an exception is a class. So to create a Custom exception,
1. Create a class that derives from System.Exception class. As a convention, end the
class name with Exception suffix. All .NET exceptions end with, exception suffix. If you
don't do so, you won't get a compiler error, but you will be deviating from the guidelines
for creating custom exceptions.
public class UserAlreadyLoggedInException : Exception
{
}

2. Provide a public constructor, that takes in a string parameter. This constructor simply
passes the string parameter, to the base exception class constructor.
public UserAlreadyLoggedInException(string message)
: base(message)
{
}

3. Using InnerExceptions, you can also track back the original exception. If you want to
provide this capability for your custom exception class, then overload the constructor as
shown below. If you are new to Constructor Overloading, please watch this video.
public UserAlreadyLoggedInException(string message, Exception innerException)
: base(message, innerException)
{
}

4. If you want your Exception class object to work across application domains, then the
object must be serializable. To make your exception class serializable mark it with
Serializable attribute and provide a constructor that invokes the base Exception class
constructor that takes in SerializationInfo and StreamingContext objects as parameters.
[Serializable]
public class UserAlreadyLoggedInException : Exception
{
public UserAlreadyLoggedInException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
}

Note: It is also possible to provide your own custom serialization, which will discuss in a later
session.
Complete Example of creating a custom exception:
using System;
using System.Runtime.Serialization;

public class CustomExceptions

{
public static void Main()
{
try
{
throw new UserAlreadyLoggedInException("User Already logged in");
}
catch (UserAlreadyLoggedInException ex)
{
Console.WriteLine(ex.Message);
}
}
}

[Serializable]
public class UserAlreadyLoggedInException : Exception
{
public UserAlreadyLoggedInException(string message)
: base(message)
{
}

public UserAlreadyLoggedInException(string message, Exception innerException)

: base(message, innerException)
{
}

public UserAlreadyLoggedInException(SerializationInfo info, StreamingContext context)

: base(info, context)
{
}
}

Part 43 - C# Tutorial - Exception Handling abuse

Exceptions are unforeseen errors that occur when a program is running. For example,
when an application is executing a query, the database connection is lost. Exception handling is
generally used to handle these scenarios.
But many a times I have seen programmers using exception handling to
implement programming logic which is bad, and this is called as exception handling
abuse.
Program using exception handling to implement logical flow:
using System;
public class ExceptionHandlingAbuse
{
public static void Main()
{
try
{
Console.WriteLine("Please enter Numerator");
int Numerator = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("Please enter Denominator");

//Convert.ToInt32() can throw FormatException, if the entered value
//cannot be converted to integer. So use int.TryParse() instead
int Denominator = Convert.ToInt32(Console.ReadLine());

int Result = Numerator / Denominator;

Console.WriteLine("Result = {0}", Result);

}
catch (FormatException)
{
Console.WriteLine("Only numbers are allowed!");
}
catch (OverflowException)
{
Console.WriteLine("Only numbers between {0} & {1} are allowed",
Int32.MinValue, Int32.MaxValue);

}
catch (DivideByZeroException)
{
Console.WriteLine("Denominator cannot be zero");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
 }
}