PES INSTITUTE OF TECHNOLOGY (BSC) V MCA, Second IA Test, OCTOBER 2017 Programming Using C#.NET (13MCA53) Solution Set Faculty: Jeny Jijo

Transcription

1 PES INSTITUTE OF TECHNOLOGY (BSC) V MCA, Second IA Test, OCTOBER 2017 Programming Using C#.NET (13MCA53) Solution Set Faculty: Jeny Jijo 1. What is Encapsulation? Explain the two ways of enforcing encapsulation with suitable examples.[10] Encapsulation: * Hides unnecessary implementation details from the object user. (i.e.) no need to worry about the numerous lines of code that are working behind the scenes to carry out the work. * Data Protection (i.e.) Rather than defining public fields, you should get in the habit of defining private data fields, which are indirectly manipulated by the caller using one of the two main techniques. ** Define a pair of Traditional Accessor and Mutator methods ** Define a named property Defining a pair of Traditional Accessor and Mutator methods: Defining an accessor (get method) and mutator (set method) is one way of accessing the private data field. (e.g.) public class employee private string name; public string getname() return name; public void setname(string n) name=n; class empapp public static void Main() employee o=new employee(); o.setname( XYZ ); Console.WriteLine(o.getname()); Property: * Drawbacks of Traditional accessor and mutator methods are: * Code manually * Users have to remember that they have to use accessor methods to work with data members. * Using a property, a programmer can get access to data members as though they are public fields. (e.g.) public class employee private string name; public string name1 get return name; set name=value;

2 The get and set logic is both public. * A property that has only a getter is called a read-only property * A property that has only a setter is called write-only property * Static properties 2. (a) Explain is-a and has-a relationships with respect to inheritance? [5] Classical inheritance ( is-a relationship): * Single * Multilevel * Hierarchical inheritance When we establish is-a relationships between classes, we are building a dependency between two or more class types. The basic idea behind the classical inheritance is that new classes may extend the functionality of existing classes. Containment / Delegation model ( has-a relationship): (e.g.) public class deductions public int deduct() return 1000; public class employee protected deductions empdeduct=new deductions(); public deductions ded get return empdeduct; set empdeduct=value; public class containment public static void Main() employee ob=new employee(); Console.WriteLine(ob.ded.deduct()); (b) How do you prevent inheritance using sealed classes? Explain with example. [5] Sealed Class: * A class that cannot be sub-classed is called Sealed class. * This is achieved in C# using the modifier sealed. * Declaring a class sealed prevents any unwanted extensions to the class (e.g.) sealed class A.. Sealed Method: * When an instance method declaration includes the sealed modifier, the method is said to be a sealed method.

3 * It means a derived class cannot override this method, but a sealed method can be used to override an inherited virtual method with the same signature. * Always used along with override modifer. (e.g.) class A public virtual void add() class B:A public sealed override void add(). 3 (a) What are Exceptions? List out the core members of system exception class [6] Programming with structured exception handling involves the use of 4 interrelated entities A class type that represents the details of the exception that occured A member that throws an instance of the exception class to the caller. A block of code on the callers side that invokes the exception-prone member A block of code on the callers side that will process(or catch) the exception should it occur. The C# programming language offers four keywords Try Catch Throw Finally System.Exception: * All user and system-defined exceptions are derived from System.Exception base class. Core Members of System.Exception: 1)HelpLink: This virtual property returns a URL to a help file describing the error in full detail. 2) Message: This virtual read-only (get) property returns the textual description of a given error. The error message itself is set as a constructor parameter. 3) Source: This virtual property returns the name of the assembly that threw the exception. 4) TargetSite: This read-only property returns a MethodBase type, which describes numerous details about the method that threw the exception. 5) StackTrace: This virtual read-only property contains a string that identifies the sequence of calls that triggered the exception. 6) Data: This virtual read-only property retrieves a collection of key/value pairs that provides additional, user-defined information about the exception. 7) InnerException: This read-only property can be used to obtain information about the previous exception that caused the current exception to occur.

4 (b) Give an example for throwing a generic exception. [04] class Program static void Main(string[]args) int[] a = new int[2]; int c; try a[0] = 0; a[1] = 1; Console.WriteLine("Enter a value:"); c = int.parse(console.readline()); if (c < 0) throw new ArgumentOutOfRangeException("value not within the range"); if (c == 0) throw new DivideByZeroException("Cannot divide by zero"); else Console.WriteLine("Division = 0", a[1] / c); catch (IndexOutOfRangeException e1) Console.WriteLine(e1.Message); catch (ArgumentOutOfRangeException e2) Console.WriteLine(e2.Message); catch (DivideByZeroException e3) Console.WriteLine(e3.Message); catch (Exception e) Console.WriteLine("Exception in general"); Console.WriteLine(e.Message); finally Console.ReadLine(); Console.WriteLine("\n\nFinally section will always occur");

