An Analysis of Object Oriented Metrics Using C# Programs

Transcription

1 I J C S S E I T, Vol. 5, No. 1, June 2012, pp An Analysis of Object Oriented Metrics Using C# Programs 1 SUSHIL GOEL AND 2 RAJESH VERMA 1 Associate Professor, Department of Computer Science, Dyal Singh College, Karnal, India 2 Professor & Head, Department of Computer Science & Engineering, KITM, Kurukshetra, India Abstract: Software metrics are units of measurement such as meter for length or gram for weight. Object oriented metrics are used to measure object oriented products (design, source code, test cases etc), processes (the activities of analysis, designing, coding, testing etc.) and people (efficiency or productivity of an individual professional). There are many object oriented metrics proposed by several authors. We observed that a single object oriented metric in isolation is seldom useful for a particular process, product or person. Metrics are interrelated i.e. attempts to influence one metric usually have an impact on other metrics for the same person, process or product. In this research paper, we investigate several object oriented metrics proposed by Chidamber and Kemerer [C & K], Li etc. These object oriented metrics are than applied to several C# programs. Finally, a critical analysts of the result about object oriented languages and object oriented metrics is presented. Keywords: Software Metrics, Object Oriented Metrics, C#, C&K, Li 1. INTRODUCTION The object oriented paradigm is gaining popularity day by day as is evident by more and more organizations introducing object-oriented languages into their software development practices. The key ideas of the object oriented approach are encapsulation, objects, class, inheritance, methods and messages. Main advantages of object oriented development are reusability, increased quality, simplicity, faster development, maintainable, scalable, modularity and modifiability [5]. C# (C sharp) is today s dominant object-oriented Programming language. It is first component oriented language. It is simple, flexible and type safe language. It is the only language designed for the.net framework [9, 10]. The extensive interoperability makes C# the obvious choice for most of the software developers. In this research paper, we investigate several object oriented metrics proposed by various researches [1, 3]. These metrics are applied to various C# programs and a study is made based on the results obtained by applying these metrics to C# programs.

2 84 Sushil Goel and Rajesh Verma Rest of the paper is organized in four sections. Section 2 presents a brief overview of object oriented metrics. Section 3 presents an example of C# source code. Section 4 explains results obtained by applying object oriented metrics to C# source code. Finally, section 5 presents discussion and concluding remark. 2. OBJECT ORIENTED METRICS 2.1. Chidamber and Kemerer Metrics Chidamber and Kemerer (C& K) [1, 2] proposed six object-oriented metrics which were considered as the foundation of object-oriented metrics. These metrics are : (a) Weighted Methods per class (WMC): The WMC is defined as the sum of the complexities of all the methods defined in a class. Assume a class with methods M 1, M 2, M n and C 1, C 2, C n are the complexity of the methods respectively. Then n WMC = C Complexity of the methods can be calculated by using McCabe Cyclomatic Complexity. If all method complexities are considered to be unity, then WMC is simply the count of methods defined in class. Therefore, in this case. i= 1 WMC = number of methods defined in class (b) Depth of Inheritance Tree (DIT): The DIT was defined as the maximum path or length from the node to the root of the inheritance tree. Therefore, DIT = maximum inheritance path from the specific class to the root class DIT represents the complexity of the behaviour of a class, the complexity of design of a class and potential reuse. (c) Number of Children (NOC): The NOC metric is defined as the number of immediate subclasses of a class in the class hierarchy. Therefore, NOC = number of immediate sub-classes of a class NOC measures the breadth of a class hierarchy, whereas DIT measures the depth. (d) Coupling between objects (CBO): The CBO is defined as number of classes to which a class is coupled. A class is coupled with another if the method of one class use the methods or instance variables (or attributes) of the other class. Therefore CBO = number of classes to which a class is coupled. i

3 An Analysis of Object Oriented Metrics using C# Programs 85 Here unit of measurement is class. Therefore, Multiple accesses to the same class are counted as one access. (e) Response for a class (RFC): The RFC is the number of methods of the class plus the number of methods called by any of those methods. Therefore RFC = M + R Where M is number of methods in the class R is number of remote methods directly called by methods of the class. (f) Lack of cohesion of methods (LCOM): The LCOM is a count of the number of disjoint method pairs minus the number of similar method pairs. The disjoint methods have no common instance variables or attributes while the similar methods have one or more common instance variable. Suppose a class with n methods M 1, M 2 M n and assume that I j is the set of instance variables or attributes used by method M j Set P = (I i, I j ) I i I j = φ Q = (I i, I j ) I i I j φ Then 2.2. Li Metrics R S T LCOM P Q, = if P > Q 0, otherwise Li discovered some problems with Chidamber and Kemerer metrics during the course of defining the unit definition model for the metrics. An alternative suite of object-oriented metrics was proposed by Li [3, 4]. (a) Number of Ancestor Classes (NAC): Li found two ambiguous points is the definition of DIT metric proposed by C & K. (i) Maximum length from node to root becomes unclear with multiple roots. C# does not support multiple inheritance. Therefore, this point raised by Li is resolved automatically. (ii) Conflicting goals stated in the definition of DIT metric and the viewpoints of DIT metric. The definition of DIT metric stated that DIT is the length from the node to the root of the inheritance tree but theoretical basis and viewpoints of DIT metric indicate that it measures the number of ancestor classes of a class. Therefore Li proposed NAC metric as an alternative to the DIT metric. The NAC is defined as the total number of ancestor classes from which a class inherits in the class inheritance hierarchy. The unit for the NAC metric is class.

