C#

C#.NET 2.
Why .NET?
Web Services. Security. Built in Server side Controls. Optimized User Interface. (Browser Type & versions) Improved performance. Built in Classes. .asx templates to standardize page layouts. Ease in integration of other MS products.
Luminus IT Education 2
.NET Framework
Luminus IT Education
Common Language Runtime

The .NET Framework provides a run-time environment called the Common Language Runtime, which manages the execution of code and provides services that make the development process easier
Introduction to C#
C# is a new generation language designed to work within the .NET framework. Strongly typed, object-oriented language that is a direct descendent of other languages including C, C++, and Java. C# was developed by a Anders Hejlsberg. The C# language is highly expressive in implementing all the features of a modern object-oriented programming language, It provides support for encapsulation, inheritance, and polymorphism. C# has about 80 keywords and a dozen built-in data types.
Cont..
C# includes language features such as single inheritance, multiple interfaces, and compilation to an intermediate format. There are some C# features that exist primarily to work within the .NET Framework, and it could even be argued that some features of .NET exist because of C#. C# features, such as versioning, COM support, and Multilanguage development, which cant be found in Java. Following is a list of features that C# and Java share in common, which are intended to improve on C++.
Cont..
Both languages compile to an intermediate format that is run in a managed environment. Each runtime environment provides support for automatic garbage collection. All classes in both languages descend from Object and are allocated on the heap when they are created. Everything must belong to a class, which means that there are no global functions or constants. Both languages abandoned multiple inheritances, although implementing multiple interfaces is allowed. Both C# and Java use exceptions for error handling. Arrays are bound checked. Inline code comments are used to produce API documentation. They both use packages/namespaces to avoid type collision.
Cont..
In C# all methods start with a capital letter C# has Object.Equals(), whereas Java has object.equals(). C# has Object.Finalize(), whereas Java has Object.finalize(). C# has Object.ToString(), whereas Java has Object.toString().
Differences with JAVA

C# provides XML style documentation for inline documentation that is more flexible than Javadocs. This greatly simplifies the creation of online and print reference documentation for an application. C# provides support for directly accessing memory using pointers. Although seen as potentially dangerous, pointers can provide programmers with an extra level of control that isnt available in Java. It uses the unsafe keyword to warn the garbage collector not to collect or move objects in memory that are referenced by the pointer until they are released.
Getting Started.
To make sure that the SDK has been installed properly open a command line window (cmd.exe) and type csc.exe /help on the command prompt. If the program has been installed properly, you should see something similar to Figure
10
Cont..
The csc.exe program is the main C# compiler for the .NET SDK. It has several switches that allow you to specify compiler options. By typing /help, the program will list all the different compiler options available as shown in above picture.
11
Creating Your First C# Program

Open up your favorite text editor and type the following code, then save the file as Hello.cs. If you dont have a favorite text editor, Notepad will do.
12
Compiling and Running the Program

As mentioned previously, the command line compiler included in the Microsoft .NET Framework SDK is called csc.exe. To compile the application, simply type the following on the command prompt: csc /out:Hello.exe Hello.cs
out switch, which specifies the output for our compiled file. 2nd argument is the name of our source file to be compiled
13
Cont..
All C# programs are JIT compiled, unlike Java where it is interpreted at most times by a Java runtime. Therefore, after compiling the program, all you have to do is type the output filename at the command prompt to execute it.
Output I wrote my first C# program at: 5/14/2002 2:24:37 PM
Cont..
If you execute this same program with some arguments an error dialogue box will pop up similar to Figure
Runtime Error Dialogue Box Just click on Cancel and you should see the following
15
Cont..
C:\test>Hello Praveen Kumar I wrote my first C# program at: 5/15/2002 2:27:01 AM Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array. at Hello.Main(String[] args)
16
Cont..
The error message doesnt really tell us where the problem is. To solve this, we can recompile the Hello.cs with the /debug switch. csc /debug Hello.cs By adding this debug switch the compiler will generate an extra file with the .pdb extension, which contains debugging information. After running the program again, it should display more information, as shown:
Cont..
C:\test>Hello Praveen Kumar I wrote my first C# program at: 5/15/2002 2:48:33 AM Unhandled Exception: System.IndexOutOfRangeException:Index was outside the bounds of the array. at Hello.Main(String[] args) in C:\test\Hello.cs:line 17
18
Using the Debugger Tool

