MEASURE YOUR CODE USING CODE METRICS. CS 599 Software Metrics and Models Hana Alarifi

Transcription

1 MEASURE YOUR CODE USING CODE METRICS CS 599 Software Metrics and Models Hana Alarifi

2 Overview Quality code is the top priority for a good developer. The code must be not only bug free code but also understandable, maintainable, extensible, less complex and loosely coupled code. How do you measure your code? How can you check the quality of my code? What are the signs to discover bad practices in you code? Using CODE METRICS can be the answer for the questions above.

3 Advantages of Code Metrics Tool Identify the design flaws or bad practices, which might require attention, either immediately or at a later point of time. Some of the common code bad practices are Long Method, Duplicate Code, Large Class, and Dead Code. Identify the complexity and maintainability of your code It ll give an insight of the code maintainability and complexity. Increase the Code Review efficiency.

4 Code Metrics Measurements Code Metrics is a tool which analyzes a project, measures the complexity and provides us better insight into the code. To generate code metrics for a project, we can go to Analyze Menu > Calculate Code Metrics.

5 Maintainability Index The maintainability index metric can be used as an overall quality measurer in combination with cyclomatic complexity and lines of code metric results. Maintainability Index Risk Evaluation 00 To 09 Low maintainability 10 To 19 Moderate maintainability 20 To 100 Good maintainability

6 Cyclomatic Complexity Cyclomatic complexity measures the code complexity. The cyclomatic complexity metric is used for calculations on method level. It helps the developer to identify the complexity of the code and risk factors in method level. Cyclomatic Complexity >50 21 To 50 Risk Evaluation Very high risky code which is an un testable Risky code it include more complex logic 11 To 20 Moderate risk 1 To 10 a simple program, without very much risk Example: this code has a cyclomatic complexity of 12 for just of 5 lines of code. 1.private static void GetFormattedEmployeeDetails(Employee employee) 2. { 3. if (employee!= null) 4. { 5.if (string.isnullorwhitespace(employee.firstname) && string.isnullorwhitespace(e mployee.lastname)) 6. { 7. //Build full name 8. } 9. if (string.isnullorwhitespace(employee.address1) && string. IsNullOrWhiteSpace(employee.Address2) && 10. string.isnullorwhitespace(employee.address3) && string.isn ullorwhitespace(employee.city) && 11. string.isnullorwhitespace(employee.country) && string.isnu llorwhitespace(employee.zipcode)) 12. { 13. //Build complete address 14. } 15. if (string.isnullorwhitespace(employee. )) 16. { 17. //Check Valid ..Regex check 18. } 19. if (string.isnullorwhitespace(employee.phone)) 20. { 21. //Do Something 22. } 23. } 24. }

7 Example By adding more logic to the previous example, complexity will be increased. To rectify this bad code, we have to refractor the code.

8 Example After refactor the code into a small number of portions as shown. Now cyclomatic complexity is only 2 for same 5 lines of code. 1. static void Main() 2. { 3. Employee employee = new Employee(); 4. GetFormattedEmployeeDetails(employee); 5. } 6. private static void GetFormattedEmployeeDetai ls(employee employee) 7. { 8. if (employee!= null) 9. { 10. FullEmployeeName(employee); GetCompleteAddress(employee); IsValid (employee); GetPhone(employee); 17. } 18.}

9 Depth of Inheritance Depth of inheritance describes the number of classes from which a specific type inherits functionality. The idea is that if more types exist in an inheritance hierarchy, the code will likely be more difficult to maintain as a result. Depth of Inheritance Risk Evaluation >4 Base types are critical 3 To 4 Base types are still okay 1 To 2 Base types are good

10 Class Coupling Class coupling is a measure of how many dependencies classes in a single class uses. Class Coupling Risk Evaluation > 30 (on member level) AND > 80 (on type level) Dependencies are critical 10 To 30 (on member level) AND 10 To 80 (on type level) Dependencies are still okay 00 To 09 Dependencies are good

11 Example The Program class has dependency with employee class, so class coupling is static void Main() 2. { 3. Employee employee = new Employee(); 4. GetFormattedEmployeeDetails(employee); 5.}

12 Line of Code The fewer the lines of code in a method, the more maintainability it has. This metric will be calculated at method level and calculation is not the exact line of code we write in C#, it is actually based upon the line number of IL code. The calculation does not include comments, white space, line break etc. Lines of Code Risk Evaluation >20 Lines of code is critical 11 To 20 Lines of code is still okay 1 To 10 Lines of code is good

13 Example This code contains comments and white spaces. When we run a metrics, lines of code result is 4. 1.static void Main() 2.{ 3. //Employee object have employee related details 4. Employee employee = new Employee(); EmployeeBusinessService employeebusinessservice = new EmployeeBusinessService(); //Validate the complete employee object and get formatted employee details 9. GetFormattedEmployeeDetails(employee); //Save employee details 12. employeebusinessservice.saveemployee(employee) ; }

14 Additional Tools Tool For Maintainable Index ( Free extension) Microsoft Code Lens Code Health Indicator is a free extension. This feature will provide the quick information about your code. It means provide code maintainable index on the fly for the methods, properties or classes.

15 Additional Tools Tool For Cyclomatic Complexity This is a Code Metrices which helps to monitor the code complexity. As you type, the method complexity "health" is updated, and the complexity is shown near the method.

16 References MarcPrieur.MicrosoftCodeLensCodeHealthIndicator