4 86 Sushil Goel and Rajesh Verma (b) Number of descendent classes (NDC): Li found that the attribute of a class that the NOC metric captures is the number of classes that may potentially be influenced by the class because of inheritance relations. Li proposed NDC metric as an alternative to the NOC metric to remedy the insufficiency of immediate sub-class counting in NOC. The NDC is defined as the total number of descendent classes (or subclasses) of a class. (c) Number of local methods (NLM) : Li reported that WMC metric has two intentions (i) Count of local methods and (ii) Sum of internal complexity of all local methods Therefore, Li proposed two metrics namely NLM and CMC (class method complexity) to measure the two attributes that WMC metric intends to capture. The NLM is defined as the number of the local methods defined in a class which are accessible outside the class. Therefore, NLM counts the public methods defined in a class. (d) Class method complexity (CMC): The CMC is defined as the summation of the internal structural complexity of all local methods. Regardless whether they are visible outside the class or not. (e) Coupling through abstract data type (CTA): Li claimed that the unit of class used in CBO metric is difficult to justify. Therefore, Li proposed two metrics namely CTA and CTM (Coupling through message passing) as an alternative metrics. The CTA is defined as the total number of classes that are used as abstract data types in the data-attribute declaration of a class. Two classes are coupled when one class uses the other class as an abstract data type. (f) Coupling through message passing (CTM): The CTM is defined as the number of different messages sent out from a class to other classes excluding the messages sent to the objects created as local object in the local methods of the class. Two classes can be coupled because one class sends a message to an object of another class, without involving the two classes through inheritance or abstract data type. The CTM indicates that how many methods of other classes are needed to fulfill the class own functionality. 3. AN EXAMPLE OF C# SOURCE CODE using System; //Base class class student

5 An Analysis of Object Oriented Metrics using C# Programs 87 int roll; string name; public void getdata() Console.WriteLine( Enter Roll No and Name ); roll = Convert.ToInt32(Console.ReadLine()); name = Convert.ToString(Console.ReadLine()); public void display() Console.WriteLine( Roll No = 0, roll); Console.WriteLine( Name = 0, name); // Intermediate base class1 class bsc : student protected int sub1, sub2; public void readdata() getdata(); //base class method Console.WriteLine( Enter the Marks of two subjects ); sub1 = Convert.ToInt32(Console.ReadLine()); sub2 = Convert.ToInt32(Console.ReadLine()); public void putdata() display(); //base class method Console.WriteLine( Marks of subject1 0, sub1); Console.WriteLine( Marks of subject2 0, sub2); // Intermediate base class2

6 88 Sushil Goel and Rajesh Verma class bcom : student protected int sub1, sub2; public void readdata() getdata(); //base class method Console.WriteLine( Enter the Marks of two subjects ); sub1 = Convert.ToInt32(Console.ReadLine()); sub2 = Convert.ToInt32(Console.ReadLine()); public void putdata() display(); //base class method Console.WriteLine( Marks of subject1 0, sub1); Console.WriteLine( Marks of subject2 0, sub2); // Intermediate base class3 class ba : student protected int sub1, sub2; public void readdata() getdata(); //base class method Console.WriteLine( Enter the Marks of two subjects ); sub1 = Convert.ToInt32(Console.ReadLine()); sub2 = Convert.ToInt32(Console.ReadLine()); public void putdata() display(); //base class method Console.WriteLine( Marks of subject1 0, sub1); Console.WriteLine( Marks of subject2 0, sub2);

7 An Analysis of Object Oriented Metrics using C# Programs 89 // Derived class1 class total_bsc : bsc int total_marks; public void compute() total_marks = sub1 + sub2; Console.WriteLine( Sum of Marks = 0, total_marks); // Derived class2 class total_bcom : bcom int total_marks; public void compute() total_marks = sub1 + sub2; Console.WriteLine( Sum of Marks = 0, total_marks); // Derived class3 class total_ba : ba int total_marks; public void compute() total_marks = sub1 + sub2; Console.WriteLine( Sum of Marks = 0, total_marks);

