Category: csharp

C# – Polymorphism ”; Previous Next The word polymorphism means having many forms. In object-oriented programming paradigm, polymorphism is often expressed as ”one interface, multiple functions”. Polymorphism can be static or dynamic. In static polymorphism, the response to a function is determined at the compile time. In dynamic polymorphism, it is decided at run-time. Static Polymorphism The mechanism of linking a function with an object during compile time is called early binding. It is also called static binding. C# provides two techniques to implement static polymorphism. They are − Function overloading Operator overloading We discuss operator overloading in next chapter. Function Overloading You can have multiple definitions for the same function name in the same scope. The definition of the function must differ from each other by the types and/or the number of arguments in the argument list. You cannot overload function declarations that differ only by return type. The following example shows using function print() to print different data types − Live Demo using System; namespace PolymorphismApplication { class Printdata { void print(int i) { Console.WriteLine(“Printing int: {0}”, i ); } void print(double f) { Console.WriteLine(“Printing float: {0}” , f); } void print(string s) { Console.WriteLine(“Printing string: {0}”, s); } static void Main(string[] args) { Printdata p = new Printdata(); // Call print to print integer p.print(5); // Call print to print float p.print(500.263); // Call print to print string p.print(“Hello C++”); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Printing int: 5 Printing float: 500.263 Printing string: Hello C++ Dynamic Polymorphism C# allows you to create abstract classes that are used to provide partial class implementation of an interface. Implementation is completed when a derived class inherits from it. Abstract classes contain abstract methods, which are implemented by the derived class. The derived classes have more specialized functionality. Here are the rules about abstract classes − You cannot create an instance of an abstract class You cannot declare an abstract method outside an abstract class When a class is declared sealed, it cannot be inherited, abstract classes cannot be declared sealed. The following program demonstrates an abstract class − Live Demo using System; namespace PolymorphismApplication { abstract class Shape { public abstract int area(); } class Rectangle: Shape { private int length; private int width; public Rectangle( int a = 0, int b = 0) { length = a; width = b; } public override int area () { Console.WriteLine(“Rectangle class area :”); return (width * length); } } class RectangleTester { static void Main(string[] args) { Rectangle r = new Rectangle(10, 7); double a = r.area(); Console.WriteLine(“Area: {0}”,a); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Rectangle class area : Area: 70 When you have a function defined in a class that you want to be implemented in an inherited class(es), you use virtual functions. The virtual functions could be implemented differently in different inherited class and the call to these functions will be decided at runtime. Dynamic polymorphism is implemented by abstract classes and virtual functions. The following program demonstrates this − Live Demo using System; namespace PolymorphismApplication { class Shape { protected int width, height; public Shape( int a = 0, int b = 0) { width = a; height = b; } public virtual int area() { Console.WriteLine(“Parent class area :”); return 0; } } class Rectangle: Shape { public Rectangle( int a = 0, int b = 0): base(a, b) { } public override int area () { Console.WriteLine(“Rectangle class area :”); return (width * height); } } class Triangle: Shape { public Triangle(int a = 0, int b = 0): base(a, b) { } public override int area() { Console.WriteLine(“Triangle class area :”); return (width * height / 2); } } class Caller { public void CallArea(Shape sh) { int a; a = sh.area(); Console.WriteLine(“Area: {0}”, a); } } class Tester { static void Main(string[] args) { Caller c = new Caller(); Rectangle r = new Rectangle(10, 7); Triangle t = new Triangle(10, 5); c.CallArea(r); c.CallArea(t); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Rectangle class area: Area: 70 Triangle class area: Area: 25 Print Page Previous Next Advertisements ”;

