C Sharp Programming SLIDES 02 FP2005 Ver1.0

C Sharp Programming – Day 2
Day 2
• Interface
• Properties
• Indexers
• Collections
• Introduction to Preprocessor directive
• Compiler Switches
• Assemblies
– Private
– Public
– Versioning
Copyright © 2005, 2 ER/CORP/CRS/LA30FC/003

Infosys Technologies Ltd Version no: 2.0
Interface
Definition:
An interface is a collection of abstract methods that is used to define the

functionality of an application.
The methods of an interface are defined in the classes or structs that

implement the interface.

Interface
Uses of Interface:
• Interfaces can be used as a means to provide some inheritance features with

structures.
• Multiple interfaces can be implemented with a class, thus gaining functionality

one can’t obtain with an abstract class.

Interface
Syntax:
Interface_ Modifer interface Interface_ identifier : base_interface
E.g.:
public interface ITextBox : IControl {
………………. // interface body
}
The interface body contains the members of the interface. An interface

contains the members that are inherited from its base interfaces and its own
members.

Interface
• Members of an interface:
– Methods
– Properties
– Events
• An interface modifier cannot be specified for an interface member.
• All the interface members are public by default. This is because any class
or struct in the program can access the interface members.
• Interface members are defined in a class.
• An interface cannot contain constants, fields and operators. An interface

cannot contain constructors and destructors.

Implementing an interface in a class
interface IShape {
void Draw(); // interface method declaration
}
class Circle : IShape {

void Draw() { // interface method definition
……………………………………. // method definition
}
}
Interface
Interface

E.g.:
interface ICntrl {
void Draw(); // interface method declaration
}
interface ITxtBox : ICntrl {
void SetText( string text); // method declaration
}
class TxtBox : ITxtBox {
void ICntrl.Draw() { … } // method definition
void ITxtBox.SetText() { … } // method definition
}
If an inherited interface is implemented in a class, the class implicitly

implements the base interface members of the inherited interface.

Explicit Interface Implementation
• Explicit interface implementation is used to remove ambiguity
• Handles name collisions
• Explicit interface implementations can’t be declared with abstract , virtual,

override or new modifiers
• No access modifier

public interface IDelete {
void Delete(); // interface method declaration
}
public interface ITransact {

void Delete(); // interface method declaration
}
class TextBox : IDelete, ITransact {

void IDelete.Delete() { ... } // method definition
void ITransact.Delete() { ... } // method definition
}

Explicit interface member implementations take precedence over other
members of the class when determining the class member that will be
mapped as the implementation of an interface member.
interface IAdd {
void Add ( int a, int b);
}
class Calculate {
void IAdd.Add ( int a, int b) {
…………………… // method body
}
public void Add() {
…………………… // method body
}
}
Classes Versus Interfaces
• An interface is like a pure abstract class. An interface differs from a class in a

number of ways:
– An interface does not provide any implementation code. This will be done by the
classes that implement the interface. An interface is said to provide a specification or
guideline for what will be happening, but not the details.
– All the members of the interface are assumed to be public.
– Interfaces contain only methods, properties, events and indexers. They do not
contain data members, constructors, or destructors.
– They cannot contain any static members.

Which statement gives a compilation error in the code snippet listed below:
interface IAdd {
void Add ( int a, int b);
}
class Calculate{
public void IAdd.Add ( int a, int b) {
……………………. // method body
}
}

Spot the error in the code snippet listed below:
interface IAdd {
void Add ( int a, int b); // method declaration
}
class Calculate : IAdd {

void Add ( int a, float b) { // method definition
……………………. // method body
}
}

Properties
• C# provides a concept called properties to enable to create object oriented fields within
the classes.
• Properties use the keywords get and set to get the values from the variables and set the
values in the variables.
// property.cs – Using properties

//------------------------------------------------------------------
class point
{
int iPointx; // iPointx is private
int iPointy; // iPointy is private
public int iPointx1
{
get
{
return iPointx;
}

set
{
iPointx = value;
}
}
public int iPointy1
{
get
{
return iPointy;
}
set
{
iPointy = value;
}
}
}

Class MyApp
{
public static void Main()
{
point starting = new point();
point ending = new point();
starting.iPointx1 = 1;
starting.iPointy1 = 4;
ending.iPointx1 = 10;
ending.iPointy1 = 11;
System.Console.WriteLine(“Point 1: {0},{1})”,
starting.iPointx1, starting.iPointy1);
System.Console.WriteLine(“Point 2: {0},{1})”,
ending.iPointx1, ending.iPointy1);
}
}

