Session 9_TP 5

Session 5

Advanced C# Concepts - I

C# Simplified / Session 5 / 2 of 45

Review Apart from avoiding naming conflicts, namespaces are also

elements designed to help organize the code. Namespaces can be nested. Namespaces are implicitly public.

A fully qualified name is the name of the class prefixed by the namespace within which it is contained and the dot operator.

With ‘using namespace directives’, we can employ classes outside their namespaces without using their qualified names. The using namespace directives must be declared before any member declarations.

‘using alias directives’ can be deployed to pull out and bring into scope one component (a class or a struct) from a namespace.

The Base Class Library is a collection of pre-written code that can be incorporated easily and used in our applications.


Review Contd… The System.String class provides methods for

manipulating strings.

The System.Array class provides methods for manipulating arrays.

We can use the System.Threading namespace to implement multi-threading into our programs.

The System.IO namespace provides plenty of classes for file/stream input/output.


Objectives

Discuss and create Assemblies Explain Private and Shared

Assemblies Discuss Versioning Discuss Reflections Discuss Collections Explain Error Handling


Assemblies

The sharing is taken care of automatically using certain commands.

An assembly is a means of reusing code without using any complex syntax


Assemblies – Contd… An assembly consists of two main

elements A set of types and resources that form a

logical unit of functionality A manifest that contains information, which

describes the assembly Set of Types andResources

Manifest

An Assembly


Manifest A manifest is the metadata that

describes how elements in an assembly are related

Contains information about the other assemblies on which they depend for proper functioning

Contains identity of an assembly Contains details of all the types and

resources defined in the assembly


Creating Assemblies To create an assembly use the

following command-

The following command creates an assembly called “array.dll”

C:\> csc /out:<assembly name>/target:library <filename1 filename2..>

C:\> csc /out: array.dll /target:library array1.cs>


After an assembly is created, it can be referenced from an executable.

To create an executable from a .cs file use the following command

Creating Executables

The following command creates a .exe file from a .cs file

C:\>csc /out<executable name> /targetexe <filename1 filename2.cs>

C:\>csc /out trial.exe /targetexe trial1.cs


The following command is used to reference an assembly

Referencing an Assembly

The following command creates an executable called trial.exe from the source file trial1.cs while referencing an assembly called newtrial.dll

C:\>csc /out<executable name> /target.exe /r<assembly name1;assembly name2..><filename1 filename2..>

C:\>csc /out trial.exe /target.exe /r newtrial.dll trial1.cs


Namespaces vs. Assembly Difference between Namespace &

Assembly -


Types of Assemblies - Private Assemblies can be of two types: private

and shared

By default, a C# program is compiled to a private assembly

Needs to be placed in the same folder as the application

Assembly name should be unique within the application


Types of Assemblies - Shared

Can be shared across various applications

Assembly name should be unique across all applications using the assembly

Placed in the Global Assembly Cache


Global Assembly Folder


Global Assembly Folder There are two ways by which an

assembly can be installed into the global assembly cache Using Microsoft Windows Installer 2.0.

Using the Global Assembly Cache tool (Gacutil.exe)


Access Modifiers Access modifiers define the level of

access that certain blocks of code have, to class members like its methods and properties

C# introduces a new access modifier known as the internal access modifier

The internal modifier can be used to specify accessibility at the assembly level instead of the class level


Internal access modifier


Versioning

All assemblies must have a version number

Assemblies having the same name but different version numbers can coexist in the same application.


Versioning

The version number of an assembly is represented as a four-part number in the following format


Solving “DLL Hell” Problem In the previous versions of Microsoft Windows operating

systems, two DLL files with the same name could not be used in a single process

DLL file needed to be upgraded and the registry entry for it had to be modified

However, other applications using the older DLL file may still be searching for that DLL file

This is because the registry entries of those applications may not have been updated with the new DLL file.

This situation is known as “DLL Hell”. The Windows 2000 operating system is capable of

loading two assemblies with the same name but different version numbers.

Therefore, it is possible to have a new version of that file, while still using the same name for the newer version


Reflection (1) Used to retrieve information about

an object at runtime The Type class is the base of all

reflection information for an object Two methods to retrieve the Type

object – typeof() GetType()


Reflection - Exampleusing System;namespace RefDemo{public class ReflectionDemo{ public int addition(int first, int second) { return first+second; }

public static int Main(){ Type refType= typeof(ReflectionDemo); //Class Reference ReflectionDemo objRef =new ReflectionDemo(); Type objType = objRef.GetType(); // Object Reference


Reflection - OutputConsole.WriteLine ("The type of objRef is : {0} ", objType);Console.WriteLine ("The type of ReflectionDemo is : {0}", refType);Console.WriteLine ("The Namespace of ReflectionDemo is : {0} ", refType.Namespace);return 0;}}}


Reflection – Methods of Type


Reflection – GetMembersnamespace Reflection_Example{ using System; using System.Reflection; public class RefExample { private int intSum; public void addition(int intA, int intB) { intSum= intA + intB; } public static int Main() { Type refType= typeof(RefExample); MemberInfo[] memInfoArray = refType.GetMembers();


Reflection – GetMembers Output

foreach (MemberInfo memInfo in memInfoArray) { Console.WriteLine (memInfo); } return 0; } }}