C# – Properties ”; Previous Next Properties are named members of classes, structures, and interfaces. Member variables or methods in a class or structures are called Fields. Properties are an extension of fields and are accessed using the same syntax. They use accessors through which the values of the private fields can be read, written or manipulated. Properties do not name the storage locations. Instead, they have accessors that read, write, or compute their values. For example, let us have a class named Student, with private fields for age, name, and code. We cannot directly access these fields from outside the class scope, but we can have properties for accessing these private fields. Accessors The accessor of a property contains the executable statements that helps in getting (reading or computing) or setting (writing) the property. The accessor declarations can contain a get accessor, a set accessor, or both. For example − // Declare a Code property of type string: public string Code { get { return code; } set { code = value; } } // Declare a Name property of type string: public string Name { get { return name; } set { name = value; } } // Declare a Age property of type int: public int Age { get { return age; } set { age = value; } } Example The following example demonstrates use of properties − Live Demo using System; namespace tutorialspoint { class Student { private string code = “N.A”; private string name = “not known”; private int age = 0; // Declare a Code property of type string: public string Code { get { return code; } set { code = value; } } // Declare a Name property of type string: public string Name { get { return name; } set { name = value; } } // Declare a Age property of type int: public int Age { get { return age; } set { age = value; } } public override string ToString() { return “Code = ” + Code +”, Name = ” + Name + “, Age = ” + Age; } } class ExampleDemo { public static void Main() { // Create a new Student object: Student s = new Student(); // Setting code, name and the age of the student s.Code = “001”; s.Name = “Zara”; s.Age = 9; Console.WriteLine(“Student Info: {0}”, s); //let us increase age s.Age += 1; Console.WriteLine(“Student Info: {0}”, s); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Student Info: Code = 001, Name = Zara, Age = 9 Student Info: Code = 001, Name = Zara, Age = 10 Abstract Properties An abstract class may have an abstract property, which should be implemented in the derived class. The following program illustrates this − Live Demo using System; namespace tutorialspoint { public abstract class Person { public abstract string Name { get; set; } public abstract int Age { get; set; } } class Student : Person { private string code = “N.A”; private string name = “N.A”; private int age = 0; // Declare a Code property of type string: public string Code { get { return code; } set { code = value; } } // Declare a Name property of type string: public override string Name { get { return name; } set { name = value; } } // Declare a Age property of type int: public override int Age { get { return age; } set { age = value; } } public override string ToString() { return “Code = ” + Code +”, Name = ” + Name + “, Age = ” + Age; } } class ExampleDemo { public static void Main() { // Create a new Student object: Student s = new Student(); // Setting code, name and the age of the student s.Code = “001”; s.Name = “Zara”; s.Age = 9; Console.WriteLine(“Student Info:- {0}”, s); //let us increase age s.Age += 1; Console.WriteLine(“Student Info:- {0}”, s); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Student Info: Code = 001, Name = Zara, Age = 9 Student Info: Code = 001, Name = Zara, Age = 10 Print Page Previous Next Advertisements ”;

C# – Inheritance ”; Previous Next One of the most important concepts in object-oriented programming is inheritance. Inheritance allows us to define a class in terms of another class, which makes it easier to create and maintain an application. This also provides an opportunity to reuse the code functionality and speeds up implementation time. When creating a class, instead of writing completely new data members and member functions, the programmer can designate that the new class should inherit the members of an existing class. This existing class is called the base class, and the new class is referred to as the derived class. The idea of inheritance implements the IS-A relationship. For example, mammal IS A animal, dog IS-A mammal hence dog IS-A animal as well, and so on. Base and Derived Classes A class can be derived from more than one class or interface, which means that it can inherit data and functions from multiple base classes or interfaces. The syntax used in C# for creating derived classes is as follows − <acess-specifier> class <base_class> { … } class <derived_class> : <base_class> { … } Consider a base class Shape and its derived class Rectangle − Live Demo using System; namespace InheritanceApplication { class Shape { public void setWidth(int w) { width = w; } public void setHeight(int h) { height = h; } protected int width; protected int height; } // Derived class class Rectangle: Shape { public int getArea() { return (width * height); } } class RectangleTester { static void Main(string[] args) { Rectangle Rect = new Rectangle(); Rect.setWidth(5); Rect.setHeight(7); // Print the area of the object. Console.WriteLine(“Total area: {0}”, Rect.getArea()); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Total area: 35 Initializing Base Class The derived class inherits the base class member variables and member methods. Therefore the super class object should be created before the subclass is created. You can give instructions for superclass initialization in the member initialization list. The following program demonstrates this − Live Demo using System; namespace RectangleApplication { class Rectangle { //member variables protected double length; protected double width; public Rectangle(double l, double w) { length = l; width = w; } public double GetArea() { return length * width; } public void Display() { Console.WriteLine(“Length: {0}”, length); Console.WriteLine(“Width: {0}”, width); Console.WriteLine(“Area: {0}”, GetArea()); } }//end class Rectangle class Tabletop : Rectangle { private double cost; public Tabletop(double l, double w) : base(l, w) { } public double GetCost() { double cost; cost = GetArea() * 70; return cost; } public void Display() { base.Display(); Console.WriteLine(“Cost: {0}”, GetCost()); } } class ExecuteRectangle { static void Main(string[] args) { Tabletop t = new Tabletop(4.5, 7.5); t.Display(); Console.ReadLine(); } } } When the above code is compiled and executed, it produces the following result − Length: 4.5 Width: 7.5 Area: 33.75 Cost: 2362.5 Multiple Inheritance in C# C# does not support multiple inheritance. However, you can use interfaces to implement multiple inheritance. The following program demonstrates this − Live Demo using System; namespace InheritanceApplication { class Shape { public void setWidth(int w) { width = w; } public void setHeight(int h) { height = h; } protected int width; protected int height; } // Base class PaintCost public interface PaintCost { int getCost(int area); } // Derived class class Rectangle : Shape, PaintCost { public int getArea() { return (width * height); } public int getCost(int area) { return area * 70; } } class RectangleTester { static void Main(string[] args) { Rectangle Rect = new Rectangle(); int area; Rect.setWidth(5); Rect.setHeight(7); area = Rect.getArea(); // Print the area of the object. Console.WriteLine(“Total area: {0}”, Rect.getArea()); Console.WriteLine(“Total paint cost: ${0}” , Rect.getCost(area)); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Total area: 35 Total paint cost: $2450 Print Page Previous Next Advertisements ”;