Properties - Demo
Properties Properties
(Class1.cs) (Class2.cs)

Indexers
• Enables an object to be indexed in the same way as an array. The
signature of indexer is
– <modifier> <return type> this [argument list]
• The modifier can be private, public, protected or internal
• The ‘this’ is a special keyword in C# to indicate the object of the current
class
• The formal-argument-list specifies the parameters of the indexer.
• C# do not have the concept of static indexers
• A base class indexer is inherited to the derived class.
Indexer(Class1.cs) Indexer(Class2.cs) Indexer 1

Indexers & Properties
Indexer Properties
An indexer is identified by it’s But a property is identified by it’s name.

signature.
An indexer is always an instance

property can be static also.
member
An indexer is accessed through an

element access. But a property is through a member access

Pre-processing directives
These directives are called preprocessor directives because before compiling the code, the
compiler preprocesses the listing and evaluates any preprocessor directives.
Directive Description
#define, #undef Defines and undefines conditional symbols
Indexer(Class1.cs)
#if, #elif, #else, #endif Conditionally skip sections of code
#error, #warning Issue errors and warnings
#region, #endregion Delimits / outlines regions
#line Specify line number

// preprocess.cs – using the preprocessor directives
// ---------------------------------------------------------
#define DEBUG
Using System;
Using System.IO;
Public class ReadingApp

{
public static void Main(String[] args)
{
if( args.Length < 1)
{
Console.WriteLine(“Must include file name.”);
}
else
{

#if DEBUG
Console.WriteLine( “========== DEBUG INFO==========“ );
for ( int x= 0; x < args.Length ; x++)
{
Console.WriteLine( “ Arg[{0}] = {1}”, x, args[x]);
}
Console.WriteLine( “===============================“ );
#endif
string buffer;
StreamReader myFile = File.OpenText(args[0]);
while ( buffer = myfile.ReadLine()) != null )
{
#if DEBUG
Console.Write( “{0:D3} –”, buffer.Length);
#endif
Console.WriteLine(buffer);
}
myFile.Close();
}
}
}
Collection
• A collection is a specialized class that organizes and exposes a group of
objects.
• Various collection classes are ArrayList, BitArray, HashTable, SortedList,

Queue and Stack
• They are all included in System.Collections namespace
• Like arrays, members of collections can be accessed by an index.
• Unlike arrays, collections can be resized dynamically.
• Collection Classes implement following interfaces –
IEnumerable - Supports method GetEnumerator ()

IEnumerator - Supports method MoveNext () and property Current

ArrayList
• System.Collections.ArrayList class allows to dynamically add and remove
items from a simple list.
• The list of objects managed by the Array List is a zero based collection.
• The items in the list are retrieved by accessing the item index.
• Methods
– Add()
– Remove()
– RemoveAt()
• Property
– Indexer
– Count
ArrayList

Hashtable
• System.Collections.Hashtable class represents a collection of key-and-value

pairs that are organized based on the hash code of the key.
• It uses hashing algorithm to store and index values
• It makes use of the GetHashCode() method to generate the hashcode
• Methods
– Add()
– Remove()
• Property HashTable
– Indexer
– Count

foreach loop
• Can be used to loop through in an array or collection in turn.
int [] num= {10,20,30,40};
foreach (int i in num)
{
Console.WriteLine(i);
}
//Assumes that myList is an ArrayList that contains

Strings //and variety of objects of other types
foreach (object o in myList) {
if(o.GetType() == typeof(string)){
Console.WriteLine(o.ToString());
}
}
Compile Switches
• -option or /option
• /doc:file.xml
– Used to process documentation comments
– Are generated after compiling source file and stored in a xml file
– csc /doc:firstc.xml firstc.cs
• /out:filename
– Can specify the name of the output file
– csc /out:firstprogram.exe firstc.cs
• /target:exe
• /target:library
• /target:module
• /target:winexe
– Can specify the type of output file

Compile Switches
• Error report
• /bugreport:file
– Can generate an error report, all the compilation errors are stored in the file
– csc /bugreport:error.txt firstc#.cs
• Contains
– Copy of all course code files in the compilation
– List of compiler option used in the compilation
– Version information about the compiler, run time and operating system
– Output generated by the compiler

Assemblies
• Assemblies are fundamental building blocks of a .NET Framework application.
• They contain the types and resources that make up an application and
describe those contained types to the CLR.
• An assembly consists of four internal parts:

– Assembly Manifest or Metadata
– Type Metadata
– IL code
– Resource files