5 4) Explain i) Indexers [5] Indexers are location indicators which are used to access class objects just like accessing elements in an array. They are useful in cases where a class is a container for other objects 1. An indexer takes an index argument and looks like an array 2. The indexer is declared using the name this Egpublic double this[int idx] get... set... The implementation rules for get and set are same as for properties. The parameter inside the square bracket is used as index. ii) Partial classes [5] Partial class is a class that enables you to specify the definition of a class,structure or interface in two or more source files. All d source files, each containing a section of the class defn, combine when the application is complete. Required when working on large projects Distributes a class over multiple separate files allowing developers to work on the class simultaneously Declare a partial class using keyword partial public partial class student public void marks() 5 (a) What are Extension methods? [3] Helps to extend a class without creating a new derived class Work as a static method, but is invoked with an instance of the extended class It uses the this keyword before its first parameter Only a class that has static member and implements the this keyword in the first parameter of a static method can use the extension methods static class myclass public static int extmethod(this string Number ) return Int32.Parse(Number); public static int mystaticmethod(string Number) return Int32.Parse(Number); class mainclass static void Main(strings [] args) string Number = 100 ; int ext=number.extmethod(); C.Wl(ext); int stat = myclass.mystaticmethod(number); C.Wl(stat);

6 (b) Explain the types of compile time and runtime polymorphism [7] Types of Polymorphism: Operation polymorphism: * This is been implemented using overloaded methods and operators * The overloaded methods are selected for invoking by matching arguments, in terms of number, type and order. * This information is known to the compiler at the time of compilation and therefore the compiler is able to select and bind the appropriate method to the object for a particular call at compile time itself. (Early binding, Static binding, static linking or Compile-time polymorphism) * Multiple methods with the same name are created. However, the parameters on each method vary. using System; class employee public int empid=101; public string empname="xyz"; public employee() Console.WriteLine("01",empid, empname); public void emp (int id) Console.WriteLine("0",id); public void emp (int id, string name) Console.WriteLine("01",id, name); class operation public static void Main() employee ob=new employee(); ob.emp(20); ob.emp(30,"sss"); Inclusion Polymorphism: * This is been implemented using virtual functions. * The selection of appropriate method is done dynamically at runtime * The decision on exactly which method to call is delayed until runtime. (Late binding, Dynamic binding, runtime polymorphism) C# permits upcasting of an object of a derived class to an object of its base class. class Base class Derived:Base

7 Base b=new Derived(); // upcasting Derived d=new Base(); // Error using System; class fruits public virtual void display() Console.WriteLine("FRUITS"); class apple:fruits public override void display() Console.WriteLine("APPLE"); class orange:fruits public override void display() Console.WriteLine("ORANGE"); class inclusion public static void Main() //fruits ob=new fruits(); //ob.display(); fruits ob=new apple(); ob.display(); fruits ob=new orange(); ob.display(); 6) What are abstract classes? Bring out the difference between abstract base classes and interfaces. [10] Interface Types vs. Abstract Base Classes when a class is marked as abstract, it may define any number of abstract members to provide a polymorphic interface to all derived types. However, even when a class does define a set of abstract members, it is also free to define any number of constructors, field data, nonabstract members (with implementation), and so on. Interfaces, on the other hand, only contain abstract member definitions. The polymorphic interface established by an abstract parent class suffers from one major limitation in that only derived types support the members defined by the abstract parent. However, in larger software systems, it is very common to develop multiple class hierarchies that have no common parent beyond System.Object. Given that abstract members in an abstract base class apply only to derived types, we have no way to configure types in different hierarchies to support the same polymorphic interface. By way of example, assume you have defined the following abstract class: abstract class CloneableType // Only derived types can support this // "polymorphic interface." Classes in other // hierarchies have no access to this abstract // member. public abstract object Clone(); Given this definition, only members that extend CloneableType are able to support the Clone() method. If you create a new set of classes that do not extend this base class, you can t gain this polymorphic interface. Also you may recall, that C# does not support multiple inheritance for classes. Therefore, if you wanted to create a MiniVan that is-a Car and is-a CloneableType, you are unable to do so: // Nope! Multiple inheritance is not possible in C# // for classes. public class MiniVan : Car, CloneableType