C# – Anonymous Methods ”; Previous Next We discussed that delegates are used to reference any methods that has the same signature as that of the delegate. In other words, you can call a method that can be referenced by a delegate using that delegate object. Anonymous methods provide a technique to pass a code block as a delegate parameter. Anonymous methods are the methods without a name, just the body. You need not specify the return type in an anonymous method; it is inferred from the return statement inside the method body. Writing an Anonymous Method Anonymous methods are declared with the creation of the delegate instance, with a delegate keyword. For example, delegate void NumberChanger(int n); … NumberChanger nc = delegate(int x) { Console.WriteLine(“Anonymous Method: {0}”, x); }; The code block Console.WriteLine(“Anonymous Method: {0}”, x); is the body of the anonymous method. The delegate could be called both with anonymous methods as well as named methods in the same way, i.e., by passing the method parameters to the delegate object. For example, nc(10); Example The following example demonstrates the concept − Live Demo using System; delegate void NumberChanger(int n); namespace DelegateAppl { class TestDelegate { static int num = 10; public static void AddNum(int p) { num += p; Console.WriteLine(“Named Method: {0}”, num); } public static void MultNum(int q) { num *= q; Console.WriteLine(“Named Method: {0}”, num); } public static int getNum() { return num; } static void Main(string[] args) { //create delegate instances using anonymous method NumberChanger nc = delegate(int x) { Console.WriteLine(“Anonymous Method: {0}”, x); }; //calling the delegate using the anonymous method nc(10); //instantiating the delegate using the named methods nc = new NumberChanger(AddNum); //calling the delegate using the named methods nc(5); //instantiating the delegate using another named methods nc = new NumberChanger(MultNum); //calling the delegate using the named methods nc(2); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Anonymous Method: 10 Named Method: 15 Named Method: 30 Print Page Previous Next Advertisements ”;

C# – Enums ”; Previous Next An enumeration is a set of named integer constants. An enumerated type is declared using the enum keyword. C# enumerations are value data type. In other words, enumeration contains its own values and cannot inherit or cannot pass inheritance. Declaring enum Variable The general syntax for declaring an enumeration is − enum <enum_name> { enumeration list }; Where, The enum_name specifies the enumeration type name. The enumeration list is a comma-separated list of identifiers. Each of the symbols in the enumeration list stands for an integer value, one greater than the symbol that precedes it. By default, the value of the first enumeration symbol is 0. For example − enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat }; Example The following example demonstrates use of enum variable − Live Demo using System; namespace EnumApplication { class EnumProgram { enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat }; static void Main(string[] args) { int WeekdayStart = (int)Days.Mon; int WeekdayEnd = (int)Days.Fri; Console.WriteLine(“Monday: {0}”, WeekdayStart); Console.WriteLine(“Friday: {0}”, WeekdayEnd); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Monday: 1 Friday: 5 Print Page Previous Next Advertisements ”;

