2. overview of c#

Microsoft .Net
(Introduction to C#)
Rohit Rao

Agenda
• Overview of C#
• Control Structures
• Arrays
• Generics
• Namespace

Overview of C#
• Object Oriented Programming Language
• Derived from C, C++ & Java

Control Structure
• Types
– Decision (Conditional) : Use to control the flow of program. Code runs
only once if certain condition is true.
– Iteration
• Decision
– If, if-else, If-else if
– Switch
• Iteration
– For Loop
– ForEach Loop
– While
– Do While

Decision Statements
• If statements
– If : Code runs once only if condition is true.
– If-Else : It allow us to specify the code that should
run if first statement (If) evaluates to false
– If-Else If-Else : It allow us to select from multiple if
statements.
– The ? : Operator :
• Exp1 ? Exp2 : Exp3

Switch
• It allow us to select from pre-defined set of
choices
• After each choice statement, we will have to use
break keyword
switch (i)
{
case 1:
Console.WriteLine(1);
break;
case 2:
break;
case 3:
break;
default:
Console.WriteLine("Please enter a number between 1 & 3.");
break;
}

Iterations
• It repeats the code in cyclic fashion
• For Loop
– It allow us to repeat the block of code N times
– We can use any decision statement in it
– We can use Continue / Break
int sum = 0;
for (int i = 0; i < 5; i++)
{
sum += i;
}
Console.WriteLine(sum);

For Each Loop
• Used to loop through items in a collection or
array individually (With no indexes)
• The collection or array must use interface
IEnumerable / IEnumerable <T>
• We can not add / remove from the collection
within the loop body
string[] students = { "A", "B", "C" };
foreach (string studentName in students)
{
Console.WriteLine(studentName);
}

While Loop
• Repeat the block of code while a certain
condition remains true.
int sum = 0;i = 0;
while (i < 5)
{
sum += i;
i++;
}

Do-While Loop
• It tests the condition at the end of the loop Body
• Loop is guaranteed to execute at least once time.
int sum = 0;i = 0;
do
{
sum += i;
i++;
} while (i < 5);

Continue Keyword
• Allow us to immediately move to next
iteration of a loop body
• It starts the next iteration immediately and
skip the steps below the Continue statement
in loop’s body.

Break Keyword
• It is used to move out from the iteration and it
does not loop any more.
• It skips the code below Break statement.

Array
• string[] arrOfStr = new string[] { "A", "B", "C" };
• string[] arrOfStr = new string[3];
arrOfStr[0] = "A";
arrOfStr[1] = "B";
arrOfStr[2] = "C";
• Passing Array To Method
//Method
public void ReadArray(int[] arr)
{ }
//Call
int[] arrOfInt = { 1, 2, 3 };
ReadArray(arrOfInt);

2D Array
string[,] arr2D= new string[,]
{
{"A", "1"},
{"B", "2"},
{"C", "3"},
{"D", "4"},
};
//Print
Console.WriteLine(arr2D[0, 0]);
int arr2D = new int[3, 3];
---------------------------------------------------------------------------------
Passing 2D array to method :
public void Pass2DArray(int[,] arr2d)
{
// Display value of first element in first row.
Console.WriteLine(arr2d[0, 0]);
}

Generics
• Arrays are strong typed
– No boxing / Unboxing (Adv)
– Fixed Length (DisAdv)
• Array List
– Variable / Flexible length (Adv)
– Lot of Boxing / UnBoxing because they take
objects (DisAdv)
• Generics provides advantages of both of these
collection : Strong Type & Flexible
• It creates Flexible Strong Typed Collection

Generics
• It separates the logic from Data Type, to
increase reusability
String
Boolean
Numeric
Generic compare logic (separate from data
type) for all the data types
-> Is “A” == “B” ?
-> Is bTrue == bFlase ?
-> Is 5 == 5 ?
At runtime attach the data type to the
method.

Generic Method Example
//Generic Method
public static bool Compare<T>(T x, T y)
{
if (x.Equals(y))
return true;
return false;
}
• //Method Call
bool result = Compare(10, 12);
Console.WriteLine(result.ToString());
result = Compare("A", "B");
result = Compare(true, true);
Console.ReadLine();

Generic Class Example
public class GenericCompare<T>
{
public bool Comapre(T x, T y)
{
if (x.Equals(y))
return true;
return false;
}
}
//Method call for integers
GenericCompare<int> objGenericCompInt = new GenericCompare<int>();
result = objGenericCompInt.Comapre(10, 12);
//Method Call for string
GenericCompare<String> objGenericCompString = new GenericCompare<String>();
result = objGenericCompString.Comapre("A", "B");

Generic Collections
• Generic decoupled datatype from Logic
• In .NET, Microsoft team took .NET collections & applied
generic concepts & created Generic Collections
• We will need to import System.Collections.Generic
Array List - > List (Generic) ---- Index Based
Hash Table - > Dictionary --- Key Value Pair
Stack & Queue - > Stack Generics & Queue Generics ---- Prioritized

Generic Collection (Index Based)
• List of Int
• List Of String
List<String> lstStr = new List<string>();
lstStr.Add("A");
lstStr.Add("B");
lstStr.Remove("A");

Generic Collections (Key Based)
• Dictionary : Generic form of HashTables
Dictionary<int, int> dictInt = new Dictionary<int, int>();
dictInt.Add(1, 1);
dictInt.Add(2, 2);
Dictionary<int, string> dictString = new Dictionary<int, string>();
dictString.Add(1, "A");
dictString.Add(2, "B");

Generic Collection (Stack / Queue)
• Stack
Stack<int> stkInt = new Stack<int>();
stkInt.Push(1);
stkInt.Push(2);
stkInt.Pop();
• Queue
Queue<string> QString = new Queue<string>();
QString.Enqueue("A");
QString.Enqueue("B");
QString.Dequeue();
QString.Dequeue();

Generic Collection (Custom Objects)
• We can attach custom objects to Generic
collections :
Student objStudent = new Student();
objStudent.StudentID = 1;
objStudent.RollNo = 1;
objStudent.StudentName = "A";
List<Student> lstStudent = new List<Student>();
lstStudent.Add(objStudent);

IEnumerable, ICollection, IList, IDictionary
• Interfaces : These all are interfaces, It provides
decoupling.
• Encapsulation : We can control how much
collection access should give to end clients.
• Polymorphism : We can dynamically point to
different collection on runtime.

IEnumerator ICollection
IList or
IDictionary
Only Browse Browse + Count Browse + Count + Add +
Remove elements

static void Main(string[] args)
{
//Fetch Students info
Student objStudent = new Student();
ArrayList arrLstStudents = objStudent.GetStudents();
//Here user can modify the arrLstStudents objects but it may be for browse only
purpose
/*
arrLstStudents.Remove(Object obj);
arrLstStudents.Add(Object obj);
*/
//It would be good if we can give him IEnumerable object instead of ArrayList.
So client will not be able to ad / remove items
IEnumerable studentList = objStudent.GetStudentsIEnumerable();
}

public class Student
{
//Method to get array List
public ArrayList GetStudents()
{
ArrayList arrLstStudents = new ArrayList();
//Logic to fetch Student info & Add in ArrayList object
return arrLstStudents;
}
//Method to get IEnumerable
public IEnumerable GetStudentsIEnumerable()
{
ArrayList arrLstStudents = new ArrayList();
//Logic to fetch Student info & Add in ArrayList object
return CovertToIEnumerable(arrLstStudents);
}
public IEnumerable CovertToIEnumerable(ArrayList arrList)
{
return (IEnumerable) arrList;
}
}

NameSpace
• It helps you to organize your program / code.
• It Provides a way to create globally unique
types.
• It helps in avoiding class name clashes in more
than one set of code.
• The compiler adds a default namespace.

2. overview of c#

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to 2. overview of c# (20)

Recently uploaded (20)

2. overview of c#