Collections Collections are general-purpose

datatypes, that provide us with a store, and act upon them collectively

Hashtable class allows us to store data as a collection of keys and value pairs, which are organized depending on the hash code of the key


Collections - Example

using System.Collections;class HashDemo{ static void Main() { Hashtable listOfStudents = new Hashtable(); listOfStudents.Add ("Sam", "8605130"); listOfStudents.Add("Smith", "8604292"); listOfStudents.Add("Tom", "8604292"); System.Console.WriteLine ("The number of students in the school are {0} ", listOfStudents.Count); }}


ArrayList Class ArrayList is actually a refined version of

an array that offers some features that are offered in most Collections classes but are not in the Array class

The capacity or the number of elements of an Array is fixed; on the other hand the capacity of an ArrayList can be expanded dynamically as per the requirement

A range of elements can be inserted or removed at one point of time with the help of methods provided by ArrayList


Arraylist Class – Contd…

Property DescriptionCapacity Used to specify the number of

elements in as ArrayList

Count Indicates the number of elements actually present in an ArrayList

IsReadOnly Used to specify whether an ArrayList is read-only

IsFixedSize Used to specify whether an ArrayList has a fixed size

Item Used to specify an element at a specific index position in the ArrayList

Properties of ArrayList class are as follows


Arraylist Class – ContdPublic methods of ArrayList class are as follows

Method Description

Add Used to add an element at the end of an ArrayList

Clear Removes all the elements from the specified ArrayList

Contains Checks whether the given element is present in the ArrayList

CopyTo Used to copy the entire contents of an ArrayList or a part of it to single-dimensional Array

IndexOf Specifies the positional index of the first occurrence of the given element in the ArrayList. It is important to note here that the positional index is zero-based.

LastIndexOf Specifies the positional index of the last occurrence of the given element in the ArrayList.


ArrayList Class - Exampleusing System;using System.Collections;public class ArrlistDemo{public static void Main() { ArrayList myArrLst = new ArrayList(); Console.WriteLine ("Enter names of 5 countries below:"); for(int i = 0;i <= 4;i++) { Console.Write ("Enter country {0} :", i+1); string str1 = Console.ReadLine(); myArrLst.Add(str1); } Console.WriteLine( "Information about Countries" );


ArrayList Class - Example Console.WriteLine( "\tCount:{0}", myArrLst.Count );Console.WriteLine( "\tCapacity: {0}", myArrLst.Capacity );Console.WriteLine ("The contents of the arraylist are as follows");System.Collections.IEnumerator myEnumerator = myArrLst.GetEnumerator();while ( myEnumerator.MoveNext() ) Console.Write( "\n{0}", myEnumerator.Current ); Console.ReadLine();}}


Exceptions A program will crash rarely if it has

been programmed to recover from situations that may result in an error

Exceptions are used to anticipate and trap errors that may result in crashing a program


Exceptions – Contd…

System.Exception

System.SystemException System.ApplicationException

ArithmeticException

Data.DataException

ArgumentException

FormatException

IO.IOException

………..

Reflection.TargetException

Reflection.InvalidCriteriaException

………..

DivideByZeroException

OverflowException

IO.EndOFStreamException

FileLoadException

………..

The .NET framework provides us with a large range of exception classes that store information regarding exceptions


Try & catch blocks

Helps in handling raised exceptions


More on catch blocks

C# allows the usage of more than one catch block


General catch blockGeneral catch block is the one that can trap just about any type of exception

one try can have only one general catch block


Using throw

The throw statement allows you to raise custom exceptions


Using Finally

The code in this block is executed irrespective of whether an exception was raised or not


try…..catch - Example

using System;class ExceptionDemo{ static void Main() { int dividend = 50; int userInput = 0; int quotient = 0; Console.WriteLine ("Enter a number : "); try { userInput = Convert.ToInt32 (Console.ReadLine()); quotient = divident /userInput; }


try….catch - Example

catch (System.FormatException excepE) { Console.WriteLine (excepE); } catch (System.DivideByZeroException excepE) { Console.WriteLine ("catch block"); Console.WriteLine (excepE); Console.WriteLine(""); }


try….catch – Example Output

finally{ Console.WriteLine ("finally block"); if (quotient != 0) { Console.WriteLine("The Integer Quotient of 50 divided by {0} is {1}", userInput, quotient); }}}}


Summary An assembly consists of:

A set of types and resources that form a logical unit of functionality.

A manifest containing information that describes the assembly.

We can deploy classes within the same namespace into different assemblies, and classes within different namespaces into one assembly.

Assemblies are of two types: Private Assemblies and Shared Assemblies

The version number of an assembly is represented as a four-part number in the following format: <Major version>.< Minor version >.<Revision>.<Build Number>


Summary Contd… The System.Reflection namespace contains around forty

classes and interfaces that can be employed to get information about an object.

Collections are datatypes that provide us with a way to store and collectively act upon data.

Exceptions are raised by the runtime when an error occurs. The try and catch block helps in handling raised

exceptions. Using the Throw statement, we can either throw a system

exception, or our own custom exception. The statements in the Finally block are executed

regardless of the control flow.

Documents

Session 9_TP 5