8 As you would guess, interface types come to the rescue. Once an interface has been defined, it can be implemented by any class or structure, in any hierarchy, within any namespace or any assembly (written in any.net programming language). As you can see, interfaces are highly polymorphic. Consider the standard.net interface named ICloneable defined in the System namespace. This interface defines a single method named Clone(): public interface ICloneable object Clone(); If you examine the.net Framework 4.0 SDK documentation, you ll find that a large number of seemingly unrelated types (System.Array, System.Data.SqlClient.SqlConnection, System.OperatingSystem, System.String, etc.) all implement this interface. Although these types have no common parent (other than System.Object), we can treat them polymorphically via the ICloneable interface type. For example, if you had a method named CloneMe() that took an ICloneable interface parameter, you could pass this method any object that implements said interface. Consider the following simple Program class defined within a Console Application named ICloneableExample: class Program static void Main(string[] args) Console.WriteLine("***** A First Look at Interfaces *****\n"); // All of these classes support the ICloneable interface. string mystr = "Hello"; OperatingSystem unixos = new OperatingSystem(PlatformID.Unix, new Version()); System.Data.SqlClient.SqlConnection sqlcnn = new System.Data.SqlClient.SqlConnection(); // Therefore, they can all be passed into a method taking ICloneable. CloneMe(myStr); CloneMe(unixOS); CloneMe(sqlCnn); Console.ReadLine(); private static void CloneMe(ICloneable c) // Clone whatever we get and print out the name. object theclone = c.clone(); Console.WriteLine("Your clone is a: 0", theclone.gettype().name); When you run this application, the class name of each class prints out to the console, via the GetType() method you inherit from System.Object (Chapter 15 provides full coverage of this method and.net reflection services). Another limitation of traditional abstract base classes is that each derived type must contend with the set of abstract members and provide an implementation. To see this problem, recall the shapes hierarchy we defined in Chapter 6. Assume we defined a new abstract method in the Shape base class named GetNumberOfPoints(), which allows derived types to return the number of points required to render the shape: abstract class Shape... // Every derived class must now support this method! public abstract byte GetNumberOfPoints(); Clearly, the only type that has any points in the first place is Hexagon. However, with this update,

9 every derived class (Circle, Hexagon, and ThreeDCircle) must now provide a concrete implementation of this function even if it makes no sense to do so. 7) (a) What are Pointers? Is it possible to use pointers in C#? Explain [3] When you wish to work with pointers in C#, you must specifically declare a block of unsafe code using the unsafe keyword (any code that is not marked with the unsafe keyword is considered safe automatically). For example, the following Program class declares a scope of unsafe code within the safe Main() method: class Program static void Main(string[] args) unsafe // Work with pointer types here! // Can't work with pointers here! In addition to declaring a scope of unsafe code within a method, you can build structures, classes, type members, and parameters that are unsafe. // This entire structure is "unsafe" and can be used only in an unsafe context. public unsafe struct Node public int Value; public Node* Left; public Node* Right; (b) Explain the concept of delegates with example [7] A delegate is a type-safe object that points to another method in the application, which can be invoked at a later time.(i.e) contains the details of the method rather than data. * A delegate type maintains 3 pieces of information: * name of the method on which it makes calls. * arguments * return value * Once created, it may dynamically invoke the method it points at run time. * It can be used to hold reference to a method of any class. The only requirement is that its signature must match the signature of the method. Creating and using delegates invloves 4 steps 1) Delegate declaration 2) Delegate instantiation 3) Delegate methods definition 4) Delegate invocation A delegate defines a class using the class System.Delegate as a base class Delegate methods are any functions whose signature matches the delegate signature exactly. The delegate instance holds the reference to delegate methods(invoke the methods indirectly) Defining a Delegate: modifier delegate return-type delegate-name(parameters);

10 public delegate int binaryop(int x,int y); public class simplemath public static int add(int x,int y) return x+y; public static int sub(int x,int y) return x-y; class program static void Main() binaryop o=new binaryop(simplemath.add); binaryop a=new binaryop(simplemath.sub); Console.WriteLine( Sum is 0, o(10,10)); Console.WriteLine( Difference is 0, a(20,10)); MultiCast Delegates Also known as combinable delegates must satisfy the following conditions The return type of the delegate must be void None of the parameters of the delegate type can be declared as output parameters,using out keyword If D is a delegate that satisfies the above conditions and d1,d2,d3,d4 are instances of D, then the stmnts d3=d1+d2; // d3 refers to 2 methods d4=d3-d2; // d4 refers to only d1 method Are valid provided that the delegate instances d1 and d2 have already been initialized with method references and d3 and d4 contain null reference For a multicast delegate instance that was created by combining 2 delegates, the invocation list is formed by concatenating the invocation list of the two operands of the addition operation delegates are invoked in the order they are add delegate void A(); class DM Static public void display() C.WL( New delhi ); Static public void print() C.WL( New York ); class Mtest public static void Main() A m1= new A(DM.display); A m2= new A(DM.print); A m3= m1+m2; A m4= m2+m1; A m5= m3 - m2; m3(); m4(); m5();

11 8) What are events in C#? Write a C# program to explain how delegates are used for event handling [5] Events: * It is a delegate type class member that is used by the object or class to provide a notification to other objects that an event has occurred.events are declared using the simple event declaration format: modifier event type event-name; * type of an event declaration must be a delegate type * event is a keyword that signifies that the event name is an event Egpublic event EventHandler Click; public event RateChange Rate; using System; public delegate void A(string str) //delegation declaration first class Eventclass public event A status; // declaration of the event public void TriggerEvent() if(status!= null) status("event Triggered"); class EventTest public static void Main() Eventclass ec=new Eventclass(); EventTest et=new EventTest(); ec.status+= new A(et.Eventcatch); ec.triggerevent(); public void Eventcatch(string str) Console.WriteLine(str); *****************************