At the time of this writing, the current version of the .NET SDK is 1.30705, and it offers two debugging tools. Theres a command line tool called cordbg.exe and a version with a graphical user interface called dbgclr.exe that can be found in the GUIDebug subdirectory of the Framework SDK Since it is much more convenient to use the dbgclr.exe because of its graphical user interface, well try to debug our program using this tool.To debug your application follow these steps:
19
Cont..
1. In Explorer, launch the debugger, which can be found in <InstalledDirectory>/Microsoft.NET/FrameworkSDK/Gui Debug/dbgclr.exe. Click on Debug | Program To Debug. This will let you specify the program you wish to debug and enter in any arguments the program needs. You can enter Hello.exe under Program, and type some names under the Arguments field. After doing so, you should see something similar to Figure
2.
20
Cont..
3. Click on OK. Once thats done, you can start debugging the program by clicking on Debug | Start F5, or by simply pressing the F5 key. This will start the debugging process and the program will halt once it encounters an error. Click on Break.The program will pause and highlight the piece of code that caused the error. We can visibly see where the problem is occurring. Now we can set a breakpoint at this location in the code so that we can watch whats causing it.To do this, rightclick on the line and select InsertBreakpoint from the menu
4. 5.
21
Cont..
6. Now we can start the debugging process again, and as soon as the debugger encounters the breakpoint it will automatically stop the program. The debugger provides the Locals window to display all the values of all the local variables. This is extremely useful because you get a glimpse of the variable states at a specific time of code execution. This is the key in analyzing and solving the bug. Output C:\test>Hello Praveen Kumar I wrote my first C# program at: 5/15/2002 4:24:11 AM You wanted to say hello to Praveen Kumar
22
Classes, Objects, and Namespaces

The C# programming language is based on the objectoriented programming Model. It describes how objects are created based on classes and how access to data and methods is controlled. It also covers how classes are logically grouped into namespaces.
23
Classes and Objects