C# – Encapsulation ”; Previous Next Encapsulation is defined ”as the process of enclosing one or more items within a physical or logical package”. Encapsulation, in object oriented programming methodology, prevents access to implementation details. Abstraction and encapsulation are related features in object oriented programming. Abstraction allows making relevant information visible and encapsulation enables a programmer to implement the desired level of abstraction. Encapsulation is implemented by using access specifiers. An access specifier defines the scope and visibility of a class member. C# supports the following access specifiers − Public Private Protected Internal Protected internal Public Access Specifier Public access specifier allows a class to expose its member variables and member functions to other functions and objects. Any public member can be accessed from outside the class. The following example illustrates this − Live Demo using System; namespace RectangleApplication { class Rectangle { //member variables public double length; public double width; public double GetArea() { return length * width; } public void Display() { Console.WriteLine(“Length: {0}”, length); Console.WriteLine(“Width: {0}”, width); Console.WriteLine(“Area: {0}”, GetArea()); } }//end class Rectangle class ExecuteRectangle { static void Main(string[] args) { Rectangle r = new Rectangle(); r.length = 4.5; r.width = 3.5; r.Display(); Console.ReadLine(); } } } When the above code is compiled and executed, it produces the following result − Length: 4.5 Width: 3.5 Area: 15.75 In the preceding example, the member variables length and width are declared public, so they can be accessed from the function Main() using an instance of the Rectangle class, named r. The member function Display() and GetArea() can also access these variables directly without using any instance of the class. The member functions Display() is also declared public, so it can also be accessed from Main() using an instance of the Rectangle class, named r. Private Access Specifier Private access specifier allows a class to hide its member variables and member functions from other functions and objects. Only functions of the same class can access its private members. Even an instance of a class cannot access its private members. The following example illustrates this − Live Demo using System; namespace RectangleApplication { class Rectangle { //member variables private double length; private double width; public void Acceptdetails() { Console.WriteLine(“Enter Length: “); length = Convert.ToDouble(Console.ReadLine()); Console.WriteLine(“Enter Width: “); width = Convert.ToDouble(Console.ReadLine()); } public double GetArea() { return length * width; } public void Display() { Console.WriteLine(“Length: {0}”, length); Console.WriteLine(“Width: {0}”, width); Console.WriteLine(“Area: {0}”, GetArea()); } }//end class Rectangle class ExecuteRectangle { static void Main(string[] args) { Rectangle r = new Rectangle(); r.Acceptdetails(); r.Display(); Console.ReadLine(); } } } When the above code is compiled and executed, it produces the following result − Enter Length: 4.4 Enter Width: 3.3 Length: 4.4 Width: 3.3 Area: 14.52 In the preceding example, the member variables length and width are declared private, so they cannot be accessed from the function Main(). The member functions AcceptDetails() and Display() can access these variables. Since the member functions AcceptDetails() and Display() are declared public, they can be accessed from Main() using an instance of the Rectangle class, named r. Protected Access Specifier Protected access specifier allows a child class to access the member variables and member functions of its base class. This way it helps in implementing inheritance. We will discuss this in more details in the inheritance chapter. Internal Access Specifier Internal access specifier allows a class to expose its member variables and member functions to other functions and objects in the current assembly. In other words, any member with internal access specifier can be accessed from any class or method defined within the application in which the member is defined. The following program illustrates this − Live Demo using System; namespace RectangleApplication { class Rectangle { //member variables internal double length; internal double width; double GetArea() { return length * width; } public void Display() { Console.WriteLine(“Length: {0}”, length); Console.WriteLine(“Width: {0}”, width); Console.WriteLine(“Area: {0}”, GetArea()); } }//end class Rectangle class ExecuteRectangle { static void Main(string[] args) { Rectangle r = new Rectangle(); r.length = 4.5; r.width = 3.5; r.Display(); Console.ReadLine(); } } } When the above code is compiled and executed, it produces the following result − Length: 4.5 Width: 3.5 Area: 15.75 In the preceding example, notice that the member function GetArea() is not declared with any access specifier. Then what would be the default access specifier of a class member if we don”t mention any? It is private. Protected Internal Access Specifier The protected internal access specifier allows a class to hide its member variables and member functions from other class objects and functions, except a child class within the same application. This is also used while implementing inheritance. Print Page Previous Next Advertisements ”;