Class Library Assemblies
• Class Library assemblies represent sets
of types that can be referenced and
used in other assemblies.
TestDLL
TestAssembly
MyAssembly

Private and Shared Assemblies
• Assemblies can be either private or shared.
• A private assembly is an assembly that is used by one application only.
• A private assembly is integral to the application.
• Private assemblies do not have version or identity issues
• A shared assembly can be used by multiple applications.

Private and Shared Assemblies
• A shared assembly can be used by multiple applications.
• Only one copy of shared assemblies is present per machine.
• An assembly is shared by installing it to the Global Assembly Cache.
• Reasons for being in GAC

– Shared Location
– Security
– Side by Side Versioning

Strong Naming
• A strong name is a name that guarantees an assembly identity.
• Consists of
- Name of assembly
- Version number
- Public key of public/private key pair
• A strong name can be generated with sn.exe

Steps to create an Shared Assembly
• Step 1 : In the .Net IDE, from the File menu, choose New and then choose
Project. The New Project window opens.
• Step 2 : In the New Project window, select Visual C# Projects, and then
choose Class Library .Specify name as TestLib and path as
C:\SharedAssembly
(Please a create the folder SharedAssembly before)
• Step 3: Write the following code in class library

using System;
namespace TestLib
{
/// <summary>
/// Summary description for Class1.
/// </summary>
public class MathsFunction
{
public MathsFunction()
{
//
// TODO: Add constructor logic here
//
}
public int multiply(int x, int y)
{
return x*y;
}
}
}

Step 4: Compile it.
Step 5 : Move to .NET Command prompt and change path to C:\SharedAssembly\

TestLib
Step 6: Type at the given prompt sn –k testkey.snk
Step 7: In IDE,thru Solution Explorer ,open AssemblyInfo.cs and change

[assembly: AssemblyVersion("1.0.*")]
to
[assembly: AssemblyVersion("1.0.0.0")]
Step 8: Also,change [assembly: AssemblyKeyFile] to

[assembly: AssemblyKeyFile(@"C:\SharedAssembly\TestLib\testkey.snk")]

• Step 9 : Compile and Build it.
• Step 10 : Move to .NET Command Prompt and change path to

C:\SharedAssembly\TestLib\bin\Debug
• Step 11 : Give the command at the said prompt as gacutil /i TestLib.dll
• Step 12: Verify at C:\Windows\assembly , an entry for TestLib exists.

Steps for using an Shared Assembly
• Step 1: In the .Net IDE, from the File menu, choose New and then choose
Project. The New Project window opens.
• Step 2: In the New Project window, select Visual C# Projects, and then choose
Console Application and name it as TestClient.
• Step 3: From Project menu, select Add Reference to the above created dll
(thru Browse).
(dll would be present in the following path –
C:\SharedAssembly\TestLib\bin\debug\TestLib.dll)
• Step 4: Write the following code in the Console Application TestClient

using System;
namespace TestClient
{
/// <summary>
/// Summary description for Class1.
/// </summary>
class Class1
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
TestLib.MathsFunction obj = new TestLib.MathsFunction ();
Console.WriteLine (obj.multiply(5,5));
}
}
}

• Step 5 : Compile and Run the TestClient Application.

Versioning
• Step 1: In AssemblyInfo.cs of TestLib change Assembly Version to 2.0.0.0
• Step 2 : In .cs file,change in multiply() return x*y to 2*x*y
• Step 3 : Rebuild the class library and publish again using gacutil.
• Step 4: Recompile TestClient application , it now uses Version 2.0.
• Step 5 : Verify at C:\Windows\assembly , two entries for TestLib exists.

Configuration File
• Step 1: Open TestClient.sln.
• Step 2: From Project Menu, selct Add - > New Item -> Application
Configuration File and click on Open. App.config is added.
• Step 3 : Click on Start->All Programs -> Microsoft .NET SDK FrameWork ->
Documentation.
• Step 4 : Look for “bindingredirect”
• Step 5: From the given example copy and paste the entire contents between
<configuration></configuration> in App.config.

Configuration File
<configuration>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="myAssembly"
publicKeyToken="32ab4ba45e0a69a1"
culture="neutral" />
<bindingRedirect oldVersion="1.0.0.0"
newVersion="2.0.0.0"/>
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>

