PES INSTITUTE OF TECHNOLOGY (BSC) V MCA, Second IA Test, September 2014

Transcription

1 PES INSTITUTE OF TECHNOLOGY (BSC) V MCA, Second IA Test, September 2014 Topics in Enterprise Architectures-II Solution Set Faculty: Jeny Jijo 1) What is Encapsulation? Explain the two ways of enforcing encapsulation with suitable examples [10] The concept of encapsulation revolves around the notion that an object s internal data should not be directly accessible from an object instance. Rather, if the caller wants to alter the state of an object, the user does so indirectly using accessor (i.e., getter ) and mutator (i.e., setter ) methods. In C#, encapsulation is enforced at the syntactic level using the public, private, internal, and protected Encapsulation provides a way to preserve the integrity of an object s state data. Rather than defining public fields (which can easily foster data corruption), you should get in the habit of defining private data, which is indirectly manipulated using one of two main techniques: Define a pair of accessor (get) and mutator (set) methods. Define a.net property. class Employee // Field data. private string empname;... // Accessor (get method) public string GetName() return empname; // Mutator (set method) public void SetName(string name) // Do a check on incoming value // before making assignment. if (name.length > 15) Console.WriteLine("Error! Name must be less than 16 characters!"); else empname = name; This technique requires two uniquely named methods to operate on a single data point. To test your new methods, update your Main() method as follows: static void Main(string[] args) Console.WriteLine("***** Fun with Encapsulation *****\n"); Employee emp = new Employee("Marvin", 456, 30000); emp.givebonus(1000); emp.displaystats(); // Use the get/set methods to interact with the object's name. emp.setname("marv"); Console.WriteLine("Employee is named: 0", emp.getname()); Console.ReadLine();

2 Because of the code in your SetName() method, if you attempted to specify more than 15 characters (see below), you would find the hard-coded error message print to the console: static void Main(string[] args) Console.WriteLine("***** Fun with Encapsulation *****\n");... // Longer than 15 characters! Error will print to console. Employee emp2 = new Employee(); emp2.setname("xena the warrior princess"); Console.ReadLine(); So far so good. You have encapsulated the private empname field using two methods named GetName() and SetName(). If you were to further encapsulate the data in the Employee class, you would need to add various additional methods (GetID(), SetID(), GetCurrentPay(), SetCurrentPay() for example). Each of the mutator methods could have within it various lines of code to check for additional business rules. While this could certainly be done, the C# language has a useful alternative notation to encapsulate class data. (2)Define a.net property empname; private int empid; private float currpay; // Properties! public string Name get return empname; set if (value.length > 15) Console.WriteLine("Error! Name must be less than 16 characters!"); else empname = value; // We could add additional business rules to the sets of these properties, // however there is no need to do so for this example. public int ID get return empid; set empid = value; public float Pay get return currpay; set currpay = value;... A C# property is composed by defining a get scope (accessor) and set scope (mutator) directly within the property itself. Notice that the property specifies the type of data it is encapsulating by what appears to be a return value. Also take note that, unlike a method, properties do not make use of parentheses (not even empty parentheses) when being defined. Consider the commentary on your current ID property: // The 'int' represents the type of data this property encapsulates. // The data type must be identical to the related field (empid). public int ID // Note lack of parentheses.

3 get return empid; set empid = value; Within a set scope of a property, you use a token named value, which is used to represent the incoming value used to assign the property by the caller. This token is not a true C# keyword, but is what is known as a contextual keyword. When the token value is within the set scope of the property, it always represents the value being assigned by the caller, and it will always be the same underlying data type as the property itself. Thus, notice how the Name property can still test the range of the string as so: public string Name get return empname; set // Here, value is really a string. if (value.length > 15) Console.WriteLine("Error! Name must be less than 16 characters!"); else empname = value; Once you have these properties in place, it appears to the caller that it is getting and setting a public point of data; however, the correct get and set block is called behind the scenes to preserve encapsulation: static void Main(string[] args) Console.WriteLine("***** Fun with Encapsulation *****\n"); Employee emp = new Employee("Marvin", 456, 30000); emp.givebonus(1000); emp.displaystats(); // Set and get the Name property. emp.name = "Marv"; Console.WriteLine("Employee is named: 0", emp.name); Console.ReadLine(); 2. (a) Explain is-a and has-a relationships with respect to inheritance? [05] Inheritance: * Classical inheritance ( is-a relationship): * Single * Multilevel * Hierarchical inheritance 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;

4 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 [05] C# supplies another keyword, sealed, that prevents inheritance from occurring. When you mark a class as sealed, the compiler will not allow you to derive from this type. For example, assume you have decided that it makes no sense to further extend the MiniVan class: // The MiniVan class cannot be extended! sealed class MiniVan : Car If you (or a teammate) were to attempt to derive from this class, you would receive a compile-time error: // Error! Cannot extend // a class marked with the sealed keyword! class DeluxeMiniVan : MiniVan 3) What are Exceptions? List out the core members of system exception class. Give an example for throwing a generic exception [10] Programming with structured exception handling involves the use of 4 interrelated entities a. A class type that represents the details of the exception that occured b. A member that throws an instance of the exception class to the caller. c. A block of code on the callers side that invokes the exception-prone member d. A block of code on the callers side that will process (or catch) the exception should it occur. e. The C# programming language offers four keywords i. Try ii. Catch iii. Throw iv. 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. 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.