C# – Generics ”; Previous Next Generics allow you to define the specification of the data type of programming elements in a class or a method, until it is actually used in the program. In other words, generics allow you to write a class or method that can work with any data type. You write the specifications for the class or the method, with substitute parameters for data types. When the compiler encounters a constructor for the class or a function call for the method, it generates code to handle the specific data type. A simple example would help understanding the concept − Live Demo using System; using System.Collections.Generic; namespace GenericApplication { public class MyGenericArray<T> { private T[] array; public MyGenericArray(int size) { array = new T[size + 1]; } public T getItem(int index) { return array[index]; } public void setItem(int index, T value) { array[index] = value; } } class Tester { static void Main(string[] args) { //declaring an int array MyGenericArray<int> intArray = new MyGenericArray<int>(5); //setting values for (int c = 0; c < 5; c++) { intArray.setItem(c, c*5); } //retrieving the values for (int c = 0; c < 5; c++) { Console.Write(intArray.getItem(c) + ” “); } Console.WriteLine(); //declaring a character array MyGenericArray<char> charArray = new MyGenericArray<char>(5); //setting values for (int c = 0; c < 5; c++) { charArray.setItem(c, (char)(c+97)); } //retrieving the values for (int c = 0; c< 5; c++) { Console.Write(charArray.getItem(c) + ” “); } Console.WriteLine(); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − 0 5 10 15 20 a b c d e Features of Generics Generics is a technique that enriches your programs in the following ways − It helps you to maximize code reuse, type safety, and performance. You can create generic collection classes. The .NET Framework class library contains several new generic collection classes in the System.Collections.Generic namespace. You may use these generic collection classes instead of the collection classes in the System.Collections namespace. You can create your own generic interfaces, classes, methods, events, and delegates. You may create generic classes constrained to enable access to methods on particular data types. You may get information on the types used in a generic data type at run-time by means of reflection. Generic Methods In the previous example, we have used a generic class; we can declare a generic method with a type parameter. The following program illustrates the concept − Live Demo using System; using System.Collections.Generic; namespace GenericMethodAppl { class Program { static void Swap<T>(ref T lhs, ref T rhs) { T temp; temp = lhs; lhs = rhs; rhs = temp; } static void Main(string[] args) { int a, b; char c, d; a = 10; b = 20; c = ”I”; d = ”V”; //display values before swap: Console.WriteLine(“Int values before calling swap:”); Console.WriteLine(“a = {0}, b = {1}”, a, b); Console.WriteLine(“Char values before calling swap:”); Console.WriteLine(“c = {0}, d = {1}”, c, d); //call swap Swap<int>(ref a, ref b); Swap<char>(ref c, ref d); //display values after swap: Console.WriteLine(“Int values after calling swap:”); Console.WriteLine(“a = {0}, b = {1}”, a, b); Console.WriteLine(“Char values after calling swap:”); Console.WriteLine(“c = {0}, d = {1}”, c, d); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Int values before calling swap: a = 10, b = 20 Char values before calling swap: c = I, d = V Int values after calling swap: a = 20, b = 10 Char values after calling swap: c = V, d = I Generic Delegates You can define a generic delegate with type parameters. For example − delegate T NumberChanger<T>(T n); The following example shows use of this delegate − Live Demo using System; using System.Collections.Generic; delegate T NumberChanger<T>(T n); namespace GenericDelegateAppl { class TestDelegate { static int num = 10; public static int AddNum(int p) { num += p; return num; } public static int MultNum(int q) { num *= q; return num; } public static int getNum() { return num; } static void Main(string[] args) { //create delegate instances NumberChanger<int> nc1 = new NumberChanger<int>(AddNum); NumberChanger<int> nc2 = new NumberChanger<int>(MultNum); //calling the methods using the delegate objects nc1(25); Console.WriteLine(“Value of Num: {0}”, getNum()); nc2(5); Console.WriteLine(“Value of Num: {0}”, getNum()); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Value of Num: 35 Value of Num: 175 Print Page Previous Next Advertisements ”;