8 90 Sushil Goel and Rajesh Verma class sample static void Main() total_bsc x = new total_bsc(); //object of derived class1 created Console.WriteLine( Enter the data of a B.Sc. Student ); x.readdata(); x.putdata(); x.compute(); total_bcom y = new total_bcom(); //object of derived class2 created Console.WriteLine( ); Console.WriteLine( Enter the data of a B.Com. Student ); y.readdata(); y.putdata(); y.compute(); total_ba z = new total_ba(); //object of derived class3 created Console.WriteLine( ); Console.WriteLine( Enter the data of a B.A. Student ); z.readdata(); z.putdata(); z.compute(); 4. RESULT OF OBJECT ORIENTED METRICS OBTAINED BY USING C# PROGRAM 4.1. Result of CK Metrics Result of CK Metrics is shown in Table 1 Table 1 student bsc bcom ba bsc_total bcom_total ba_total WMC DIT NOC CBO RFC LCOM

9 An Analysis of Object Oriented Metrics using C# Programs Result of Li Metrics Result of Li Metrics is shown in Table 2 Table 2 student bsc bcom ba bsc_total bcom_total ba_total NAC NDC NLM CMC CTA CTM DISCUSSION AND CONCLUDING REMARK Following are the observations made from applying the object oriented metrics proposed by C & K and refined by Li on C# programs. 1. WMC proposed by C & K has two intensions : (a) Count of local methods and (b) Sum of internal complexity of all local methods. This issue was found by Li and proposed NLM and CMC metrics. From Table 1 and Table 2, we can observed that values of WMC, NLM and CMC are same. 2. The NLM metric considers only public local methods. The private methods also shows the properties of objects but private methods are not included in this method. Therefore, NLM metric should be further divided into two metrics: (a) Number of public methods and (b) Number of private methods defined in a class 3. Li found two ambiguous points is the definition of DIT metric proposed by C & K. (a) Maximum length from node to root becomes unclear with multiple roots. C# does not support multiple inheritance. Therefore, this point raised by Li is resolved automatically. (b) Conflicting goals stated in the definition of DIT metric and the viewpoints of DIT metric. The definition of DIT metric stated that DIT is the length from the node to the root of the inheritance tree but theoretical basis and viewpoints of DIT metric indicate that it measures the number of ancestor classes of a class. Therefore Li proposed NAC metric as an alternative to the DIT metric. From Table 1 and Table 2, we observed that DIT and NAC both have the same value, therefore both serve the same purpose.

10 92 Sushil Goel and Rajesh Verma 4. Li found that the attribute of a class that the NOC metric captures is the number of classes that may potentially be influenced by the class because of inheritance relations. Li proposed NDC metric as an alternative to the NOC metric to remedy the insufficiency of immediate sub-class counting in NOC. From Table 1 and Table 2, we observed that values of NOC and NDC are same. 5. Li claimed that the unit of class used in CBO metric is difficult to justify. Therefore, Li proposed two metrics namely CTA and CTM (Coupling through message passing) as an alternative metrics. From Table 1 and Table 2, we observed that values of CBO and CTA are same but values of CTM and CBO are different. 6. In Li metrics suit, there is no alternative metrics to NOC and LCOM. References [1] S. R. Chidamber and C. F. Kemerer, A Metrics Suite for Object Oriented Design, IEEE Transactions on Software Engineering, 20(6), 1994, [2] S. R. Chidamber and C. F. Kemerer, Towards a Metrics Suite for Object Oriented Design, Proceeding on Object Oriented Programming Systems, Languages and Applications Conference (OOPSLA 91), ACM, 26(11), 1991, [3] W.Li, Another Metric Suite for Object Oriented Programming, The Journal of System and Software, 44(2), 1998, [4] W.Li and S. Henry, Object Oriented Metrics which Predict Maintainability, The Journal of Systems and Software, 23(2), 1993, [5] Tieng Wei Koh, Mohd Hasan Selamat, Abdul Azim Abdul Ghani, Rusli Addullah, Review of Complexity Metrics for Object Oriented Software Products, IJCSNS International Journal of Computer Science and Network Security, 8(11), [6] Dr. Rakesh Kumar, Gurvinder Kaur, Comparing Complexity in Accordance with Object Oriented Metrics, International Journal of Computer Applications ( ) 15(8), [7] Arti Chhikara, R.S. Chhillar, Sujata Khatri Applying Object Oriented Metrics to C# (C Sharp) Programs, International Journal of Computer Technology and Application, 2(3), [8] K. K. Aggarwal, Yogesh Singh, Arvinder Kaur, Ruchika Malhotra, Empirical Study of Object Oriented Metrics, Vol. 5., Journal of Object Technology, No. 8, November-December [9] Sushil Goel, Introduction to.net, Natraj Publishing House, First Edition, [10] Patrick Naughton & Herbert Schildt, C# 3.0: The Complete Reference, Mc Graw-Hill Professional, UK, 2008.