Configuration File
• Step 6: Change assembly name to TestLib .
• Step 7 : Change public key token. For it thru Windows Explorer, move to location
c:\Windows\assembly and select TestLib.
• Step 8: Right Click on TestLib and select Properties.Copy and Paste public key token in
App.config file.
• Step 9 : Rebuild application. Run TestClient.exe from the .NET command prompt and
path C:\SharedAssembly\TestClient\bin\debug. Version 2.0 will be used.
• Step 10: In order to use,Version 1.0,open App.config and interchange old and new
version.
• Step 11 : Rebuild application. Run TestClient.exe from the .NET command prompt and
path C:\SharedAssembly\TestClient\bin\debug. Version 1.0 will be used.

Summary
• Interface
• Properties
• Indexers
• Collections
• Introduction to Preprocessor directive
• Compiler Switches
• Assemblies
– Private
– Public
– Versioning

Thank You!


C Sharp Programming SLIDES 02 FP2005 Ver1.0

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

C Sharp Programming SLIDES 02 FP2005 Ver1.0

Transféré par

Droits d'auteur :

Formats disponibles

C Sharp Programming – Day 2

• Introduction to Preprocessor directive

Copyright © 2005, 2 ER/CORP/CRS/LA30FC/003

An interface is a collection of abstract methods that is used to define the

The methods of an interface are defined in the classes or structs that

Copyright © 2005, 3 ER/CORP/CRS/LA30FC/003

• Interfaces can be used as a means to provide some inheritance features with

• Multiple interfaces can be implemented with a class, thus gaining functionality

Copyright © 2005, 4 ER/CORP/CRS/LA30FC/003

Interface_ Modifer interface Interface_ identifier : base_interface

The interface body contains the members of the interface. An interface

Copyright © 2005, 5 ER/CORP/CRS/LA30FC/003

• An interface modifier cannot be specified for an interface member.

• Interface members are defined in a class.

• An interface cannot contain constants, fields and operators. An interface

Copyright © 2005, 6 ER/CORP/CRS/LA30FC/003

class Circle : IShape {

Copyright © 2005, 7 ER/CORP/CRS/LA30FC/003

If an inherited interface is implemented in a class, the class implicitly

Copyright © 2005, 8 ER/CORP/CRS/LA30FC/003

• Handles name collisions

• Explicit interface implementations can’t be declared with abstract , virtual,

Copyright © 2005, 9 ER/CORP/CRS/LA30FC/003

public interface ITransact {

class TextBox : IDelete, ITransact {

Copyright © 2005, 10 ER/CORP/CRS/LA30FC/003

• An interface is like a pure abstract class. An interface differs from a class in a

– All the members of the interface are assumed to be public.

– They cannot contain any static members.

Copyright © 2005, 12 ER/CORP/CRS/LA30FC/003

Copyright © 2005, 13 ER/CORP/CRS/LA30FC/003

class Calculate : IAdd {

Copyright © 2005, 14 ER/CORP/CRS/LA30FC/003

// property.cs – Using properties

Copyright © 2005, 15 ER/CORP/CRS/LA30FC/003

Copyright © 2005, 16 ER/CORP/CRS/LA30FC/003

Copyright © 2005, 17 ER/CORP/CRS/LA30FC/003

Copyright © 2005, 18 ER/CORP/CRS/LA30FC/003

Indexer(Class1.cs) Indexer(Class2.cs) Indexer 1

Copyright © 2005, 19 ER/CORP/CRS/LA30FC/003

An indexer is identified by it’s But a property is identified by it’s name.

An indexer is always an instance

An indexer is accessed through an

Copyright © 2005, 20 ER/CORP/CRS/LA30FC/003

#define, #undef Defines and undefines conditional symbols

#if, #elif, #else, #endif Conditionally skip sections of code

#error, #warning Issue errors and warnings

#region, #endregion Delimits / outlines regions

#line Specify line number

Copyright © 2005, 21 ER/CORP/CRS/LA30FC/003

Public class ReadingApp

Copyright © 2005, 22 ER/CORP/CRS/LA30FC/003

• Various collection classes are ArrayList, BitArray, HashTable, SortedList,

• They are all included in System.Collections namespace

• Like arrays, members of collections can be accessed by an index.

• Unlike arrays, collections can be resized dynamically.

• Collection Classes implement following interfaces –

IEnumerable - Supports method GetEnumerator ()

Copyright © 2005, 24 ER/CORP/CRS/LA30FC/003

Copyright © 2005, 25 ER/CORP/CRS/LA30FC/003

• System.Collections.Hashtable class represents a collection of key-and-value

• It uses hashing algorithm to store and index values

• It makes use of the GetHashCode() method to generate the hashcode

• Step 2 : In .cs file,change in multiply() return xy to 2x*y