C# – Exception Handling ”; Previous Next An exception is a problem that arises during the execution of a program. A C# exception is a response to an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero. Exceptions provide a way to transfer control from one part of a program to another. C# exception handling is built upon four keywords: try, catch, finally, and throw. try − A try block identifies a block of code for which particular exceptions is activated. It is followed by one or more catch blocks. catch − A program catches an exception with an exception handler at the place in a program where you want to handle the problem. The catch keyword indicates the catching of an exception. finally − The finally block is used to execute a given set of statements, whether an exception is thrown or not thrown. For example, if you open a file, it must be closed whether an exception is raised or not. throw − A program throws an exception when a problem shows up. This is done using a throw keyword. Syntax Assuming a block raises an exception, a method catches an exception using a combination of the try and catch keywords. A try/catch block is placed around the code that might generate an exception. Code within a try/catch block is referred to as protected code, and the syntax for using try/catch looks like the following − try { // statements causing exception } catch( ExceptionName e1 ) { // error handling code } catch( ExceptionName e2 ) { // error handling code } catch( ExceptionName eN ) { // error handling code } finally { // statements to be executed } You can list down multiple catch statements to catch different type of exceptions in case your try block raises more than one exception in different situations. Exception Classes in C# C# exceptions are represented by classes. The exception classes in C# are mainly directly or indirectly derived from the System.Exception class. Some of the exception classes derived from the System.Exception class are the System.ApplicationException and System.SystemException classes. The System.ApplicationException class supports exceptions generated by application programs. Hence the exceptions defined by the programmers should derive from this class. The System.SystemException class is the base class for all predefined system exception. The following table provides some of the predefined exception classes derived from the Sytem.SystemException class − Sr.No. Exception Class & Description 1 System.IO.IOException Handles I/O errors. 2 System.IndexOutOfRangeException Handles errors generated when a method refers to an array index out of range. 3 System.ArrayTypeMismatchException Handles errors generated when type is mismatched with the array type. 4 System.NullReferenceException Handles errors generated from referencing a null object. 5 System.DivideByZeroException Handles errors generated from dividing a dividend with zero. 6 System.InvalidCastException Handles errors generated during typecasting. 7 System.OutOfMemoryException Handles errors generated from insufficient free memory. 8 System.StackOverflowException Handles errors generated from stack overflow. Handling Exceptions C# provides a structured solution to the exception handling in the form of try and catch blocks. Using these blocks the core program statements are separated from the error-handling statements. These error handling blocks are implemented using the try, catch, and finally keywords. Following is an example of throwing an exception when dividing by zero condition occurs − Live Demo using System; namespace ErrorHandlingApplication { class DivNumbers { int result; DivNumbers() { result = 0; } public void division(int num1, int num2) { try { result = num1 / num2; } catch (DivideByZeroException e) { Console.WriteLine(“Exception caught: {0}”, e); } finally { Console.WriteLine(“Result: {0}”, result); } } static void Main(string[] args) { DivNumbers d = new DivNumbers(); d.division(25, 0); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Exception caught: System.DivideByZeroException: Attempted to divide by zero. at … Result: 0 Creating User-Defined Exceptions You can also define your own exception. User-defined exception classes are derived from the Exception class. The following example demonstrates this − Live Demo using System; namespace UserDefinedException { class TestTemperature { static void Main(string[] args) { Temperature temp = new Temperature(); try { temp.showTemp(); } catch(TempIsZeroException e) { Console.WriteLine(“TempIsZeroException: {0}”, e.Message); } Console.ReadKey(); } } } public class TempIsZeroException: Exception { public TempIsZeroException(string message): base(message) { } } public class Temperature { int temperature = 0; public void showTemp() { if(temperature == 0) { throw (new TempIsZeroException(“Zero Temperature found”)); } else { Console.WriteLine(“Temperature: {0}”, temperature); } } } When the above code is compiled and executed, it produces the following result − TempIsZeroException: Zero Temperature found Throwing Objects You can throw an object if it is either directly or indirectly derived from the System.Exception class. You can use a throw statement in the catch block to throw the present object as − Catch(Exception e) { … Throw e } Print Page Previous Next Advertisements ”;