A class is an abstraction that represents the common data and behavior of a real-world entity. What is Data and Behavior? Data: Real-world entities which are identified and mapped as structures or records. Behavior: subprograms are written to act upon this data Classes are the fundamental building blocks of object-oriented applications
24
Cont..
As a modern abstraction, classes reduce complexity by: Hiding away details (implementation), Highlighting essential behavior (interface), and Separating interface from implementation.
25
Declaring Classes
As mentioned previously, a class declaration encapsulates two kinds of class members: Data, otherwise known as a field, attribute, or variable, and Behavior, otherwise known as a method, operation, or service. In below Ex. fields and methods are used to represent the data and behavior members of a class. Consider the ID class given below. This class defines an abstraction that represents a personal identification and is composed of two fields and four methods. The two fields, firstName and lastName, are both of type string; the four methods simply retrieve and set the values of the two data fields.
Cont..
class ID { // Methods (behavior) string GetFirstName() { return firstName; } string GetLastName() { return lastName; } void SetFirstName(string value) { firstName = value; } void SetLastName(string value) { lastName = value; }
// Fields (data) string firstName = Praveen"; string lastName = Kumar"; }
Creating Objects
An instantiation is the creation or construction of an object based on a class declaration. This process involves two steps. First, a variable is declared in order to hold a reference to an object of a particular class. In the following example, a reference called id is declared for the class Id: ID id; Once a variable is declared, an instance of the class is explicitly created using the new operator. This operator returns a reference to an object where upon it is assigned to the reference variable. As shown here, an object of the ID class is created and a reference to that object is assigned to id:
Cont..
id = new ID(); The previous two steps, declaring a variable and creating an object, can also be coalesced into a single line of code: ID id = new ID();
29
Access Modifiers
To uphold the principle of information hiding, access to classes and class members may be controlled using modifiers that prefix the class name, method, or data field. In this section, we first examine those modifiers that control access to classes, followed by a discussion on the modifiers that control access to methods and data fields.
30
Controlling Access to Classes

In C#, each class has one of two access modifiers: public or internal. If a class is public as it is for the ID class here, then it is also visible from all other classes. class ID { ... } On the other hand, if a class is internal then it is only visible among classes that are part of the same compiled unit. It is important to point out that one or more compilation units may be compiled together to generate a single compiled unit.
Cont..
internal class ID { ... } Classes are, by default, internal; therefore, the internal modifier is optional.
32
Controlling Access to Class Members

The C# language is equipped with five access modifiers for methods and data fields. public, private, protected, internal, and protected internal. The semantics of these modifiers depends on their context, that is, whether or not the class itself is public or internal. If a class is public, its public methods and data fields are visible and, hence, accessible both inside and outside the class. Private methods and data fields, only visible within the class itself. The visibility of its Protected methods and data fields is restricted to the class itself and to its subclasses
Cont..
Internal methods and data fields are only visible among classes that are part of the same compiled unit. Methods or data fields that are protected internal have the combined visibility of internal and protected members. By default, if no modifier is specified for a method or data field then accessibility is private. If a class is internal, then access modifiers is similar to those of a public class except for one key restriction: Access is limited to those classes within the same compiled unit. Otherwise, no method or data field of an internal class is directly accessible among classes that are compiled separately.
34
Cont..
When used in conjunction with the data fields and methods of a class, access modifiers dually support the notions of information hiding and encapsulation. By making data fields private, data contained in an object is hidden from other objects in the system. Hence, data integrity is preserved. By making methods as private, access and modification to data is controlled via the methods of the class. Hence, no direct external access by other objects ensures that data behavior is also preserved.
35
Access Modifiers
36
Tip
As a rule of thumb, good class design declares data fields as private and methods as public. It is also suggested that methods to retrieve data members (called getters) and methods to change data members (called setters) be public and protected, respectively.
37
Namespaces
A namespace is a mechanism used to organize classes (even namespaces) into groups and to control the proliferation of names. This control is absolutely necessary to avoid any future name conflicts with the integration (or reuse) of other classes that may be included in an application. If a class is not explicitly included in a namespace, then it is placed into the default namespace, otherwise known as the global namespace
38
Declaring Namespaces
The following example presents a namespace declaration for the Presentation subsystem that includes two public classes, Ex. namespace Presentation { public class First { ... } public class Second { ... } }
39
Cont..
This Presentation namespace can also be nested into a Project namespace containing all three distinct subsystems as shown here: Ex.
namespace Project { namespace Presentation { public class First { ... } public class Second{ ... } } namespace Business { // Domain classes ... } }
Cont..
Access to classes and nested namespaces is made via a qualified identifier. For example, Project.Presentation provides an access path to the classes First and Second. This mechanism allows two or more namespaces to contain classes of the same name without any conflict. Have a look at the below example.
41
Cont..
namespace Compilers { namespace C { class Lexer { ... } class Parser { ... } } namespace Csharp { class Lexer { ... } class Parser { ... } } }
Cont..
A graphical representation of these qualifications.
43
Importing Namespaces
The using directive allows one namespace to access the types (classes) of another without specifying their full qualification. UsingDirective = "using" ( UsingAliasDirective | | amespaceName ) "; For example, the WriteLine method may be invoked using its full qualification, System.Console.WriteLine. With the using directive, we can specify the use of the System namespace to access the WriteLine method via its class Console:
Cont..
Ex. using System; public class Welcome { public static void Main() { Console.WriteLine( Practical guide for C#! "); } }
Declaring Partial Classes

Although declaring one class per source file is the bestpractice policy in the software Tip industry, In that case, the class is better divided among more than one file to ease development, testing, and maintenance. Using the prefix partial before the class name, different parts of a class can be distributed across different files
46
Cont..
ParserCompilationUnit.cs file (Part 1): public partial class Parser { private ILexer lexer; private IReportable errorReporter; private ISymbolTable symbolTable; // ... // Compilation Unit productions void ParseCompilationUnit() { ... } void ParseNamespace() { ... } // ... }
Cont..
ParserClass.cs file (Part 2): public partial class Parser { // Class productions void ParseClassDecl() { ... } void ParseClassMemberDecl() { ... } // ... }
48
Cont..
ParserExpr.cs file (Part 3): public partial class Parser { // Expression productions void ParseExpr() { ... } void ParseExprList() { ... } // ... } When all the 3 files are compiled together, the resulting code is the same as if the class had been written as a single source file Parser.cs:
49
Cont..
public class Parser { private ILexer lexer; private IReportable errorReporter; private ISymbolTable symbolTable; // ... // Compilation Unit productions void ParseCompilationUnit() { ... } void ParseNamespace() { ... } // ... // Class productions void ParseClassDecl() { ... } void ParseClassMemberDecl() { ... } // ... // Expression productions void ParseExpr() { ... } void ParseExprList() { ... } // ... }
50
Adding XML Documentation

The C# compiler automatically generates well-formatted documentation in XML using doc comments (///) and XML tags (<...>) that have been entered by the developers at their proper places in the source code Compile the code with fallowing command Ex. csc /target:module /doc:First.xml First.cs
51
Data Types and the Common Type System

C# is, of course, based on the Microsoft .NET framework. One of the fundamental parts of this framework is a shared Common Type System (CTS). The CTS defines how types are declared and used throughout the .NET framework and provides the cross-platform type support for which .NET was designed.
52
Cont..
53
Cont..
In C#, all data types are part of the System namespace and can be referenced. For ex, the bool data type can be referenced as System.Boolean. C# supports two kinds of types, value types and reference types. Value types hold actual data in the form of variables. They are stored in the stack by C#, which is a temporary memory space. With value types, every stored value is stored separately from all of the other stored values, and changing one will not affect another Reference types hold objects, which refer to actual data. Since an object can be referred to by multiple variables, operations using one of the variables can affect operations by the other
Cont..
class Program { static void Main(string[] args) { int i = 10; //Boxing object obj = i; // unboxing int j = Convert.ToInt32(obj); Console.WriteLine("(Boxing) obj=" + obj); Console.WriteLine("(Unboxing) j =" + j); Console.Read(); } }
55
Variables
C# works with variables in a manner similar to Java. All variables must be declared prior to use and are declared with a statement of what data type the variable is. Variables can be initialized with a default value when declared and multiple variables of the same type can be declared at the same time. There are three main types of variables: class variables, instance variables, and local variables. Class variables are prefaced with the term static and are initialized only once, when the class is initialized.
56
Cont..
Instance variables are initialized every time an instance of the class is created. The last variable type is local, and these are initialized every time the variable is declared. Ex, class SetVars { public static int a = 10; // Class variable public int b = 4; //Instance Variable }
57
Cont..
class WorkVars { static void Main() { int c; // local variable SetVars MyVars = new SetVars(); SetVars MyOtherVars = new SetVars(); } }
58
Constants
Constants in C# are basically variables that are readonly. In C#, a constant is declared by using the keyword const prior to the data type in your declaration. By specifying a variable as a constant, you can be sure that the value of the variable will not be changed from its original assignment. Ex,
class SetVars { public static int a; public int b; public const string IniFileName = "SETVARS.INI"; }
Assignment Statements
When assigning values to variables, we use the = symbol to show that the variable should be set to whatever follows the = symbol. Ex, class BoxTest { static void Main() { int Length = 10, Width = 5; int Height; Height = 2; } }
Conversions between Data Types

One of the more common functions that is necessary to perform on variables is that of conversion. There are two types of conversions possible: implicit and explicit. Another term for this would be automatic and casted conversions. Implicit conversions are used inthe following situations: The two data types are identical The two data types are compatible The destination data type is larger than the source data type
61
Cont..
Ex, using System; class ImplicitConversion { public static void Main() { byte a=1; int b=1234; int c=b; //Implicit cast double d= b; //Explicit Console.WriteLine("{0}", c); Console.WriteLine("{0}", d); } }
Cont..
Explicit conversions will attempt to convert the value stored in your source variable into the data type of your destination variable. Note: Not all conversions will be successful. Some data may be lost in the conversion. This may be in the form of truncated data following a decimal point, or modified numeric values.
63
Cont..
Ex, using System; class ExplicitConv { static void Main() { double a = 5.654321; int b; b = (int) a; Console.WriteLine("The value is {0}", b); } }
Operators
C#, much like Java, makes available a large number of operators for us to use. In C#, these are broken up into six major groups: mathematical, assignment, increment and decrement, relational, logical, and bitwise.
65
Mathematical Operators
In C#, mathematical operators perform in the same way as arithmetic operators do in Java.
66
Cont..
Ex, using System; class Operators { static void Main() { int a = 5, b = 10, c = 15; int d = a + b; int e = c - b; int f = a * e; int g = f / a; Console.WriteLine("{0}", g); Console.WriteLine("{0}", g % 2); } }
Assignment Operators
68
Cont..
Ex, class Operators { static void Main() { int a, b, c, d, e; a = 14; b = 15; c = 20; d = a + b - c; //d=9 c += d; //c=29 e = c + d; //e=38 e /= 2; //e=19 Console.WriteLine("{0}", e);
}
}
Increment and Decrement Operators

In C# (just as in Java) there are increment and decrement operators, which function exactly as they do in Java. The ++ operator increases a value by 1, and the operator decreases the value by 1.
70
Cont
Ex, class Operators { static void Main() { int a=10, b, c; b = a++; //Postfix operation c = ++a; //Prefix operation Console.WriteLine("{0}", b); Console.WriteLine("{0}", c); b = b--; //Postfix operation c = --c; //Prefix operation Console.WriteLine("{0}", b); Console.WriteLine("{0}", c); } }
Relational Operators
Relational operators basically take two values and evaluate the relationship between them.
72
Cont
Ex, using System; class Operators { static void Main() { bool a = 4 > 5; Console.WriteLine("{0}", a); } }
73
Operator Precedence Hierarchy
74
Programming Structures
Branch Statements
Branch statements, also known as Conditional statements, permit us to branch our code in a different direction based on a condition.
The if/else Statement

It tests a condition and if that condition is true, it executes either the next code statement or several code statements if they are enclosed in curly braces. If the condition does not evaluate to true, then it either skips the code segment, or executes code in an else statement.
Cont..
Ex, class Program { static void Main(string[] args) { int x = 10; if (x == 10) { Console.WriteLine("X is equal to 10"); } else { Console.WriteLine("X is not equal to 10"); } } }
Cont..
class Program { static void Main(string[] args) { int x = 1; int y = 2; if (x == 1) if (y == 2) System.Console.WriteLine("x = 1, y = 2"); else System.Console.WriteLine("x = 1, y != 2"); else System.Console.WriteLine("x != 1"); } }
Nested If/Else
77
The switch Statement

A switch statement will evaluate an expression and execute the corresponding case statement. Switch statements are a common alternative to using nested if/else constructs for testing multiple conditions. C# switch statements can use any of the following data types: sbyte, byte, short, ushort, int, uint, long, ulong, char, string, or enum.
78
Cont..
Ex, class Program { static void Main(string[] args) { String testString = "Test"; switch (testString) { case "Hello": System.Console.WriteLine("The string says Hello."); break; case "Test": System.Console.WriteLine("The string says Test"); break; default: System.Console.WriteLine("The string is unknown"); break; } } }
While Loop
The while loop executes a segment of code 0 or more times, based on the outcome of a boolean control expression. The while loop is called an indeterminate loop and is usually used when the program will be unaware of the number of iterations of the loop until it has been entered.
80
Cont..
Ex, class Program { static void Main(string[] args) { bool noMoreRecords = false; while (!noMoreRecords) { Console.WriteLine("Inside While Loop"); Console.Read(); } } }
81
The do-while Loop

The do-while loop executes a segment of code 1 or more times. It is similar to the while loop, except that the control condition is evaluated after the loop body had run once.
Ex, class Program { static void Main(string[] args) { bool noMoreRecords = false ; do { Console.WriteLine("Inside do"); Console.Read(); } while (!noMoreRecords); } }
82
The for Loop

The for loop is a pretest determinate loop. Ex, class Program { static void Main(string[] args) { for (int x = 1; x <= 31; x++) { System.Console.WriteLine("Dec {0}", x); } Console.Read(); } }
83
The goto Statement

The goto statement transfers control to a code segment marked with a label.
Ex,
class Program { static void Main(string[] args) { int x = 4; goto Print; Console.WriteLine("Test"); // This line will be skipped x = 5; // This line will be skipped Print: Console.WriteLine(x); Console.Read(); } }
84
The continue Statement

The continue statement performs in the same way as the break statement, but rather than exit the loop entirely, it returns control to the start of the loop. Ex,
class Program { static void Main(string[] args) { for (int i = 0; i < 10; i++) { int x = i; if (x == 0) continue; System.Console.WriteLine("loop iteration " + i); } Console.Read(); } }
The return statement

When a program calls a method, the program flow moves to the start of that function. For the flow to return to the code that called the method, it must encounter a return statement. Once this is encountered, the flow returns to the code that called the method.
86
Cont..
Ex, class Program { static void Main(string[] args) { Console.WriteLine("Main Line 1"); MethodSample(); Console.WriteLine("Main Line 2"); Console.Read(); } static void MethodSample() { Console.WriteLine("MethodSample line 1"); return; } }
The foreach Statement

Ex, int[] IntArray = {1,2,3,4,5,6}; for (int i = 0; i < 6; i++) { System.Console.WriteLine(IntArray[i]); } Console.Read(); foreach (int i in IntArray) { System.Console.WriteLine(i); } Console.Read(); As you can see, with the foreach statement we dont need prior knowledge of the array size
Arrays
An array is a series of objects consisting of the same data types. Individual objects in the series, called elements, are referenced by their index into the array.
Declaring and Initializing Arrays

data_type[] arrayname; Ex,
int[] IntegerArray;
Cont..
The most common way is by using the new operator, which will initialize an array, but not assign any values to it. The following code will create an integer array with four elements: int[] IntegerArray = new int[4]; If you knew the values you wished to assign the array elements at the time you created the array, you can also use the following syntax. int[] integerArray = {1,2,3,4};
Cont..
To access an individual element of an array you specify the index of that element. IntegerArray[1].ToString();
91
Collections.
ArrayList - The classic problem with the Array type is its fixed size. If you do not know in advance how many objects an array will hold, you run the risk of declaring either too small an array (and running out of room) or too large an array (and wasting memory). - Your program might be asking the user for input, or gathering input from a web site. As it finds objects (strings, books, values, etc.), you will add them to the array, but you have no idea how many objects you'll collect in any given session. The classic fixed-size array is not a good choice, as you can't predict how large an array you'll need.
Cont..
The ArrayList class is an array whose size is dynamically increased as required.
class Program { static void Main(string[] args) { ArrayList ObjAL = new ArrayList(); for (int i = 1; i <= 10; i++) { ObjAL.Add(i); } foreach (int x in ObjAL) { Console.WriteLine(x + " "); } Console.Read(); } }
Hashtable
A hashtable is a dictionary optimized for fast retrieval.
using System.Collections; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Hashtable Ht = new Hashtable(); Ht.Add("ID", "1"); Ht.Add("Name", "Praveen"); Console.WriteLine("ID : " + Ht["ID"]); Console.WriteLine("NAME : " + Ht["Name"]); Console.Read(); } } }
Exceptions
Exception handling permits you to execute code and handle error conditions prior to the program exiting. In C# exception handling requires three code blocks: try, catch, and finally. Catching Exceptions To catch an exception you would execute the code you want to execute in a try block, and follow this block with a catch block. The code in which the exception is likely to occur must be encased in a try block followed by a catch block
95
Cont..
Typically you would end with a finally block to perform any cleanup code that must occur regardless if an exception was thrown or not. Ex,
96
Cont..
static void Main(string[] args) { try { Console.WriteLine("Enter the number to print Multiplication Chart:"); int a = Convert.ToInt32(Console.ReadLine()); int b; for (int i = 1; i <= 10; i++) { b = a * i; Console.WriteLine(a + " x " + i + " = " + b); } Console.Read(); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.Read(); } finally { // Clean Up activities. } } } Luminus IT Education
97
Throwing Exceptions
Exceptions are not just thrown by the Framework libraries. In fact, you can, and should, throw exceptions yourself if the situation requires.
98
Object Oriented Programming

Inheritance Inheritance is a relationship between classes. In this relationship, a child class inherits the members and methods of a parent class.
99
Cont..
class Program { static void Main(string[] args) { try { int a = Convert.ToInt32(Console.ReadLine()); int b = Convert.ToInt32(Console.ReadLine()); if (b == 0) { throw new FormatException("My Message- Invalid values"); } else { int c = a / b; Console.WriteLine("Result:"+c.ToString()); Console.Read(); } } catch (FormatException ex) { Console.WriteLine("----- We caught FormatException -----"); Console.WriteLine(ex.Message.ToString()); Console.Read(); } Luminus IT Education } }
100
Cont..
101
Defining Base Class

When you declare a class in C# you need to identify its base class. As we mentioned earlier, all classes in C# are derived from Object. If you derive a class directly from Object, there is no need to specify it. If you derive a class from any other class you must indicate the parent class in the class declaration. Both Java and C# offer support for single inheritance. a C# class is allowed to have only one base class. C# uses a colon (:) to indicate a base class.
102
Cont..
// C# base class public class Employee { protected string name ; protected string ssn ; }
103
Cont..
// C# derived class public class Salaried : Employee { protected double salary ; public Salaried(string name, string ssn, double salary) { this.name = name ; this.ssn = ssn ; this.salary = salary ; } } Salaried s = new Salaried( "Albert","123456", 800.00 ) ;
Calling Base Class Constructors

In our previous code example we did not give the Employee class any constructors. The Salaried class constructor does all the work of initializing variables in both the Employee and Salaried classes. In order to prevent duplication of code, we will implement a constructor in the Employee class. This new constructor will initialize the name and ssn variables that are common to all Employee objects
105
Cont..
// C# base class public class Employee { protected string name ; protected string ssn ; public Employee(string name, string ssn) { System.Console.WriteLine("Employee") ; this.name = name ; this.ssn = ssn ; } }
Cont..
// C# derived class public class Salaried : Employee { protected double salary ; public Salaried(string name, string ssn, double salary) : base(name, ssn) { System.Console.WriteLine("Salaried") ; this.salary = salary ; } }
107
Cont..
public class Test { static void Main() { new Salaried("Albert","123456",80000.00 ) ; } } Output: Employee Salaried
108
Polymorphism
Polymorphism comes from two Greek root words:poly means many and morphe means form. The idea is that something may take on many forms. If we apply our definition of polymorphism we see that the Employee class takes on four specialized forms (Salaried, Commissioned, Hourly, and TruckDriver). It is quite common that we will use base class references to refer to derived class objects.
109
Cont..
Ex, Employee [] employees = new Employee[4] ; employees[0] = new Salaried("Becky","123456789",80000) ; employees[1] = new Commissioned("Chuck","234567891",20000,.05) ; employees[2] = new Hourly("Deb","345678912",19.75) ; employees[3] = new TruckDriver("Earl","456789123",20000,0.30) ;
Cont..
If you look closely you see that although we created all of these different kinds of objects, we created only one kind of reference to access them - employee references.
111
Abstract Classes
// C# abstract class public abstract class Employee {
protected string name ; protected string ssn ; protected Employee(string name, string ssn)
{ System.Console.WriteLine("Employee") ; this.name = name ; this.ssn = ssn ; } }
112

C#

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

C#

Uploaded by

Copyright:

Available Formats

C#.NET 2.

Common Language Runtime

Differences with JAVA

Creating Your First C# Program

Compiling and Running the Program

Using the Debugger Tool

Classes, Objects, and Namespaces

Classes and Objects

Controlling Access to Classes

Controlling Access to Class Members

Declaring Partial Classes

Adding XML Documentation

Data Types and the Common Type System

Conversions between Data Types

Increment and Decrement Operators

Operator Precedence Hierarchy

The if/else Statement

The switch Statement

The do-while Loop

The for Loop

The goto Statement

The continue Statement

The return statement

The foreach Statement

Declaring and Initializing Arrays

Object Oriented Programming

Defining Base Class

Calling Base Class Constructors

{ System.Console.WriteLine("Employee") ; this.name = name ; this.ssn = ssn ; } }

You might also like