5 7) InnerException: This read-only property can be used to obtain information about the previous exception that caused the current exception to occur. The previous exceptions are recorded by passing them into the constructor of the most current exception. 4) Illustrate with example, the various methods for obtaining interface references [10] * Explicit Cast static void Main() circle c=new circle( xxx ); Ipointy p; try p=(ipointy)c; catch(invalidcastexception e) as Keyword: static void Main() Hexagon h=new Hexagon( xxx ); Ipointy ip=h as Ipointy; if(ip!=null) Console.WriteLine( Points: 0, ip.points); else Console.WriteLine( Not pointy ); is Keyword: Static void Main() shape[] s = new hexagon(),new circle(),new triangle(); for(int i=0;i<s.length;i++) if (s[i] is Ipointy) Console.WriteLine(((Ipointy)s[i]).points) Else 5) Illustrate with an example, how would you build custom exceptions [10] using System; class myownexception:applicationexception //private string messagedetails; public myownexception()

6 public myownexception(string msg):base(msg) //messagedetails=msg; /*public override string Message get return(messagedetails); */ class exc1 public static void Main() int x=5,y=100; try float z=(float)x/(float)y; if(z<0.1) throw new myownexception("number is too small"); //throw new myownexception(); catch(myownexception e) Console.WriteLine(e.Message); try y=y/(y-y); catch(exception e1) Console.WriteLine("Message: 0",e1.Message); 6) How can we build finalizable and disposable types in.net Garbage Collector() [10] The supreme base class of.net, System.Object, defines a virtual method named Finalize(). The default implementation of this method does nothing whatsoever: // System.Object public class Object... protected virtual void Finalize()

7 When you override Finalize() for your custom classes, you establish a specific location to perform any necessary cleanup logic for your type. Given that this member is defined as protected, it is not possible to directly call an object s Finalize() method from a class instance via the dot operator. Rather, the garbage collector will call an object s Finalize() method (if supported) before removing the object from memory. Of course, a call to Finalize() will (eventually) occur during a natural garbage collection or when you programmatically force a collection via GC.Collect().the role of the Finalize() method is to ensure that a.net object can clean up unmanaged resources when it is garbage-collected. Thus, if you are building a class that does not make use of unmanaged entities (by far the most common case), finalization is of little use. In fact, if at all possible, you should design your types to avoid supporting a Finalize() method for the very simple reason that finalization takes time.when you allocate an object onto the managed heap, the runtime automatically determines whether your object supports a custom Finalize() method. If so, the object is marked as finalizable, and a pointer to this object is stored on an internal queue named the finalization queue. The finalization queue is a table maintained by the garbage collector that points to each and every object that must be finalized before it is removed from the heap. When the garbage collector determines it is time to free an object from memory, it examines each entry on the finalization queue and copies the object off the heap to yet another managed structure termed the finalization reachable table (often abbreviated as freachable, and pronounced effreachable ). At this point, a separate thread is spawned to invoke the Finalize() method for each object on the freachable table at the next garbage collection. Given this, it will take at the very least two garbage collections to truly finalize an object. The bottom line is that while finalization of an object does ensure an object can clean up unmanaged resources, it is still nondeterministic in nature, and due to the extra behind-the-curtains processing, considerably slower. Building Disposable Objects As you have seen, finalizers can be used to release unmanaged resources when the garbage collector kicks in. However, given that many unmanaged objects are precious items (such as raw database or file handles), it may be valuable to release them as soon as possible instead of relying on a garbage collection to occur. As an alternative to overriding Finalize(), your class could implement the IDisposable interface, which defines a single method named Dispose(): public interface IDisposable void Dispose(); If you are new to interface-based programming, Chapter 9 will take you through the details. In a nutshell, an interface is a collection of abstract members a class or structure may support. When you do support the IDisposable interface, the assumption is that when the object user is finished using the object, the object user manually calls Dispose() before allowing the object reference to drop out of scope. In this way, an object can perform any necessary cleanup of unmanaged resources without incurring the hit of being placed on the finalization queue and without waiting for the garbage collector to trigger the class s finalization logic. To illustrate the use of this interface, create a new C# Console Application named SimpleDispose. Here is an updated MyResourceWrapper class that now implements IDisposable, rather than overriding System.Object.Finalize(): // Implementing IDisposable. class MyResourceWrapper : IDisposable // The object user should call this method // when they finish with the object. public void Dispose()

8 // Clean up unmanaged resources... // Dispose other contained disposable objects... // Just for a test. Console.WriteLine("***** In Dispose! *****"); 7) 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 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.

9 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, 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. 8) Illustrate the process of implementing existing.net interface by Enumerable types[10] C# supports a keyword named foreach that allows you to iterate over the contents of any array type: // Iterate over an array of items. int[] myarrayofints = 10, 20, 30, 40;

10 foreach(int i in myarrayofints) Console.WriteLine(i); While it may seem that only array types can make use of this construct, the truth of the matter is any type supporting a method named GetEnumerator() can be evaluated by the foreach construct public class Garage private Car[] cararray = new Car[4]; public Garage() // Fill with some Car objects upon startup. cararray[0] = new Car("Rusty", 30); cararray[1] = new Car("Clunker", 55); cararray[2] = new Car("Zippy", 30); cararray[3] = new Car("Fred", 30); public class Program static void Main(string[] args) Garage carlot = new Garage(); // Hand over each car in the collection? foreach (Car c in carlot) Console.WriteLine("0 is going 1 MPH", c.petname, c.currentspeed); Console.ReadLine(); //This interface informs the caller that the object's subitems can be enumerated. public interface IEnumerable IEnumerator GetEnumerator(); As you can see, the GetEnumerator() method returns a reference to yet another interface named System.Collections.IEnumerator. This interface provides the infrastructure to allow the caller to traverse the internal objects contained by the IEnumerable-compatible container: // This interface allows the caller to obtain a container's subitems. public interface IEnumerator bool MoveNext (); // Advance the internal position of the cursor. object Current get; // Get the current item (read-only property). void Reset (); // Reset the cursor before the first member.