C# – Interfaces ”; Previous Next An interface is defined as a syntactical contract that all the classes inheriting the interface should follow. The interface defines the ”what” part of the syntactical contract and the deriving classes define the ”how” part of the syntactical contract. Interfaces define properties, methods, and events, which are the members of the interface. Interfaces contain only the declaration of the members. It is the responsibility of the deriving class to define the members. It often helps in providing a standard structure that the deriving classes would follow. Abstract classes to some extent serve the same purpose, however, they are mostly used when only few methods are to be declared by the base class and the deriving class implements the functionalities. Declaring Interfaces Interfaces are declared using the interface keyword. It is similar to class declaration. Interface statements are public by default. Following is an example of an interface declaration − public interface ITransactions { // interface members void showTransaction(); double getAmount(); } Example The following example demonstrates implementation of the above interface − Live Demo using System.Collections.Generic; using System.Linq; using System.Text; using System; namespace InterfaceApplication { public interface ITransactions { // interface members void showTransaction(); double getAmount(); } public class Transaction : ITransactions { private string tCode; private string date; private double amount; public Transaction() { tCode = ” “; date = ” “; amount = 0.0; } public Transaction(string c, string d, double a) { tCode = c; date = d; amount = a; } public double getAmount() { return amount; } public void showTransaction() { Console.WriteLine(“Transaction: {0}”, tCode); Console.WriteLine(“Date: {0}”, date); Console.WriteLine(“Amount: {0}”, getAmount()); } } class Tester { static void Main(string[] args) { Transaction t1 = new Transaction(“001”, “8/10/2012”, 78900.00); Transaction t2 = new Transaction(“002”, “9/10/2012″, 451900.00); t1.showTransaction(); t2.showTransaction(); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Transaction: 001 Date: 8/10/2012 Amount: 78900 Transaction: 002 Date: 9/10/2012 Amount: 451900 Print Page Previous Next Advertisements ”;

C# – Indexers ”; Previous Next An indexer allows an object to be indexed such as an array. When you define an indexer for a class, this class behaves similar to a virtual array. You can then access the instance of this class using the array access operator ([ ]). Syntax A one dimensional indexer has the following syntax − element-type this[int index] { // The get accessor. get { // return the value specified by index } // The set accessor. set { // set the value specified by index } } Use of Indexers Declaration of behavior of an indexer is to some extent similar to a property. similar to the properties, you use get and set accessors for defining an indexer. However, properties return or set a specific data member, whereas indexers returns or sets a particular value from the object instance. In other words, it breaks the instance data into smaller parts and indexes each part, gets or sets each part. Defining a property involves providing a property name. Indexers are not defined with names, but with the this keyword, which refers to the object instance. The following example demonstrates the concept − Live Demo using System; namespace IndexerApplication { class IndexedNames { private string[] namelist = new string[size]; static public int size = 10; public IndexedNames() { for (int i = 0; i < size; i++) namelist[i] = “N. A.”; } public string this[int index] { get { string tmp; if( index >= 0 && index <= size-1 ) { tmp = namelist[index]; } else { tmp = “”; } return ( tmp ); } set { if( index >= 0 && index <= size-1 ) { namelist[index] = value; } } } static void Main(string[] args) { IndexedNames names = new IndexedNames(); names[0] = “Zara”; names[1] = “Riz”; names[2] = “Nuha”; names[3] = “Asif”; names[4] = “Davinder”; names[5] = “Sunil”; names[6] = “Rubic”; for ( int i = 0; i < IndexedNames.size; i++ ) { Console.WriteLine(names[i]); } Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Zara Riz Nuha Asif Davinder Sunil Rubic N. A. N. A. N. A. Overloaded Indexers Indexers can be overloaded. Indexers can also be declared with multiple parameters and each parameter may be a different type. It is not necessary that the indexes have to be integers. C# allows indexes to be of other types, for example, a string. The following example demonstrates overloaded indexers − Live Demo using System; namespace IndexerApplication { class IndexedNames { private string[] namelist = new string[size]; static public int size = 10; public IndexedNames() { for (int i = 0; i < size; i++) { namelist[i] = “N. A.”; } } public string this[int index] { get { string tmp; if( index >= 0 && index <= size-1 ) { tmp = namelist[index]; } else { tmp = “”; } return ( tmp ); } set { if( index >= 0 && index <= size-1 ) { namelist[index] = value; } } } public int this[string name] { get { int index = 0; while(index < size) { if (namelist[index] == name) { return index; } index++; } return index; } } static void Main(string[] args) { IndexedNames names = new IndexedNames(); names[0] = “Zara”; names[1] = “Riz”; names[2] = “Nuha”; names[3] = “Asif”; names[4] = “Davinder”; names[5] = “Sunil”; names[6] = “Rubic”; //using the first indexer with int parameter for (int i = 0; i < IndexedNames.size; i++) { Console.WriteLine(names[i]); } //using the second indexer with the string parameter Console.WriteLine(names[“Nuha”]); Console.ReadKey(); } } } When the above code is compiled and executed, it produces the following result − Zara Riz Nuha Asif Davinder Sunil Rubic N. A. N. A. N. A. 2 Print Page Previous Next Advertisements ”;